public void EncryptorFactoryPeerAPlain() { rig.Engine.StartAll(); rig.AddConnection(conn.Incoming); HandshakeMessage message = new HandshakeMessage(rig.Manager.InfoHash, "ABC123ABC123ABC123AB", VersionInfo.ProtocolStringV100); byte[] buffer = message.Encode(); conn.Outgoing.EndSend(conn.Outgoing.BeginSend(buffer, 0, buffer.Length, null, null)); conn.Outgoing.EndReceive(conn.Outgoing.BeginReceive(buffer, 0, buffer.Length, null, null)); message.Decode(buffer, 0, buffer.Length); Assert.AreEqual(VersionInfo.ProtocolStringV100, message.ProtocolString); }
static void HandshakeReceived(bool successful, int transferred, object state) { var data = (ReceiveMessageState) state; PeerMessage message = null; if (successful) { data.Decryptor.Decrypt (data.Buffer, 0, transferred); message = new HandshakeMessage (); message.Decode (data.Buffer, 0, transferred); } data.Callback (successful, message, data.State); ClientEngine.BufferManager.FreeBuffer (data.Buffer); receiveCache.Enqueue (data); }
public void HandshakeDecoding() { var infohash = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 12, 15, 12, 52 }; var orig = new HandshakeMessage(new InfoHash (infohash), "12312312345645645678", VersionInfo.ProtocolStringV100); orig.Encode(_buffer, Offset); var dec = new HandshakeMessage(); dec.Decode(_buffer, Offset, 68); Assert.IsTrue(orig.Equals(dec)); Assert.AreEqual(orig.Encode(), dec.Encode()); }
public void TestHandshake(byte[] buffer, CustomConnection connection) { // 1) Send local handshake SendMessage(new HandshakeMessage(rig.Manager.Torrent.infoHash, new string('g', 20), VersionInfo.ProtocolStringV100, true, false), connection); // 2) Receive remote handshake if (buffer == null || buffer.Length == 0) { buffer = new byte[68]; Receive (connection, buffer, 0, 68); decryptor.Decrypt(buffer); } HandshakeMessage handshake = new HandshakeMessage(); handshake.Decode(buffer, 0, buffer.Length); Assert.AreEqual(rig.Engine.PeerId, handshake.PeerId, "#2"); Assert.AreEqual(VersionInfo.ProtocolStringV100, handshake.ProtocolString, "#3"); Assert.AreEqual(ClientEngine.SupportsFastPeer, handshake.SupportsFastPeer, "#4"); Assert.AreEqual(ClientEngine.SupportsExtended, handshake.SupportsExtendedMessaging, "#5"); // 2) Send local bitfield SendMessage(new BitfieldMessage(rig.Manager.Bitfield), connection); // 3) Receive remote bitfield - have none PeerMessage message = ReceiveMessage(connection); Assert.IsTrue (message is HaveNoneMessage || message is BitfieldMessage, "HaveNone"); // 4) Send a few allowed fast SendMessage(new AllowedFastMessage(1), connection); SendMessage(new AllowedFastMessage(2), connection); SendMessage(new AllowedFastMessage(3), connection); SendMessage(new AllowedFastMessage(0), connection); // 5) Receive a few allowed fast ReceiveMessage(connection); ReceiveMessage(connection); ReceiveMessage(connection); ReceiveMessage(connection); ReceiveMessage(connection); ReceiveMessage(connection); ReceiveMessage(connection); ReceiveMessage(connection); ReceiveMessage(connection); ReceiveMessage(connection); }
private static void HandshakeReceived(bool succeeded, int count, object state) { EncryptorAsyncResult result = (EncryptorAsyncResult)state; IConnection connection = result.Id.Connection; try { if (!succeeded) throw new EncryptionException("Couldn't receive the handshake"); result.Available += count; HandshakeMessage message = new HandshakeMessage(); message.Decode(result.Buffer, 0, result.Buffer.Length); bool valid = message.ProtocolString == VersionInfo.ProtocolStringV100; EncryptionTypes usable = CheckRC4(result.Id); bool canUseRC4 = Toolbox.HasEncryption(usable, EncryptionTypes.RC4Header) || Toolbox.HasEncryption(usable, EncryptionTypes.RC4Full); // If encryption is disabled and we received an invalid handshake - abort! if (valid) { result.InitialData = result.Buffer; result.Complete(); return; } if (!canUseRC4 && !valid) { result.Complete(new EncryptionException("Invalid handshake received and no decryption works")); return; } if (canUseRC4) { // The data we just received was part of an encrypted handshake and was *not* the BitTorrent handshake result.EncSocket = new PeerBEncryption(result.SKeys, EncryptionTypes.All); result.EncSocket.BeginHandshake(connection, result.Buffer, 0, result.Buffer.Length, CompletedEncryptedHandshakeCallback, result); } else { result.Complete(); } } catch (Exception ex) { result.Complete(ex); return; } }
private void PeerBTest(EncryptionTypes encryption) { rig.Engine.Settings.AllowedEncryption = encryption; rig.Engine.StartAll(); rig.AddConnection(conn.Outgoing); PeerBEncryption a = new PeerBEncryption(new InfoHash[] { rig.Manager.InfoHash }, EncryptionTypes.All); IAsyncResult result = a.BeginHandshake(conn.Incoming, null, null); if (!result.AsyncWaitHandle.WaitOne(4000, true)) Assert.Fail("Handshake timed out"); a.EndHandshake(result); HandshakeMessage message = new HandshakeMessage(); byte[] buffer = new byte[68]; conn.Incoming.EndReceive(conn.Incoming.BeginReceive(buffer, 0, buffer.Length, null, null)); a.Decryptor.Decrypt(buffer); message.Decode(buffer, 0, buffer.Length); Assert.AreEqual(VersionInfo.ProtocolStringV100, message.ProtocolString); if (encryption == EncryptionTypes.RC4Full) Assert.IsTrue(a.Encryptor is RC4); else if (encryption == EncryptionTypes.RC4Header) Assert.IsTrue(a.Encryptor is RC4Header); else if (encryption == EncryptionTypes.PlainText) Assert.IsTrue(a.Encryptor is RC4Header); }
private void PeerATest(EncryptionTypes encryption, bool addInitial) { rig.Engine.Settings.AllowedEncryption = encryption; rig.Engine.StartAll(); HandshakeMessage message = new HandshakeMessage(rig.Manager.InfoHash, "ABC123ABC123ABC123AB", VersionInfo.ProtocolStringV100); byte[] buffer = message.Encode(); PeerAEncryption a = new PeerAEncryption(rig.Manager.InfoHash, encryption); if (addInitial) a.AddPayload(buffer); rig.AddConnection(conn.Incoming); IAsyncResult result = a.BeginHandshake(conn.Outgoing, null, null); if (!result.AsyncWaitHandle.WaitOne(4000, true)) Assert.Fail("Handshake timed out"); a.EndHandshake(result); if (!addInitial) { a.Encryptor.Encrypt(buffer); conn.Outgoing.EndSend(conn.Outgoing.BeginSend(buffer, 0, buffer.Length, null, null)); } int received = conn.Outgoing.EndReceive(conn.Outgoing.BeginReceive(buffer, 0, buffer.Length, null, null)); Assert.AreEqual (68, received, "Recived handshake"); a.Decryptor.Decrypt(buffer); message.Decode(buffer, 0, buffer.Length); Assert.AreEqual(VersionInfo.ProtocolStringV100, message.ProtocolString); if (encryption == EncryptionTypes.RC4Full) Assert.IsTrue(a.Encryptor is RC4); else if (encryption == EncryptionTypes.RC4Header) Assert.IsTrue(a.Encryptor is RC4Header); else if (encryption == EncryptionTypes.PlainText) Assert.IsTrue(a.Encryptor is RC4Header); }
private void Handshake(EncryptionTypes encryptionA, EncryptionTypes encryptionB, bool addInitial) { bool doneA = false; bool doneB = false; HandshakeMessage m = new HandshakeMessage(rig.Torrent.InfoHash, "12345123451234512345", VersionInfo.ProtocolStringV100); byte[] handshake = m.Encode(); PeerAEncryption a = new PeerAEncryption(rig.Torrent.InfoHash, encryptionA); if (addInitial) a.AddPayload(handshake); PeerBEncryption b = new PeerBEncryption(new InfoHash[] { rig.Torrent.InfoHash }, encryptionB); IAsyncResult resultA = a.BeginHandshake(conn.Outgoing, null, null); IAsyncResult resultB = b.BeginHandshake(conn.Incoming, null, null); WaitHandle[] handles = new WaitHandle[] { resultA.AsyncWaitHandle, resultB.AsyncWaitHandle }; int count = 1000; while (!WaitHandle.WaitAll(handles, 5, true)) { if (!doneA && (doneA = resultA.IsCompleted)) a.EndHandshake(resultA); if (!doneB && (doneB = resultB.IsCompleted)) b.EndHandshake(resultB); if (count-- == 0) Assert.Fail("Could not handshake"); } if (!doneA) a.EndHandshake(resultA); if (!doneB) b.EndHandshake(resultB); HandshakeMessage d = new HandshakeMessage(); if (!addInitial) { a.Encrypt(handshake, 0, handshake.Length); b.Decrypt(handshake, 0, handshake.Length); d.Decode(handshake, 0, handshake.Length); } else { d.Decode(b.InitialData, 0, b.InitialData.Length); } Assert.AreEqual(m, d); if (encryptionA == EncryptionTypes.RC4Full || encryptionB == EncryptionTypes.RC4Full) { Assert.IsTrue(a.Encryptor is RC4); Assert.IsTrue(b.Encryptor is RC4); } else if (encryptionA == EncryptionTypes.RC4Header || encryptionB == EncryptionTypes.RC4Header) { Assert.IsTrue(a.Encryptor is RC4Header); Assert.IsTrue(b.Encryptor is RC4Header); } else if (encryptionA == EncryptionTypes.PlainText || encryptionB == EncryptionTypes.PlainText) { Assert.IsTrue(a.Encryptor is PlainTextEncryption); Assert.IsTrue(b.Encryptor is PlainTextEncryption); } }