protected override BigInteger GenerateSearchBase(int bits, object Context) { if (Context == null) throw new ArgumentNullException("Context"); var ret = new BigInteger((BigInteger) Context); ret.SetBit(0); return ret; }
/// <summary> /// Генерация ключа авторизации /// </summary> /// <returns></returns> private bool GenerateAuthKey(string address, int port) { using (var connection = new TcpConnection(address, port, _formatter)) { connection.Connect(true); var pns = new PlainMtProtoSession(connection); _nonce = BigInteger.GenerateRandom(128); var reqpq = new Combinator("req_pq", _nonce); RpcAnswer result = pns.RpcCall(reqpq, "resPQ nonce:int128 server_nonce:int128 pq:string server_public_key_fingerprints:Vector long = ResPQ"); if (!result.Success) throw new Exception(result.Error.ToString()); Combinator reqDhParams = ProcessPqAnswer(result.Combinator); result = pns.RpcCall(reqDhParams, "server_DH_params_ok nonce:int128 server_nonce:int128 encrypted_answer:string = Server_DH_Params", "server_DH_params_fail nonce:int128 server_nonce:int128 new_nonce_hash:int128 = Server_DH_Params"); if (result.Combinator.Name == "server_DH_params_ok") { Combinator serverDhInnerData = ProcessDhParams(result.Combinator); Combinator setClientDhParams = SetClientDhParams(serverDhInnerData); result = pns.RpcCall(setClientDhParams, "dh_gen_ok nonce:int128 server_nonce:int128 new_nonce_hash1:int128 = Set_client_DH_params_answer", "dh_gen_retry nonce:int128 server_nonce:int128 new_nonce_hash2:int128 = Set_client_DH_params_answer", "dh_gen_fail nonce:int128 server_nonce:int128 new_nonce_hash3:int128 = Set_client_DH_params_answer"); Thread.Sleep(100); switch (result.Combinator.Name) { case "dh_gen_ok": InitialSalt = CalculateInitialSalt(_newNonce, _serverNonce); // Проверим new_nonce_hash1 bool res = CheckNewNonceHash(result.Combinator.Get<BigInteger>("new_nonce_hash1"), 1); return res; case "dh_gen_retry": // HACK: ретри не реализован case "dh_gen_fail": return false; default: return false; } } return false; } }
/// <summary> /// Конструктор по умолчанию /// </summary> /// <param name="authKey"></param> /// <param name="data"></param> public EncryptedMessage(byte[] authKey, EncryptedData data, int x) { SHA1 sha1 = SHA1.Create(); _authKey = authKey; byte[] hash = sha1.ComputeHash(authKey); AuthKeyId = BitConverter.ToInt64(hash, hash.Length - 8); hash = sha1.ComputeHash(data.SerializeNoPadding()); var buf = new byte[16]; Array.Copy(hash, hash.Length - 16, buf, 0, 16); MsgKey = new BigInteger(buf); _x = x; Data = data; }
public EncryptedMessage(byte[] authKey, byte[] plainData) { _authKey = authKey; using (var ms = new MemoryStream(plainData)) { using (var br = new BinaryReader(ms)) { AuthKeyId = br.ReadInt64(); MsgKey = new BigInteger(br.ReadBytes(16)); // дешифруем эту дату byte[] aesKey = CalculateAesKey(8, MsgKey.GetBytes()); byte[] aesIv = CalculateIV(8, MsgKey.GetBytes()); var aesIge = new Aes256IgeManaged(aesKey, aesIv); Data = new EncryptedData(aesIge.Decrypt(br.ReadBytes(plainData.Length - 8 - 16))); } } }
private static int GetSPPRounds(BigInteger bi, ConfidenceFactor confidence) { int bc = bi.BitCount(); int Rounds; // Data from HAC, 4.49 if (bc <= 100) Rounds = 27; else if (bc <= 150) Rounds = 18; else if (bc <= 200) Rounds = 15; else if (bc <= 250) Rounds = 12; else if (bc <= 300) Rounds = 9; else if (bc <= 350) Rounds = 8; else if (bc <= 400) Rounds = 7; else if (bc <= 500) Rounds = 6; else if (bc <= 600) Rounds = 5; else if (bc <= 800) Rounds = 4; else if (bc <= 1250) Rounds = 3; else Rounds = 2; switch (confidence) { case ConfidenceFactor.ExtraLow: Rounds >>= 2; return Rounds != 0 ? Rounds : 1; case ConfidenceFactor.Low: Rounds >>= 1; return Rounds != 0 ? Rounds : 1; case ConfidenceFactor.Medium: return Rounds; case ConfidenceFactor.High: return Rounds << 1; case ConfidenceFactor.ExtraHigh: return Rounds << 2; case ConfidenceFactor.Provable: throw new Exception( "The Rabin-Miller test can not be executed in a way such that its results are provable"); default: throw new ArgumentOutOfRangeException("confidence"); } }
public BigInteger ModPow(BigInteger exp, BigInteger n) { var mr = new ModulusRing(n); return mr.Pow(this, exp); }
public BigInteger GCD(BigInteger bi) { return Kernel.gcd(this, bi); }
public Sign Compare(BigInteger bi) { return Kernel.Compare(this, bi); }
public static BigInteger Multiply(BigInteger bi, int i) { return (bi * i); }
public static BigInteger Divid(BigInteger bi1, BigInteger bi2) { return (bi1 / bi2); }
public static BigInteger Modulus(BigInteger bi1, BigInteger bi2) { return (bi1 % bi2); }
public static unsafe void SquarePositive(BigInteger bi, ref uint[] wkSpace) { uint[] t = wkSpace; wkSpace = bi.data; uint[] d = bi.data; uint dl = bi.length; bi.data = t; fixed (uint* dd = d, tt = t) { uint* ttE = tt + t.Length; // Clear the dest for (uint* ttt = tt; ttt < ttE; ttt++) *ttt = 0; uint* dP = dd, tP = tt; for (uint i = 0; i < dl; i++, dP++) { if (*dP == 0) continue; ulong mcarry = 0; uint bi1val = *dP; uint* dP2 = dP + 1, tP2 = tP + 2 * i + 1; for (uint j = i + 1; j < dl; j++, tP2++, dP2++) { // k = i + j mcarry += (bi1val * (ulong)*dP2) + *tP2; *tP2 = (uint)mcarry; mcarry >>= 32; } if (mcarry != 0) *tP2 = (uint)mcarry; } // Double t. Inlined for speed. tP = tt; uint x, carry = 0; while (tP < ttE) { x = *tP; *tP = (x << 1) | carry; carry = x >> (32 - 1); tP++; } if (carry != 0) *tP = carry; // Add in the diagnals dP = dd; tP = tt; for (uint* dE = dP + dl; (dP < dE); dP++, tP++) { ulong val = *dP * (ulong)*dP + *tP; *tP = (uint)val; val >>= 32; *(++tP) += (uint)val; if (*tP < (uint)val) { uint* tP3 = tP; // Account for the first carry (*++tP3)++; // Keep adding until no carry while ((*tP3++) == 0) (*tP3)++; } } bi.length <<= 1; // Normalize length while (tt[bi.length - 1] == 0 && bi.length > 1) bi.length--; } }
public static BigInteger MultiplyByDword(BigInteger n, uint f) { var ret = new BigInteger(Sign.Positive, n.length + 1); uint i = 0; ulong c = 0; do { c += n.data[i] * (ulong)f; ret.data[i] = (uint)c; c >>= 32; } while (++i < n.length); ret.data[i] = (uint)c; ret.Normalize(); return ret; }
public static BigInteger RightShift(BigInteger bi, int n) { if (n == 0) return new BigInteger(bi); int w = n >> 5; int s = n & ((1 << 5) - 1); var ret = new BigInteger(Sign.Positive, bi.length - (uint)w + 1); uint l = (uint)ret.data.Length - 1; if (s != 0) { uint x, carry = 0; while (l-- > 0) { x = bi.data[l + w]; ret.data[l] = (x >> n) | carry; carry = x << (32 - n); } } else { while (l-- > 0) ret.data[l] = bi.data[l + w]; } ret.Normalize(); return ret; }
public static BigInteger LeftShift(BigInteger bi, int n) { if (n == 0) return new BigInteger(bi, bi.length + 1); int w = n >> 5; n &= ((1 << 5) - 1); var ret = new BigInteger(Sign.Positive, bi.length + 1 + (uint)w); uint i = 0, l = bi.length; if (n != 0) { uint x, carry = 0; while (i < l) { x = bi.data[i]; ret.data[i + w] = (x << n) | carry; carry = x >> (32 - n); i++; } ret.data[i + w] = carry; } else { while (i < l) { ret.data[i + w] = bi.data[i]; i++; } } ret.Normalize(); return ret; }
public static int Modulus(BigInteger bi, int i) { return (bi % i); }
public static uint Modulus(BigInteger bi, uint ui) { return (bi % ui); }
/* * Never called in BigInteger (and part of a private class) * public static bool Double (uint [] u, int l) { uint x, carry = 0; uint i = 0; while (i < l) { x = u [i]; u [i] = (x << 1) | carry; carry = x >> (32 - 1); i++; } if (carry != 0) u [l] = carry; return carry != 0; }*/ #endregion #region Number Theory public static BigInteger gcd(BigInteger a, BigInteger b) { BigInteger x = a; BigInteger y = b; BigInteger g = y; while (x.length > 1) { g = x; x = y % x; y = g; } if (x == 0) return g; // TODO: should we have something here if we can convert to long? // // Now we can just do it with single precision. I am using the binary gcd method, // as it should be faster. // uint yy = x.data[0]; uint xx = y % yy; int t = 0; while (((xx | yy) & 1) == 0) { xx >>= 1; yy >>= 1; t++; } while (xx != 0) { while ((xx & 1) == 0) xx >>= 1; while ((yy & 1) == 0) yy >>= 1; if (xx >= yy) xx = (xx - yy) >> 1; else yy = (yy - xx) >> 1; } return yy << t; }
public static BigInteger Divid(BigInteger bi, int i) { return (bi / i); }
public static uint modInverse(BigInteger bi, uint modulus) { uint a = modulus, b = bi % modulus; uint p0 = 0, p1 = 1; while (b != 0) { if (b == 1) return p1; p0 += (a / b) * p1; a %= b; if (a == 0) break; if (a == 1) return modulus - p0; p1 += (b / a) * p0; b %= a; } return 0; }
public static BigInteger Multiply(BigInteger bi1, BigInteger bi2) { return (bi1 * bi2); }
public static BigInteger modInverse(BigInteger bi, BigInteger modulus) { if (modulus.length == 1) return modInverse(bi, modulus.data[0]); BigInteger[] p = { 0, 1 }; var q = new BigInteger[2]; // quotients BigInteger[] r = { 0, 0 }; // remainders int step = 0; BigInteger a = modulus; BigInteger b = bi; var mr = new ModulusRing(modulus); while (b != 0) { if (step > 1) { BigInteger pval = mr.Difference(p[0], p[1] * q[0]); p[0] = p[1]; p[1] = pval; } BigInteger[] divret = multiByteDivide(a, b); q[0] = q[1]; q[1] = divret[0]; r[0] = r[1]; r[1] = divret[1]; a = b; b = divret[1]; step++; } if (r[0] != 1) throw (new ArithmeticException("No inverse!")); return mr.Difference(p[0], p[1] * q[0]); }
/// <summary> /// Generates a new, random BigInteger of the specified length. /// </summary> /// <param name="bits">The number of bits for the new number.</param> /// <param name="rng">A random number generator to use to obtain the bits.</param> /// <returns>A random number of the specified length.</returns> public static BigInteger GenerateRandom(int bits, RandomNumberGenerator rng) { int dwords = bits >> 5; int remBits = bits & 0x1F; if (remBits != 0) dwords++; var ret = new BigInteger(Sign.Positive, (uint)dwords + 1); var random = new byte[dwords << 2]; rng.GetBytes(random); Buffer.BlockCopy(random, 0, ret.data, 0, dwords << 2); if (remBits != 0) { var mask = (uint)(0x01 << (remBits - 1)); ret.data[dwords - 1] |= mask; mask = 0xFFFFFFFF >> (32 - remBits); ret.data[dwords - 1] &= mask; } else ret.data[dwords - 1] |= 0x80000000; ret.Normalize(); return ret; }
/* This is the BigInteger.Parse method I use. This method works because BigInteger.ToString returns the input I gave to Parse. */ public static BigInteger Parse(string number) { if (number == null) throw new ArgumentNullException("number"); int i = 0, len = number.Length; char c; bool digits_seen = false; var val = new BigInteger(0); if (number[i] == '+') { i++; } else if (number[i] == '-') { throw new FormatException(WouldReturnNegVal); } for (; i < len; i++) { c = number[i]; if (c == '\0') { i = len; continue; } if (c >= '0' && c <= '9') { val = val * 10 + (c - '0'); digits_seen = true; } else { if (Char.IsWhiteSpace(c)) { for (i++; i < len; i++) { if (!Char.IsWhiteSpace(number[i])) throw new FormatException(); } break; } throw new FormatException(); } } if (!digits_seen) throw new FormatException(); return val; }
public string ToString(uint radix, string characterSet) { if (characterSet.Length < radix) throw new ArgumentException("charSet length less than radix", "characterSet"); if (radix == 1) throw new ArgumentException("There is no such thing as radix one notation", "radix"); if (this == 0) return "0"; if (this == 1) return "1"; string result = ""; var a = new BigInteger(this); while (a != 0) { uint rem = Kernel.SingleByteDivideInPlace(a, radix); result = characterSet[(int)rem] + result; } return result; }
public static BigInteger operator *(BigInteger bi1, BigInteger bi2) { if (bi1 == 0 || bi2 == 0) return 0; // // Validate pointers // if (bi1.data.Length < bi1.length) throw new IndexOutOfRangeException("bi1 out of range"); if (bi2.data.Length < bi2.length) throw new IndexOutOfRangeException("bi2 out of range"); var ret = new BigInteger(Sign.Positive, bi1.length + bi2.length); Kernel.Multiply(bi1.data, 0, bi1.length, bi2.data, 0, bi2.length, ret.data, 0); ret.Normalize(); return ret; }
public BigInteger ModInverse(BigInteger modulus) { return Kernel.modInverse(this, modulus); }
// with names suggested by FxCop 1.30 public static BigInteger Add(BigInteger bi1, BigInteger bi2) { return (bi1 + bi2); }
/// <summary> /// Generates the smallest prime >= bi /// </summary> /// <param name="bi">A BigInteger</param> /// <returns>The smallest prime >= bi. More mathematically, if bi is prime: bi, else Prime [PrimePi [bi] + 1].</returns> public static BigInteger NextHighestPrime(BigInteger bi) { var npf = new NextPrimeFinder(); return npf.GenerateNewPrime(0, bi); }
public static BigInteger Subtract(BigInteger bi1, BigInteger bi2) { return (bi1 - bi2); }