C# BigInteger.ToByteArray方法代码示例

        public byte[] EncodeInt(BigInteger bigInt)
        {
            byte[] ret = new byte[32];

            for (int i = 0; i < ret.Length; i++)
            {
                if (bigInt.Sign < 0)
                {
                    ret[i] = 0xFF;
                }
                else
                {
                    ret[i] = 0;
                }
            }

            byte[] bytes;

            //It should always be Big Endian.
            if (BitConverter.IsLittleEndian)
            {
                bytes = bigInt.ToByteArray().Reverse().ToArray();
            }
            else
            {
                bytes = bigInt.ToByteArray().ToArray();
            }

            Array.Copy(bytes, 0, ret, 32 - bytes.Length, bytes.Length);

            return ret;
        }

        public object ConvertFrom(byte[] decimalBuf)
        {
            var bigintBytes = new byte[decimalBuf.Length - 4];
            Array.Copy(decimalBuf, 4, bigintBytes, 0, bigintBytes.Length);
            //Scale representation is an int, but System.Decimal only supports a scale of 1 byte
            var scale = decimalBuf[3];

            Array.Reverse(bigintBytes);
            var bigInteger = new BigInteger(bigintBytes);
            var isNegative = bigInteger < 0;

            bigInteger = BigInteger.Abs(bigInteger);
            bigintBytes = bigInteger.ToByteArray();
            if (bigintBytes.Length > 13 || (bigintBytes.Length == 13 && bigintBytes[12] != 0))
            {
                throw new ArgumentOutOfRangeException(
                    "decimalBuf",
                    "this java.math.BigDecimal is too big to fit into System.Decimal. Think about using other TypeAdapter for java.math.BigDecimal (e.g. J#, IKVM,...)");
            }

            var intArray = new int[3];
            Buffer.BlockCopy(bigintBytes, 0, intArray, 0, Math.Min(12, bigintBytes.Length));

            return new decimal(intArray[0], intArray[1], intArray[2], isNegative, scale);
        }

        public HKeyExchange(int exponent, string modulus, string privateExponent) :
            this()
        {
            var keys = new RSAParameters();
            Exponent = new BigInteger(exponent);
            keys.Exponent = Exponent.ToByteArray();

            Modulus = BigInteger.Parse("0" + modulus, NumberStyles.HexNumber);
            keys.Modulus = Modulus.ToByteArray();
            Array.Reverse(keys.Modulus);

            if (!string.IsNullOrWhiteSpace(privateExponent))
            {
                PrivateExponent = BigInteger.Parse("0" + privateExponent, NumberStyles.HexNumber);
                keys.D = PrivateExponent.ToByteArray();
                Array.Reverse(keys.D);

                GenerateDHPrimes(256);
                GenerateDHKeys(DHPrime, DHGenerator);
            }

            RSA = new RSACryptoServiceProvider();
            RSA.ImportParameters(keys);

            _blockSize = (RSA.KeySize -
                RSA.LegalKeySizes[0].SkipSize) / 8;
        }

 public static byte[] EncodeMPBigInteger(BigInteger value)
 {
     byte[] rawEncoding = value.ToByteArray();
     Array.Reverse(rawEncoding);
     byte[] lengthEncoded = EncodeBEWord((uint)rawEncoding.Length);
     return CombineByteArrays(lengthEncoded, rawEncoding);
 }

        public static byte[] Encrypt(byte[] input, BigInteger N, BigInteger E)
        {
            int originalsize = input.Length;
            int inputBlockLength = N.ToByteArray().Length - 1;
            int encodedBlockLength = inputBlockLength + 1;
            int blocksCount = input.Length / inputBlockLength;
            if (input.Length % inputBlockLength != 0)
            {
                blocksCount++;
                Array.Resize(ref input, blocksCount * inputBlockLength);
            }
            int headerSize = 4;
            byte[] encodedResult = new byte[blocksCount * encodedBlockLength + headerSize];
            Array.Copy(BitConverter.GetBytes(originalsize), encodedResult, 4);
            for (int i = 0; i < (input.Length / inputBlockLength) + 1; i++)
            {
                byte[] block = new byte[inputBlockLength];
                Array.Copy(input, i + inputBlockLength, block, 0, inputBlockLength);
                BigInteger message = new BigInteger(block);
                byte[] bytes = BigInteger.ModPow(message, E, N).ToByteArray();
                Array.Copy(bytes, 0, encodedResult, headerSize + i * encodedBlockLength, bytes.Length);
            }

            return encodedResult;
        }

        /// <summary>
        /// Creates instance of RSA cryptography algorithm class
        /// </summary>
        /// <param name="p">Prime number P</param>
        /// <param name="q">Prime number Q</param>
        public RSA(BigInteger p, BigInteger q)
        {
            P = p;
            Q = q;

            KeySize = (p > q) ? (p.ToByteArray().Length * 8) : (q.ToByteArray().Length * 8);
        }

 public void BigIntegerConstruction(BigInteger bi)
 {
     var biBytes = new byte[32];
     bi.ToByteArray().CopyTo(biBytes, 0);
     var hash = new Hash256(bi);
     Assert.AreElementsEqual(biBytes, hash.Bytes);
 }

        public static byte[] Base58ToByteArray(string base58)
        {
            BigInteger bi2 = new BigInteger(0);
            string b58 =new string(B58);

            foreach (char c in base58)
            {
                if (b58.IndexOf(c) != -1)
                {
                    bi2 = BigInteger.Multiply(bi2, Big58);
                    bi2 = BigInteger.Add(bi2, b58.IndexOf(c));
                }
                else
                    return null;
            }

            byte[] bb = bi2.ToByteArray();
            if (bb[bb.Length-1]==0)
            {
                byte[] withoutZero = new byte[bb.Length-1];
                Buffer.BlockCopy(bb, 0, withoutZero, 0, bb.Length - 1);
                bb = withoutZero;
            }
            Array.Reverse(bb);
            return bb;
        }

 public static byte[] EncodeInt(BigInteger y)
 {
     byte[] nin = y.ToByteArray();
     var nout = new byte[Math.Max(nin.Length, 32)];
     Array.Copy(nin, nout, nin.Length);
     return nout;
 }

 private void encryptFile(object sender, RoutedEventArgs e)
 {
     var bytes = File.ReadAllBytes(filePathOpen.Text);
     var open_key = File.ReadAllLines(SenderPath + @"\open_key.txt");
     var D = new BigInteger(open_key[0].Split(' ').Select(a => byte.Parse(a.ToString(), NumberStyles.HexNumber)).ToArray());
     var N = new BigInteger(open_key[1].Split(' ').Select(a => byte.Parse(a.ToString(), NumberStyles.HexNumber)).ToArray());
     var cryptArr = new BigInteger[(bytes.Length / (N.ToByteArray().Length - 1) + 1)];
     for (int i = 0, k = 0; i < bytes.Length; i = i)
     {
         var data = bytes.Skip(i).Take(N.ToByteArray().Length - 1).ToArray();
         cryptArr[k++] = RSAEx.EnCrypt(new BigInteger(data), D, N);
         i += data.Length;
     }
     File.WriteAllLines(filePathEncrypt.Text, cryptArr.Select(intg => string.Join(" ", intg.ToByteArray().Select(a => a.ToString("X")))));
     MessageBox.Show("Шифрование завершено");
 }

        public byte[] ConvertTo(object value)
        {
            TypeSerializer.CheckArgument<decimal>(value);
            var decimalValue = (decimal)value;
            int[] bits = decimal.GetBits(decimalValue);

            int scale = (bits[3] >> 16) & 31;

            byte[] scaleBytes = BeConverter.GetBytes(scale);

            var bigintBytes = new byte[13]; // 13th byte is for making sure that the number is positive
            Buffer.BlockCopy(bits, 0, bigintBytes, 0, 12);

            var bigInteger = new BigInteger(bigintBytes);
            if (decimalValue < 0)
            {
                bigInteger = -bigInteger;
            }

            bigintBytes = bigInteger.ToByteArray();
            Array.Reverse(bigintBytes);

            var resultBytes = new byte[scaleBytes.Length + bigintBytes.Length];
            Array.Copy(scaleBytes, resultBytes, scaleBytes.Length);
            Array.Copy(bigintBytes, 0, resultBytes, scaleBytes.Length, bigintBytes.Length);
            return resultBytes;
        }

 public ScriptBuilder Push(BigInteger number)
 {
     if (number == -1) return Add(ScriptOp.OP_1NEGATE);
     if (number == 0) return Add(ScriptOp.OP_0);
     if (number > 0 && number <= 16) return Add(ScriptOp.OP_1 - 1 + (byte)number);
     return Push(number.ToByteArray());
 }

 private static BigInteger BigRandom(this Random rand, BigInteger max)
 {
     var bytes = max.ToByteArray();
     var maxByte = bytes[bytes.Length - 1];
     rand.NextBytes(bytes);
     bytes[bytes.Length - 1] = (byte)rand.Next(maxByte);
     return new BigInteger(bytes);
 }

        public Coprimes(BigInteger target, BigInteger min, BigInteger max)
        {
            Target = new BigInteger(target.ToByteArray());
            Min = min;
            Max = max;

            counter = Min;
        }

        void CalculateV(BigInteger x, bool calcB)
        {
            v = BigInteger.ModPow(gBN, x, BN);
            V = v.ToByteArray();

            if (calcB)
                CalculateB();
        }