private static void CheckNormaliseBaseTenResult(ExpandedDouble orig, NormalisedDecimal result) { String sigDigs = result.GetSignificantDecimalDigits(); BigInteger frac = orig.GetSignificand(); while (frac.BitLength() + orig.GetBinaryExponent() < 200) { frac = frac * (BIG_POW_10); } int binaryExp = orig.GetBinaryExponent() - orig.GetSignificand().BitLength(); String origDigs = (frac << (binaryExp + 1)).ToString(10); if (!origDigs.StartsWith(sigDigs)) { throw new AssertionException("Expected '" + origDigs + "' but got '" + sigDigs + "'."); } double dO = Double.Parse("0." + origDigs.Substring(sigDigs.Length)); double d1 = Double.Parse(result.GetFractionalPart().ToString()); BigInteger subDigsO = new BigInteger((int)(dO * 32768 + 0.5)); BigInteger subDigsB = new BigInteger((int)(d1 * 32768 + 0.5)); if (subDigsO.Equals(subDigsB)) { return; } BigInteger diff = (subDigsB - subDigsO).Abs(); if (diff.IntValue() > 100) { // 100/32768 ~= 0.003 throw new AssertionException("minor mistake"); } }
protected BigInteger ModKey(BigInteger Key1, BigInteger Key2) { BigInteger orgKey1 = Key1; Key1 += Key2; Key1 = equK(Key2, orgKey1, Key1.IntValue()); return(Key1 + Key2); }
protected void HandleServerAuthChallenge(InPacket packet) { uint one = packet.ReadUInt32(); uint seed = packet.ReadUInt32(); BigInteger seed1 = packet.ReadBytes(16).ToBigInteger(); BigInteger seed2 = packet.ReadBytes(16).ToBigInteger(); var rand = System.Security.Cryptography.RandomNumberGenerator.Create(); byte[] bytes = new byte[4]; rand.GetBytes(bytes); BigInteger ourSeed = bytes.ToBigInteger(); uint zero = 0; byte[] authResponse = HashAlgorithm.SHA1.Hash ( Encoding.ASCII.GetBytes(Game.Username.ToUpper()), BitConverter.GetBytes(zero), BitConverter.GetBytes((uint)ourSeed.IntValue()), BitConverter.GetBytes(seed), Game.Key.ToCleanByteArray() ); OutPacket response = new OutPacket(WorldCommand.ClientAuthSession); response.Write((uint)12340); // client build response.Write(zero); response.Write(Game.Username.ToUpper().ToCString()); response.Write(zero); response.Write((uint)ourSeed.IntValue()); response.Write(zero); response.Write(zero); response.Write(Exchange.CurrentRealm.ID); response.Write((ulong)zero); response.Write(authResponse); response.Write(zero); // length of addon data Send(response); // TODO: don't fully initialize here, auth may fail // instead, initialize in HandleServerAuthResponse when auth succeeds // will require special logic in network code to correctly decrypt/parse packet header authenticationCrypto.Initialize(Game.Key.ToCleanByteArray()); }
public NormalisedDecimal CreateNormalisedDecimal(int pow10) { // missingUnderBits is (0..3) int missingUnderBits = _binaryExponent - 39; int fracPart = (_significand.IntValue() << missingUnderBits) & 0xFFFF80; long wholePart = (_significand >> (C_64 - _binaryExponent - 1)).LongValue(); return(new NormalisedDecimal(wholePart, fracPart, pow10)); }
void HandleServerAuthChallenge(PacketReader reader) { uint one = reader.ReadUInt32(); uint seed = reader.ReadUInt32(); BigInteger seed1 = reader.ReadBytes(16).ToBigInteger(); BigInteger seed2 = reader.ReadBytes(16).ToBigInteger(); var rand = System.Security.Cryptography.RandomNumberGenerator.Create(); byte[] bytes = new byte[4]; rand.GetBytes(bytes); BigInteger _seed = bytes.ToBigInteger(); uint zero = 0; byte[] response = HashAlgorithm.SHA1.Hash(Encoding.ASCII.GetBytes(Manager.m_WorldServer.username.ToUpper()), BitConverter.GetBytes(zero), BitConverter.GetBytes((uint)_seed.IntValue()), BitConverter.GetBytes(seed), Manager.m_WorldServer.SessionKey.ToCleanByteArray()); PacketWriter writer = new PacketWriter(Opcodes.ClientAuthSession); writer.Write((uint)12340); // Build writer.Write(zero); // LoginServerID writer.Write(Manager.m_WorldServer.username.ToUpper().ToCString()); writer.Write(zero); // Loginservertype writer.Write((uint)_seed.IntValue()); writer.Write(zero); writer.Write(zero); writer.Write((uint)1); // RealmID writer.Write((ulong)zero); writer.Write(response); writer.Write(zero); Send(writer); AuthenticationCrypto.Initialize(Manager.m_WorldServer.SessionKey.ToCleanByteArray()); }
public BigGF Mul(BigGF b) { var first = _poly; var second = b._poly; var res = new SortedDictionary <int, int>(); foreach (var pair1 in first) { foreach (var pair2 in second) { int key = pair1.Key + pair2.Key; int value = pair1.Value * pair2.Value; if (value == 1) { if (!res.ContainsKey(key)) { res.Add(key, 1); } else { res.Remove(key); } } } } var result = new BigGF(_pow.IntValue(), res); if (Math.Pow(2, result.GetMaxPow()) < _pow.IntValue()) { return(result); } else { double aaa = _pow.IntValue(); int ttt = (int)Math.Log(aaa, 2); var tmp = new BigGF(_pow, irreducible_polynomials[ttt - 1]); return(result.Div(tmp)); } }
/** * Performs modulo inverse * */ private int modInverse(int num, int prime) { if (num == -1) { return(prime - 1); } BigInteger n = new BigInteger(num); BigInteger p = new BigInteger(prime); BigInteger result = n.modInverse(p); return(result.IntValue()); }
/// <summary> /// Gets the next available address in this address pool. /// </summary> /// <returns>the next available address</returns> public IPAddress GetNextAvailableAddress() { Monitor.Enter(_lock); try { if (freeList != null) { BigInteger next = freeList.GetNextFree(); if (next.IntValue() != 0) { try { IPAddress ip = new IPAddress(next.GetBytes()); int pingCheckTimeout = DhcpServerPolicies.GlobalPolicyAsInt(Property.V4_PINGCHECK_TIMEOUT); if (pingCheckTimeout > 0) { try { if (CheckIPIsUsed(ip, pingCheckTimeout)) { log.Warn("Next free address answered ping check: " + ip.ToString()); SetUsed(ip); return(GetNextAvailableAddress()); // try again } log.InfoFormat("Assign IPv4 Address : {0}", ip.ToString()); } catch (IOException ex) { log.Error("Failed to perform v4 ping check: " + ex); } } return(ip); } catch (Exception ex) { log.Error("Unable to build IPv4 address from next free: " + ex); } } } } catch (Exception ex) { log.Error("Unable to build IPv4 address from next free: " + ex); } finally { Monitor.Exit(_lock); } return(null); }
public Stream RecalculatePrivateKey(Stream PrivateKeyData) { if (!PrivateKeyData.CanSeek || !PrivateKeyData.CanWrite) { throw new Exception("Unable to write to the stream"); } BigInteger InversedInt = 0; try { InversedInt = PrivateSalt.modInverse(this.Username); } catch (Exception ex) { SysLogger.Log(ex.Message, SysLogType.Error); //no inverse could be found InversedInt = PrivateSalt + this.Username; } PatchKey(ref InversedInt); //patch the key to randomize the 0xFF bytes byte[] inverseData = InversedInt.getBytes(); int temp = InversedInt.IntValue(); for (int j = 0; j <= 1; j++) { for (int i = 4 * j; i < PrivateKeyData.Length; i += 8) { byte[] tempData = new byte[4]; int read = 0; PrivateKeyData.Position = i; if ((read = PrivateKeyData.Read(tempData, 0, tempData.Length)) <= 0) { break; } int TempKey = BitConverter.ToInt32(tempData, 0) ^ temp; PrivateKeyData.Position -= read; PrivateKeyData.Write(BitConverter.GetBytes(TempKey), 0, read); temp = TempKey; } } return(PrivateKeyData); }
/// <summary> /// Gets the next available address in this address pool. /// </summary> /// <returns>the next available address</returns> public IPAddress GetNextAvailableAddress() { Debug.Assert(CheckIPIsUsed != null, "V6AddressBindingPool --GetNextAvailableAddress-- CheckIPIsUsed = null"); if (freeList != null) { BigInteger next = freeList.GetNextFree(); if (next.IntValue() != 0) { try { byte[] nextByte = next.GetBytes(); IPAddress ip = new IPAddress(next.GetBytes()); int pingCheckTimeout = DhcpServerPolicies.GlobalPolicyAsInt(Property.V4_PINGCHECK_TIMEOUT); if (pingCheckTimeout > 0) { try { if (CheckIPIsUsed(ip, pingCheckTimeout)) { log.Warn("Next free address answered ping check: " + ip.ToString()); SetUsed(ip); return(GetNextAvailableAddress()); // try again } log.InfoFormat("Assign IPv6 Address : {0}", ip.ToString()); } catch (IOException ex) { log.Error("Failed to perform v4 ping check: " + ex); } } return(ip); } catch (Exception ex) { log.Error("Unable to build IPv6 address from next free: " + ex); } } } return(null); }
public bool isProbablePrime(int confidence) { BigInteger thisVal; if ((this.data[maxLength - 1] & 0x80000000) != 0) // negative { thisVal = -this; } else { thisVal = this; } // test for divisibility by primes < 2000 for (int p = 0; p < primesBelow2000.Length; p++) { BigInteger divisor = primesBelow2000[p]; if (divisor >= thisVal) { break; } BigInteger resultNum = thisVal % divisor; if (resultNum.IntValue() == 0) { return(false); } } if (thisVal.RabinMillerTest(confidence)) { return(true); } else { return(false); } }
/** * When the connectiontable changes, we re-estimate * the size of the network: */ protected void EstimateSize(object contab, System.EventArgs args) { try { //Estimate the new size: int net_size = -1; BigInteger least_dist = null; BigInteger greatest_dist = null; int shorts = 0; ConnectionList structs = ((ConnectionEventArgs)args).CList; if (structs.MainType == ConnectionType.Structured) { /* * We know we are in the network, so the network * has size at least 1. And all our connections * plus us is certainly a lower bound. */ if (structs.Count + 1 > net_size) { net_size = structs.Count + 1; } /* * We estimate the density of nodes in the address space, * and since we know the size of the whole address space, * we can use the density to estimate the number of nodes. */ AHAddress local = (AHAddress)_local_add; foreach (Connection c in structs) { if (c.ConType == "structured.near") { BigInteger dist = local.DistanceTo((AHAddress)c.Address); if (shorts == 0) { //This is the first one least_dist = dist; greatest_dist = dist; } else { if (dist > greatest_dist) { greatest_dist = dist; } if (dist < least_dist) { least_dist = dist; } } shorts++; } } /* * Now we have the distance between the range of our neighbors */ if (shorts > 0) { if (greatest_dist > least_dist) { BigInteger width = greatest_dist - least_dist; //Here is our estimate of the inverse density: BigInteger inv_density = width / (shorts); //The density times the full address space is the number BigInteger total = Address.Full / inv_density; int total_int = total.IntValue(); if (total_int > net_size) { net_size = total_int; } } } //Now we have our estimate: lock ( _sync ) { _netsize = net_size; } } if (ProtocolLog.NodeLog.Enabled) { ProtocolLog.Write(ProtocolLog.NodeLog, String.Format( "Network size: {0} at {1}", _netsize, DateTime.UtcNow.ToString())); } } catch (Exception x) { if (ProtocolLog.Exceptions.Enabled) { ProtocolLog.Write(ProtocolLog.Exceptions, x.ToString()); } } }
/** * Reads an Integer (32 bit integer) from the byte stream. * @return an {@link Integer} */ public int ReadInteger(DataBuffer rawInput) { BigInteger intBits = ReadBigInteger(rawInput, 4); return(intBits.IntValue()); }
public override MazeErrorCode onReceiveData(byte[] Data, ref byte[] ResponseData) { ResponseData = new byte[0]; switch (base.Step) { case 1: { if (Data.Length != 32) { SysLogger.Log("[MazeHandShake][Server] Receive Length missmatch", SysLogType.Debug); return(MazeErrorCode.Error); } wopEx = base.GetWopEncryption(); wopEx.Decrypt(Data, 0, Data.Length); BigInteger server_prime = new BigInteger(Data); if (server_prime.isProbablePrime()) { //verify the prime from the server BigInteger server_Prime_test = BigInteger.genPseudoPrime(256, 50, new Random(BitConverter.ToInt32(wopEx.Key, 0))); if (server_prime != server_Prime_test) { //Attacker detected ? SysLogger.Log("[MazeHandShake][Server] Man-In-The-Middle detected", SysLogType.Debug); return(MazeErrorCode.Error); } //successful //generate another prime and send it back BigInteger client_Prime = BigInteger.genPseudoPrime(256, 50, new Random(server_prime.IntValue())); byte[] primeData = client_Prime.getBytes(); wopEx.Encrypt(primeData, 0, primeData.Length); ResponseData = primeData; BigInteger key = base.ModKey(server_prime, client_Prime); //apply key to encryption ApplyKey(wopEx, key); base.FinalKey = wopEx.Key; base.FinalSalt = wopEx.Salt; Step++; return(MazeErrorCode.Finished); } else { //connection failed, using old keys ? SysLogger.Log("[MazeHandShake][Server] Invalid received data", SysLogType.Debug); return(MazeErrorCode.Error); } } } return(MazeErrorCode.Success); }