public static Extreme.Mathematics.BigInteger ToUnsignedExtremeMathematics(BigInteger value) { if (value.Sign < 0) { throw new ArgumentException("Only non-negative values allowed"); } return(new Extreme.Mathematics.BigInteger(value.ToByteArray())); }
public static byte[] UnsignedToBytes(BigInteger value) { if (value.Sign < 0) { throw new ArgumentException("Only non-negative values allowed"); } byte[] bytes = value.ToByteArray(); return(ShouldTrimSign(bytes) ? bytes.Take(bytes.Length - 1).ToArray() : bytes); }
public static BigInt Random(this Random generator, BigInt limit) { ContractUtils.Requires(limit.Sign > 0, "limit"); ContractUtils.RequiresNotNull(generator, "generator"); BigInt res = BigInt.Zero; while (true) { // if we've run out of significant digits, we can return the total if (limit == BigInt.Zero) { return(res); } // if we're small enough to fit in an int, do so int iLimit; if (limit.AsInt32(out iLimit)) { return(res + generator.Next(iLimit)); } // get the 3 or 4 uppermost bytes that fit into an int int hiData; byte[] data = limit.ToByteArray(); int index = data.Length; while (data[--index] == 0) { ; } if (data[index] < 0x80) { hiData = data[index] << 24; data[index--] = (byte)0; } else { hiData = 0; } hiData |= data[index] << 16; data[index--] = (byte)0; hiData |= data[index] << 8; data[index--] = (byte)0; hiData |= data[index]; data[index--] = (byte)0; // get a uniform random number for the uppermost portion of the bigint byte[] randomData = new byte[index + 2]; generator.NextBytes(randomData); randomData[index + 1] = (byte)0; res += new BigInt(randomData); res += (BigInt)generator.Next(hiData) << ((index + 1) * 8); // sum it with a uniform random number for the remainder of the bigint limit = new BigInt(data); } }
private string RandomIntegerBelow(string Nstr) { System.Numerics.BigInteger N = System.Numerics.BigInteger.Parse(Nstr); byte[] bytes = N.ToByteArray(); System.Numerics.BigInteger R; var random = new Random(); do { random.NextBytes(bytes); bytes[bytes.Length - 1] &= (byte)0x7F; R = new System.Numerics.BigInteger(bytes); } while (R >= N); return(R.ToString()); }
public byte[] ToBytes() { int get = (bit / 32) + 1; System.Numerics.BigInteger sbi = System.Numerics.BigInteger.Zero; for (int a = 0; a < get; a++) { sbi += new System.Numerics.BigInteger(bi.data[a]) << (a * 32); } //bi.data var data2 = sbi.ToByteArray(); Array.Resize(ref data2, (bit + 7) / 8); return(data2); }
protected byte[] GetIV(byte[] ivec, TLInt offset) { var iv = new byte[ivec.Length]; Buffer.BlockCopy(ivec, 0, iv, 0, ivec.Length); Array.Reverse(iv); var bi = new System.Numerics.BigInteger(TLUtils.Combine(iv, new byte[] { 0x00 })); bi = (bi + offset.Value / 16); var biArray = bi.ToByteArray(); var b = new byte[16]; Buffer.BlockCopy(biArray, 0, b, 0, Math.Min(b.Length, biArray.Length)); Array.Reverse(b); return(b); }
// Note: ivec - big-endian, but BigInterger.ctor and BigInteger.ToByteArray return little-endian public static byte[] AES_ctr128_encrypt(byte[] input, IBuffer key, ref byte[] ivec, ref byte[] ecount_buf, ref uint num) { uint n; var output = new byte[input.Length]; n = num; var provider = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcb); var keySymmetric = provider.CreateSymmetricKey(key); for (uint i = 0; i < input.Length; i++) { if (n == 0) { var ivecBuffer = CryptographicBuffer.CreateFromByteArray(ivec); var ecountBuffer = CryptographicEngine.Encrypt(keySymmetric, ivecBuffer, null); CryptographicBuffer.CopyToByteArray(ecountBuffer, out ecount_buf); Array.Reverse(ivec); var bi = new System.Numerics.BigInteger(TLUtils.Combine(ivec, new byte[] { 0x00 })); bi = (bi + 1); var biArray = bi.ToByteArray(); var b = new byte[16]; //for (var j = 0; j < biArray.Length && j < b.Length; j++) //{ // b[j] = biArray[j]; //} System.Buffer.BlockCopy(biArray, 0, b, 0, Math.Min(biArray.Length, b.Length)); //System.Diagnostics.Debug.WriteLine(bi); Array.Reverse(b); ivec = b; } output[i] = (byte)(input[i] ^ ecount_buf[n]); n = (n + 1) % 16; } num = n; return(output); }
public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex) { var num = new System.Numerics.BigInteger(); for (int i = 0; i < charCount; ++i) { num *= Base; var index = Alphabet.IndexOf(chars[charIndex + i]); if (index == -1) { throw new Exception("Illegal character " + chars[charIndex + i] + " at " + (charIndex + i)); } num += index; } var numbytes = num.ToByteArray(); var byteCount = GetMaxByteCount(charCount); Array.Copy(numbytes, 0, bytes, byteIndex, Math.Min(byteCount, numbytes.Length)); return byteCount; }
public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex) { var num = new System.Numerics.BigInteger(); for (int i = 0; i < charCount; ++i) { num *= Base; var index = Alphabet.IndexOf(chars[charIndex + i]); if (index == -1) { throw new Exception("Illegal character " + chars[charIndex + i] + " at " + (charIndex + i)); } num += index; } var numbytes = num.ToByteArray(); var byteCount = GetMaxByteCount(charCount); Array.Copy(numbytes, 0, bytes, byteIndex, Math.Min(byteCount, numbytes.Length)); return(byteCount); }
public static byte[] Base58CheckDecode(string base58CheckTextToDecode) { const string base58CheckCodeString = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; var bigInteger = new System.Numerics.BigInteger(0); var leadingZeros = 0; do { if (base58CheckTextToDecode[leadingZeros] == base58CheckCodeString[0]) { ++leadingZeros; } } while (base58CheckTextToDecode[leadingZeros] == base58CheckCodeString[0] && leadingZeros < base58CheckTextToDecode.Length); base58CheckTextToDecode = new string(base58CheckTextToDecode.ToCharArray().Skip(leadingZeros).ToArray()); for (var i = 0; i < base58CheckTextToDecode.Length; ++i) { bigInteger *= 58; bigInteger += base58CheckCodeString.IndexOf(base58CheckTextToDecode[i]); } var bigIntegerArray = bigInteger.ToByteArray().Reverse().ToArray(); bigIntegerArray = bigIntegerArray.SkipWhile(b => b == 0x00).ToArray(); var leadingZerosArray = new byte[leadingZeros]; for (var i = 0; i < leadingZeros; i++) { leadingZerosArray[i] = 0x00; } return(leadingZerosArray.Concat(bigIntegerArray).ToArray()); }
public static byte[] AES_ctr128_encrypt2(byte[] input, byte[] key, ref byte[] ivec, ref byte[] ecount_buf, ref uint num) { uint n; var output = new byte[input.Length]; n = num; var cipher = CipherUtilities.GetCipher("AES/ECB/NOPADDING"); var param = new KeyParameter(key); cipher.Init(true, param); for (uint i = 0; i < input.Length; i++) { if (n == 0) { ecount_buf = cipher.DoFinal(ivec); Array.Reverse(ivec); var bi = new System.Numerics.BigInteger(TLUtils.Combine(ivec, new byte[] { 0x00 })); bi = (bi + 1); var biArray = bi.ToByteArray(); var b = new byte[16]; Buffer.BlockCopy(biArray, 0, b, 0, Math.Min(b.Length, biArray.Length)); //System.Diagnostics.Debug.WriteLine(bi); Array.Reverse(b); ivec = b; } output[i] = (byte)(input[i] ^ ecount_buf[n]); n = (n + 1) % 16; } num = n; return(output); }
public void ToArray_Performance() { const int loopCount = 100000000; var bigInteger = new BigInteger(huge_a); var stopWatch = new Stopwatch(); GC.Collect(); GC.WaitForFullGCComplete(); stopWatch.Start(); for (var i = 0; i < loopCount; i++) { bigInteger.ToByteArray(); } GC.Collect(); GC.WaitForFullGCComplete(); stopWatch.Stop(); Console.WriteLine(stopWatch.ElapsedMilliseconds); }
public int IntValue() { return(sign * bi.ToByteArray()[0]); }
/// <summary> /// Возвращает случайное число, не превышающее MaxValue. /// </summary> /// <param name="MaxValue">Верхний исключённый предел.</param> /// <returns>Случайное число, не превышающее MaxValue.</returns> public BigInt Next_BigInt(BigInt MaxValue) { return(GetBigInt(MaxValue.ToByteArray())); }
public void LongCtorRoundTrip() { long[] values = { 0L, long.MinValue, long.MaxValue, -1, 1L + int.MaxValue, -1L + int.MinValue, 0x1234, 0xFFFFFFFFL, 0x1FFFFFFFFL, -0xFFFFFFFFL, -0x1FFFFFFFFL, 0x100000000L, -0x100000000L, 0x100000001L, -0x100000001L, 4294967295L, -4294967295L, 4294967296L, -4294967296L }; foreach (var val in values) { try { var a = new BigInteger(val); var b = new BigInteger(a.ToByteArray()); Assert.AreEqual(val, (long) a, "#a_" + val); Assert.AreEqual(val, (long) b, "#b_" + val); Assert.AreEqual(a, b, "#a == #b (" + val + ")"); } catch (Exception e) { Assert.Fail("Failed to roundtrip {0}: {1}", val, e); } } }
public void IntCtorRoundTrip() { int[] values = { int.MinValue, -0x2F33BB, -0x1F33, -0x33, 0, 0x33, 0x80, 0x8190, 0xFF0011, 0x1234, 0x11BB99, 0x44BB22CC, int.MaxValue }; foreach (var val in values) { var a = new BigInteger(val); var b = new BigInteger(a.ToByteArray()); Assert.AreEqual(val, (int)a, "#a_" + val); Assert.AreEqual(val, (int)b, "#b_" + val); } }
public static BigInt Random(this Random generator, BigInt limit) { ContractUtils.Requires(limit.Sign > 0, "limit"); ContractUtils.RequiresNotNull(generator, "generator"); BigInt res = BigInt.Zero; while (true) { // if we've run out of significant digits, we can return the total if (limit == BigInt.Zero) { return res; } // if we're small enough to fit in an int, do so int iLimit; if (limit.AsInt32(out iLimit)) { return res + generator.Next(iLimit); } // get the 3 or 4 uppermost bytes that fit into an int int hiData; byte[] data = limit.ToByteArray(); int index = data.Length; while (data[--index] == 0) ; if (data[index] < 0x80) { hiData = data[index] << 24; data[index--] = (byte)0; } else { hiData = 0; } hiData |= data[index] << 16; data[index--] = (byte)0; hiData |= data[index] << 8; data[index--] = (byte)0; hiData |= data[index]; data[index--] = (byte)0; // get a uniform random number for the uppermost portion of the bigint byte[] randomData = new byte[index + 2]; generator.NextBytes(randomData); randomData[index + 1] = (byte)0; res += new BigInt(randomData); res += (BigInt)generator.Next(hiData) << ((index + 1) * 8); // sum it with a uniform random number for the remainder of the bigint limit = new BigInt(data); } }
public static bool IsProbablyPrime(this BigInteger value, int witnesses = 10) { if (value <= 1 || value.IsEven) { return(false); } if (witnesses <= 0) { witnesses = 10; } BigInteger d = value - 1; int s = 0; while (d % 2 == 0) { d /= 2; s += 1; } Byte[] bytes = new Byte[value.ToByteArray().LongLength]; BigInteger a; for (int i = 0; i < witnesses; i++) { do { Rng.GetBytes(bytes); a = new BigInteger(bytes); } while (a < 2 || a >= value - 2); BigInteger x = BigInteger.ModPow(a, d, value); if (x == 1 || x == value - 1) { continue; } for (int r = 1; r < s; r++) { x = BigInteger.ModPow(x, 2, value); if (x == 1) { return(false); } if (x == value - 1) { break; } } if (x != value - 1) { return(false); } } return(true); }
/// <summary> /// Return the value of this BigInteger as a little-endian twos-complement /// byte array, using the fewest number of bytes possible. If the value is zero, /// return an array of one byte whose element is 0x00. /// </summary> public byte[] ToByteArray() { return(Value.ToByteArray()); }
public override string /*!*/ ToString() { Contract.Ensures(Contract.Result <string>() != null); if (value == "") { byte[] sigBytes = significand.ToByteArray(); StringBuilder binSig = new StringBuilder(); if (exponent == 0) { binSig.Append('0'); } else { binSig.Append('1'); //hidden bit } for (int i = significandSize - 2; i >= 0; --i) { //little endian if (i / 8 < sigBytes.Length) { binSig.Append((char)('0' + ((sigBytes[i / 8] >> (i % 8)) & 1))); } else { binSig.Append('0'); } } BIM bias = BIM.Pow(2, exponentSize - 1) - 1; if (exponent == 0) { --bias; } int moveDec = ((int)((exponent - bias) % 4) + 4) % 4; BIM finalExp = (exponent - bias - moveDec) / 4; string leftBinSig = binSig.ToString().Substring(0, moveDec + 1); string rightBinSig = binSig.ToString().Substring(moveDec + 1); leftBinSig = new string('0', 4 - leftBinSig.Length % 4) + leftBinSig; rightBinSig = rightBinSig + new string('0', 4 - rightBinSig.Length % 4); StringBuilder leftHexSig = new StringBuilder(); StringBuilder rightHexSig = new StringBuilder(); for (int i = 0; i < leftBinSig.Length / 4; ++i) { leftHexSig.AppendFormat("{0:X}", Convert.ToByte(leftBinSig.Substring(i * 4, 4), 2)); } for (int i = 0; i < rightBinSig.Length / 4; ++i) { rightHexSig.AppendFormat("{0:X}", Convert.ToByte(rightBinSig.Substring(i * 4, 4), 2)); } return(String.Format("{0}0x{1}.{2}e{3}f{4}e{5}", isSignBitSet ? "-" : "", leftHexSig, rightHexSig, finalExp, significandSize, exponentSize)); } return(String.Format("0{0}{1}e{2}", value, significandSize, exponentSize)); }