C# IBigInteger.ToByteArrayUnsigned方法代码示例

        /// <summary>
        /// Creates a ECDH public key parameters from the given encoded point.
        /// </summary>
        /// <param name="encodedPoint">The encoded point.</param>
        /// <param name="publicKeyParamSet">The public key param set.</param>
        /// <param name="hashAlgorithm">The hash algorithm.</param>
        /// <param name="symmetricKeyAlgorithm">The symmetric key algorithm.</param>
        /// <returns></returns>
        public static ECDHPublicKeyParameters Create(IBigInteger encodedPoint, DerObjectIdentifier publicKeyParamSet, 
            HashAlgorithmTag hashAlgorithm, SymmetricKeyAlgorithmTag symmetricKeyAlgorithm)
        {
            var curve = ECKeyPairGenerator.FindECCurveByOid(publicKeyParamSet);
            var point = curve.Curve.DecodePoint(encodedPoint.ToByteArrayUnsigned());

            return new ECDHPublicKeyParameters(point, publicKeyParamSet, hashAlgorithm, symmetricKeyAlgorithm);
        }

        public ECPrivateKeyStructure(
			IBigInteger key)
        {
            if (key == null)
                throw new ArgumentNullException("key");

            this.seq = new DerSequence(
                new DerInteger(1),
                new DerOctetString(key.ToByteArrayUnsigned()));
        }

        public byte[] ConvertOutput(
			IBigInteger result)
        {
            byte[] output = result.ToByteArrayUnsigned();

            if (forEncryption)
            {
                int outSize = GetOutputBlockSize();

                // TODO To avoid this, create version of BigInteger.ToByteArray that
                // writes to an existing array
                if (output.Length < outSize) // have ended up with less bytes than normal, lengthen
                {
                    byte[] tmp = new byte[outSize];
                    output.CopyTo(tmp, tmp.Length - output.Length);
                    output = tmp;
                }
            }

            return output;
        }

        public static byte[] IntegerToBytes(
            IBigInteger s,
			int			qLength)
        {
            byte[] bytes = s.ToByteArrayUnsigned();

            if (qLength < bytes.Length)
            {
                byte[] tmp = new byte[qLength];
                Array.Copy(bytes, bytes.Length - tmp.Length, tmp, 0, tmp.Length);
                return tmp;
            }
            if (qLength > bytes.Length)
            {
                byte[] tmp = new byte[qLength];
                Array.Copy(bytes, 0, tmp, tmp.Length - bytes.Length, bytes.Length);
                return tmp;
            }

            return bytes;
        }

        public IntArray(IBigInteger bigInt, int minIntLen)
        {
            if (bigInt.SignValue == -1)
                throw new ArgumentException(@"Only positive Integers allowed", "bigInt");

            if (bigInt.SignValue == 0)
            {
                _ints = new int[] { 0 };
                return;
            }

            var barr = bigInt.ToByteArrayUnsigned();
            var barrLen = barr.Length;

            var intLen = (barrLen + 3) / 4;
            _ints = new int[System.Math.Max(intLen, minIntLen)];

            var rem = barrLen % 4;
            var barrI = 0;

            if (0 < rem)
            {
                var temp = (int) barr[barrI++];
                while (barrI < rem)
                {
                    temp = temp << 8 | (int) barr[barrI++];
                }
                _ints[--intLen] = temp;
            }

            while (intLen > 0)
            {
                var temp = (int) barr[barrI++];
                for (var i = 1; i < 4; i++)
                {
                    temp = temp << 8 | (int) barr[barrI++];
                }
                _ints[--intLen] = temp;
            }
        }

        /**
        * Return the passed in value as an unsigned byte array.
        *
        * @param value value to be converted.
        * @return a byte array without a leading zero byte if present in the signed encoding.
        */
        public static byte[] AsUnsignedByteArray(
			IBigInteger n)
        {
            return n.ToByteArrayUnsigned();
        }

 internal static void EncodeInteger(IBcpgOutputStream bcpgOut, IBigInteger val)
 {
     bcpgOut.WriteShort((short)val.BitLength);
     bcpgOut.Write(val.ToByteArrayUnsigned());
 }

        private static ECPoint DecodePoint(IBigInteger encodedPoint, DerObjectIdentifier oid)
        {
            var curve = ECKeyPairGenerator.FindECCurveByOid(oid);
            if (curve == null)
                throw new PgpException(oid.Id + " does not match any known curve.");
            if (!(curve.Curve is FPCurve))
                throw new PgpException("Only FPCurves are supported.");

            return curve.Curve.DecodePoint(encodedPoint.ToByteArrayUnsigned());
        }