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 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()); }
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 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; }
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[] EncodeInt(BigInteger y) { byte[] nin = y.ToByteArray(); var nout = new byte[Math.Max(nin.Length, 32)]; Array.Copy(nin, nout, nin.Length); return nout; }
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); }
/// <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 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; }
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("Шифрование завершено"); }
void CalculateV(BigInteger x, bool calcB) { v = BigInteger.ModPow(gBN, x, BN); V = v.ToByteArray(); if (calcB) CalculateB(); }
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 static BigInteger Next(this RNGCryptoServiceProvider random, BigInteger max) { var arrSize = max.ToByteArray().Length.NextPowerOfTwo(); var tempArr = new Byte[arrSize]; random.GetBytes(tempArr); var next = new BigInteger(tempArr) & 0x7fffffff; return next % max; }
public Coprimes(BigInteger target, BigInteger min, BigInteger max) { Target = new BigInteger(target.ToByteArray()); Min = min; Max = max; counter = Min; }
public static BigInteger DoBinaryOperatorMine(BigInteger num1, BigInteger num2, string op) { List<byte> bytes1 = new List<byte>(num1.ToByteArray()); List<byte> bytes2 = new List<byte>(num2.ToByteArray()); switch (op) { case "bMin": return new BigInteger(Negate(Max(Negate(bytes1), Negate(bytes2))).ToArray()); case "bMax": return new BigInteger(Max(bytes1, bytes2).ToArray()); case "b>>": return new BigInteger(ShiftLeft(bytes1, Negate(bytes2)).ToArray()); case "b<<": return new BigInteger(ShiftLeft(bytes1, bytes2).ToArray()); case "b^": return new BigInteger(Xor(bytes1, bytes2).ToArray()); case "b|": return new BigInteger(Or(bytes1, bytes2).ToArray()); case "b&": return new BigInteger(And(bytes1, bytes2).ToArray()); case "bLog": return ApproximateBigInteger(Math.Log((double)num1, (double)num2)); case "bGCD": return new BigInteger(GCD(bytes1, bytes2).ToArray()); case "bPow": int arg2 = (int)num2; bytes2 = new List<byte>(new BigInteger(arg2).ToByteArray()); return new BigInteger(Pow(bytes1, bytes2).ToArray()); case "bDivRem": BigInteger ret = new BigInteger(Divide(bytes1, bytes2).ToArray()); bytes1 = new List<byte>(num1.ToByteArray()); bytes2 = new List<byte>(num2.ToByteArray()); outParam = new BigInteger(Remainder(bytes1, bytes2).ToArray()); return ret; case "bRemainder": case "b%": return new BigInteger(Remainder(bytes1, bytes2).ToArray()); case "bDivide": case "b/": return new BigInteger(Divide(bytes1, bytes2).ToArray()); case "bMultiply": case "b*": return new BigInteger(Multiply(bytes1, bytes2).ToArray()); case "bSubtract": case "b-": bytes2 = Negate(bytes2); goto case "bAdd"; case "bAdd": case "b+": return new BigInteger(Add(bytes1, bytes2).ToArray()); default: Console.WriteLine("Invalid operation found: {0}", op); break; } return new BigInteger(); }
/// <summary> /// Equivalent of "return random x in [min;max]" /// </summary> public BigInteger GetBigInteger(BigInteger min, BigInteger max) { byte[] bytes = max.ToByteArray(); _rng.GetBytes(bytes); var rand = new BigInteger(bytes); if (rand < 0) rand = -rand; return (rand % (max - min)) + min; }
/// <summary> /// Generates a random odd BigInteger greater than the specified minimum. /// </summary> /// <param name="min">The minimum.</param> /// <param name="token">A cancellation token. The method will bail out ASAP if a cancellation is requested.</param> public BigInteger GetRandomOddBigIntegerGreaterThan(BigInteger min, CancellationToken token) { //we actually compute the highest possible value for the number of bits in min, //and then call RandomOddBigIntegerInRange with this value as the maximum. byte[] bytes = min.ToByteArray(); var nBitsMax = bytes.Length * 8; BigInteger max = BigInteger.Pow(2, nBitsMax); return GetRandomBigIntegerInRange(min, max, token, true); }
// Token: 0x06001950 RID: 6480 RVA: 0x0007806C File Offset: 0x0007626C public override void WriteValue(object value) { if (value is System.Numerics.BigInteger) { System.Numerics.BigInteger bigInteger = (System.Numerics.BigInteger)value; base.SetWriteState(JsonToken.Integer, null); this.AddToken(new BsonBinary(bigInteger.ToByteArray(), BsonBinaryType.Binary)); return; } base.WriteValue(value); }
private static uint256 ToUInt256(this System.Numerics.BigInteger input) { if (input.Sign < 1) { throw new ArgumentException(nameof(input), "input should not be negative"); } var arr = input.ToByteArray(); int len = arr.Length; if (arr[^ 1] == 0)
public static BigInteger GenerateInteger(this RandomNumberGenerator rng, BigInteger max, int securityParameter = 64) { // The simple modular method from the NIST SP800-90A recommendation if (securityParameter < 64) throw new SecurityException("Given security parameter, " + securityParameter + ", is too low."); var bytesToRepresent = max.ToByteArray().Length; var bytes = new byte[bytesToRepresent + securityParameter / 8 + 1]; rng.GetBytes(bytes); bytes[bytes.Length - 1] = 0; return BigInteger.Remainder(new BigInteger(bytes), max); }
/** * Converts a multi-precision integer (MPI) s into an * octet sequence of length k. * * @param s the multi-precision integer to convert. * @param k the length of the output. * @return the result of the transform. * @exception ArgumentException if the length in octets of meaningful * bytes of s is greater than k. */ public static byte[] I2OSP(BigInteger s, int k) { byte[] result = s.ToByteArray().Reverse().ToArray(); if (result.Length < k) { byte[] newResult = new byte[k]; Array.Copy(result, 0, newResult, k - result.Length, result.Length); result = newResult.Reverse().ToArray(); } return result; }
public byte[] EncodeInt(BigInteger bigInt) { var ret = new byte[32]; for (var 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; }
static BigInteger BigRandom(BigInteger n) { var array = n.ToByteArray(); int last; byte temp; while ((temp = array[last = array.Length - 1]) == 0) Array.Resize<byte>(ref array, last); rnd.NextBytes(array); array[last] = (byte)rnd.Next(last == 0 ? 2 : 0, temp); return new BigInteger(array); }
private BigInteger LosujLiczbeZPrzedzialu(BigInteger wartoscMin, BigInteger wartoscMax) { var dlugosc = wartoscMax.ToByteArray().Length; var bity = new byte[dlugosc]; BigInteger liczba; do { rng.GetBytes(bity); liczba = BigInteger.Abs(new BigInteger(bity)); } while (liczba < wartoscMin || liczba >= wartoscMax); return liczba; }
public static BigInteger NextBigInteger(this Random random, BigInteger maxValue) { if (maxValue < 0) throw new ArgumentException("maxValue must be positive or 0"); if (maxValue == 0) return new BigInteger(0); byte[] maxValueArray = maxValue.ToByteArray(); maxValueArray = maxValueArray.Reverse().ToArray(); RNGCryptoServiceProvider provider = new RNGCryptoServiceProvider(); byte[] data = new byte[maxValueArray.Length]; provider.GetBytes(data); BigInteger resInt; int byteNumber = 0; byte maxValueFirstByte = maxValueArray[byteNumber]; byte dataFirstByte = data[byteNumber]; while (true) { if (maxValueFirstByte > dataFirstByte) { data[byteNumber] = dataFirstByte; break; } if (maxValueFirstByte == dataFirstByte) { if (byteNumber + 1 >= maxValueArray.Length) { data[byteNumber] = dataFirstByte; data = data.Reverse().ToArray(); resInt = new BigInteger(data); return (--resInt); } data[byteNumber] = dataFirstByte; byteNumber++; maxValueFirstByte = maxValueArray[byteNumber]; dataFirstByte = data[byteNumber]; continue; } dataFirstByte >>= 1; } data = data.Reverse().ToArray(); resInt = new BigInteger(data); return resInt; }
/// <summary> /// Creates a new NLS login context. /// </summary> /// <param name="username">The username to use for authentication.</param> /// <param name="password">The password to use for authentication.</param> /// <remarks> /// This type does not validate the sequence from moving from one message to the next. Ensure that you /// have the correct sequence of calls. /// </remarks> /// <returns>An NLS context ID.</returns> public NLS(string username, string password) { userName = username; userNameAscii = Encoding.ASCII.GetBytes(userName); password = password; byte[] rand_a = new byte[32]; s_rand.GetNonZeroBytes(rand_a); a = new BigInteger(rand_a); a %= s_modulus; a = new BigInteger(ReverseArray(a.ToByteArray())); A = new BigInteger(ReverseArray(BigInteger.ModPow(s_generator, a, s_modulus).ToByteArray())); }
// myKeyAgree=KeyAgreement.getInstance("DiffieHellman"); /// <exception cref="System.Exception"></exception> public virtual byte[] GetE() { if (e == null) { DHParameterSpec dhSkipParamSpec = new DHParameterSpec(p, g); myKpairGen.Initialize(dhSkipParamSpec); Sharpen.KeyPair myKpair = myKpairGen.GenerateKeyPair(); myKeyAgree.Init(myKpair.GetPrivate()); // BigInteger x=((javax.crypto.interfaces.DHPrivateKey)(myKpair.getPrivate())).getX(); //byte[] myPubKeyEnc = myKpair.GetPublic().GetEncoded(); e = ((DHPublicKey)(myKpair.GetPublic())).GetY(); e_array = e.ToByteArray(); } return e_array; }
public static BigInteger NextRand(BigInteger max) { BigInteger ret = 0; var rng = new RNGCryptoServiceProvider(); byte[] bytes = max.ToByteArray(); int ile = bytes.Count(); ile = rand.Next(1, ile); bytes = new byte[ile]; do { rng.GetBytes(bytes); ret = new BigInteger(bytes); } while (ret > max || ret<0); return ret; }
public static BigInteger PositiveOddRandom(BigInteger lowerBound, BigInteger upperBound) { byte[] bytes = upperBound.ToByteArray(); BigInteger result; var random = new Random(DateTime.Now.Millisecond); do { random.NextBytes(bytes); bytes[bytes.Length - 1] &= (byte)0x7F; //force sign bit to positive bytes[0] = (byte)(bytes[0] | 1); result = new BigInteger(bytes); } while (result < lowerBound || result >= upperBound); return result; }
public static bigint PrivateKey(bigint primeP) { var buffer = new byte[primeP.ToByteArray().Length]; var random = new Random(); random.NextBytes(buffer); bigint result; while ((result = new bigint(buffer, true)) > primeP) { random.NextBytes(buffer); } return(result); }
public static string BigIntegerToBase64(BigInteger data, bool asLittleEndian) { if (data == null || data == 0) { return null; } byte[] bytes = data.ToByteArray(); if (!asLittleEndian) { Array.Reverse(bytes); } return Convert.ToBase64String(bytes); }
public static string ToBinaryString(this System.Numerics.BigInteger bigint) { var bytes = bigint.ToByteArray(); var idx = bytes.Length - 1; // Create a StringBuilder having appropriate capacity. var base2 = new StringBuilder(bytes.Length * 8); // Convert first byte to binary. var binary = Convert.ToString(bytes[idx], 2); // Ensure leading zero exists if value is positive. if (binary[0] != '0' && bigint.Sign == 1) { base2.Append('0'); } base2.Append(binary); for (idx--; idx >= 0; idx--) { base2.Append(Convert.ToString(bytes[idx], 2).PadLeft(8, '0')); } return(base2.ToString()); }
private static string FormatBigIntegerToHex(BigInteger value, char format, int digits, NumberFormatInfo info) { Debug.Assert(format == 'x' || format == 'X'); // Get the bytes that make up the BigInteger. Span <byte> bits = stackalloc byte[64]; // arbitrary limit to switch from stack to heap bits = value.TryWriteBytes(bits, out int bytesWritten) ? bits.Slice(0, bytesWritten) : value.ToByteArray(); Span <char> stackSpace = stackalloc char[128]; // each byte is typically two chars var sb = new ValueStringBuilder(stackSpace); int cur = bits.Length - 1; if (cur > -1) { // [FF..F8] drop the high F as the two's complement negative number remains clear // [F7..08] retain the high bits as the two's complement number is wrong without it // [07..00] drop the high 0 as the two's complement positive number remains clear bool clearHighF = false; byte head = bits[cur]; if (head > 0xF7) { head -= 0xF0; clearHighF = true; } if (head < 0x08 || clearHighF) { // {0xF8-0xFF} print as {8-F} // {0x00-0x07} print as {0-7} sb.Append(head < 10 ? (char)(head + '0') : format == 'X' ? (char)((head & 0xF) - 10 + 'A') : (char)((head & 0xF) - 10 + 'a')); cur--; } } if (cur > -1) { Span <char> chars = sb.AppendSpan((cur + 1) * 2); int charsPos = 0; string hexValues = format == 'x' ? "0123456789abcdef" : "0123456789ABCDEF"; while (cur > -1) { byte b = bits[cur--]; chars[charsPos++] = hexValues[b >> 4]; chars[charsPos++] = hexValues[b & 0xF]; } } if (digits > sb.Length) { // Insert leading zeros, e.g. user specified "X5" so we create "0ABCD" instead of "ABCD" sb.Insert( 0, value._sign >= 0 ? '0' : (format == 'x') ? 'f' : 'F', digits - sb.Length); } return(sb.ToString()); }