public void HandshakeDecoding() { byte[] infohash = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 12, 15, 12, 52 }; HandshakeMessage orig = new HandshakeMessage(new InfoHash(infohash), "12312312345645645678", VersionInfo.ProtocolStringV100); orig.Encode(buffer, offset); HandshakeMessage dec = new HandshakeMessage(); dec.Decode(buffer, offset, HandshakeMessage.HandshakeLength); Assert.IsTrue(orig.Equals(dec)); Assert.AreEqual(orig.Encode(), dec.Encode()); }
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()); }
protected void OutputMessage(HandshakeMessage message) { byte[] data = message.Encode(); _handshakeStream.Write(data, 0, data.Length); _outputMessages.Add(message); }
protected override void ProcessCertificateVerify(HandshakeMessage verify) { if (_state != HandshakeState.ReceivedClientKeyExchange) { throw new AlertException(AlertDescription.UnexpectedMessage, "Certificate verify received at the wrong time"); } if (!_clientCertificateReceived) { throw new AlertException(AlertDescription.UnexpectedMessage, "Certificate verify received even though client certificate not received"); } // Get all handshake messages up to, but not including, this one byte[] allMessages = _handshakeStream.ToArray(); byte[] handshakeMessages = new byte[allMessages.Length - verify.Encode().Length]; Buffer.BlockCopy(allMessages, 0, handshakeMessages, 0, handshakeMessages.Length); // Verify the signature of handshake messages CertificatePublicKey publicKey = new CertificatePublicKey(_clientCertificates[0]); bool signatureOk = VerifySignature(publicKey, handshakeMessages, verify.Data); if (!signatureOk) { throw new AlertException(AlertDescription.DecodeError, "Signature from client incorrect"); } // Wait for changecipherspec+finished _state = HandshakeState.ReceivedClientKeyExchange; }
protected override void ProcessFinished(HandshakeMessage finished) { if (_state != HandshakeState.ReceivedChangeCipherSpec) { throw new AlertException(AlertDescription.UnexpectedMessage, "Finished received at the wrong time"); } byte[] allMessages = _handshakeStream.ToArray(); byte[] handshakeMessages = new byte[allMessages.Length - finished.Encode().Length]; Buffer.BlockCopy(allMessages, 0, handshakeMessages, 0, handshakeMessages.Length); PseudoRandomFunction prf = _cipherSuite.PseudoRandomFunction; HashAlgorithm verifyHash = prf.CreateVerifyHashAlgorithm(_connectionState.MasterSecret); verifyHash.TransformBlock(handshakeMessages, 0, handshakeMessages.Length, handshakeMessages, 0); byte[] ourVerifyData; if (_version == ProtocolVersion.SSL3_0) { byte[] senderBytes = Encoding.ASCII.GetBytes("CLNT"); verifyHash.TransformFinalBlock(senderBytes, 0, senderBytes.Length); ourVerifyData = verifyHash.Hash; } else { verifyHash.TransformFinalBlock(new byte[0], 0, 0); byte[] hash = verifyHash.Hash; int length = _cipherSuite.PseudoRandomFunction.VerifyDataLength; ourVerifyData = _cipherSuite.PseudoRandomFunction.GetBytes(_connectionState.MasterSecret, "client finished", hash, length); } // Verify that the received data matches ours bool verifyOk = false; if (ourVerifyData.Length == finished.Data.Length) { verifyOk = true; for (int i = 0; i < ourVerifyData.Length; i++) { if (ourVerifyData[i] != finished.Data[i]) { verifyOk = false; } } } if (!verifyOk) { throw new AlertException(AlertDescription.DecryptError, "Finished packet contents incorrect"); } _connectionState.ClientVerifyData = ourVerifyData; // Send our own change cipher spec _state = HandshakeState.SendChangeCipherSpec; }
private void Handshake(EncryptionTypes encryptionA, EncryptionTypes encryptionB, bool addInitial) { 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); var resultA = a.HandshakeAsync(conn.Outgoing); var resultB = b.HandshakeAsync(conn.Incoming); if (!Task.WhenAll(resultA, resultB).Wait(5000)) { Assert.Fail("Could not handshake"); } 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); } }
public void ProcessMessage(HandshakeMessage message) { byte[] msgData = message.Encode(); _handshakeStream.Write(msgData, 0, msgData.Length); switch (message.Type) { case HandshakeMessageType.HelloRequest: ProcessHelloRequest(); break; case HandshakeMessageType.ClientHello: ProcessClientHello((HandshakeClientHello)message); break; case HandshakeMessageType.ServerHello: ProcessServerHello((HandshakeServerHello)message); break; case HandshakeMessageType.NewSessionTicket: ProcessNewSessionTicket(message); break; case HandshakeMessageType.Certificate: ProcessCertificate((HandshakeCertificate)message); break; case HandshakeMessageType.ServerKeyExchange: ProcessServerKeyExchange(message); break; case HandshakeMessageType.CertificateRequest: ProcessCertificateRequest((HandshakeCertificateRequest)message); break; case HandshakeMessageType.ServerHelloDone: ProcessServerHelloDone(message); break; case HandshakeMessageType.CertificateVerify: ProcessCertificateVerify(message); break; case HandshakeMessageType.ClientKeyExchange: ProcessClientKeyExchange(message); break; case HandshakeMessageType.Finished: ProcessFinished(message); break; } }
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 NETSTANDARD1_5 if (!result.AsyncWaitHandle.WaitOne(4000)) #else if (!result.AsyncWaitHandle.WaitOne(4000, true)) #endif { Assert.True(false, "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.True(68 == received, "Recived handshake"); a.Decryptor.Decrypt(buffer); message.Decode(buffer, 0, buffer.Length); Assert.Equal(VersionInfo.ProtocolStringV100, message.ProtocolString); if (encryption == EncryptionTypes.RC4Full) { Assert.True(a.Encryptor is RC4); } else if (encryption == EncryptionTypes.RC4Header) { Assert.True(a.Encryptor is RC4Header); } else if (encryption == EncryptionTypes.PlainText) { Assert.True(a.Encryptor is RC4Header); } }
async Task PeerATest(EncryptionTypes encryption, bool addInitial) { rig.Engine.Settings.AllowedEncryption = encryption; await 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); var result = a.HandshakeAsync(conn.Outgoing); if (!result.Wait(4000)) { Assert.Fail("Handshake timed out"); } if (!addInitial) { a.Encryptor.Encrypt(buffer); await conn.Outgoing.SendAsync(buffer, 0, buffer.Length); } int received = await conn.Outgoing.ReceiveAsync(buffer, 0, buffer.Length); Assert.AreEqual(HandshakeMessage.HandshakeLength, 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 PeerATest(EncryptionTypes encryption, bool addInitial) { rig.Engine.Settings.AllowedEncryption = encryption; rig.Engine.StartAll(); var message = new HandshakeMessage(rig.Manager.InfoHash, "ABC123ABC123ABC123AB", VersionInfo.ProtocolStringV100); var buffer = message.Encode(); var a = new PeerAEncryption(rig.Manager.InfoHash, encryption); if (addInitial) { a.AddPayload(buffer); } rig.AddConnection(conn.Incoming); var 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.IsInstanceOf <RC4>(a.Encryptor); } else if (encryption == EncryptionTypes.RC4Header) { Assert.IsInstanceOf <RC4Header>(a.Encryptor); } else if (encryption == EncryptionTypes.PlainText) { Assert.IsInstanceOf <RC4Header>(a.Encryptor); } }
public void SendFinished(Stream stream) { Record record; /* change cipher spec */ record = new Record(20, VERSION); record.Fragment = new byte[] { 0x01 }; _recordHandler.ProcessOutputRecord(record); SendRecord(stream, record); /* change our own cipher spec */ _recordHandler.ChangeLocalState(); ProtocolVersion version = VERSION; byte[] handshakeMessages = _handshakeStream.ToArray(); Console.WriteLine("handshake messages length " + handshakeMessages.Length); PseudoRandomFunction prf = _cipherSuite.PseudoRandomFunction; HashAlgorithm verifyHash = prf.CreateVerifyHashAlgorithm(_masterSecret); verifyHash.TransformBlock(handshakeMessages, 0, handshakeMessages.Length, handshakeMessages, 0); byte[] verifyData; if (version == ProtocolVersion.SSL3_0) { byte[] senderBytes = Encoding.ASCII.GetBytes("CLNT"); verifyHash.TransformFinalBlock(senderBytes, 0, senderBytes.Length); verifyData = verifyHash.Hash; } else { verifyHash.TransformFinalBlock(new byte[0], 0, 0); byte[] hash = verifyHash.Hash; int length = _cipherSuite.PseudoRandomFunction.VerifyDataLength; verifyData = _cipherSuite.PseudoRandomFunction.GetBytes(_masterSecret, "client finished", hash, length); } HandshakeMessage finished = new HandshakeMessage(HandshakeMessageType.Finished, VERSION, verifyData); PrintBytes("verify data", finished.Data); record = new Record(22, VERSION); record.Fragment = finished.Encode(); _recordHandler.ProcessOutputRecord(record); SendRecord(stream, record); Console.WriteLine("encrypted finished sent"); }
public void EncryptorFactoryPeerAPlain() { rig.Engine.StartAll(); rig.AddConnection(conn.Incoming); var message = new HandshakeMessage(rig.Manager.InfoHash, "ABC123ABC123ABC123AB", VersionInfo.ProtocolStringV100); var 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); }
public async Task EncryptorFactoryPeerAPlain() { await rig.Engine.StartAll(); rig.AddConnection(conn.Incoming); HandshakeMessage message = new HandshakeMessage(rig.Manager.InfoHash, "ABC123ABC123ABC123AB", VersionInfo.ProtocolStringV100); byte[] buffer = message.Encode(); await conn.Outgoing.SendAsync(buffer, 0, buffer.Length); await conn.Outgoing.ReceiveAsync(buffer, 0, buffer.Length); message.Decode(buffer, 0, buffer.Length); Assert.AreEqual(VersionInfo.ProtocolStringV100, message.ProtocolString); }
static async ReusableTask <EncryptorResult> DoCheckOutgoingConnectionAsync(IConnection2 connection, EncryptionTypes encryption, EngineSettings settings, InfoHash infoHash, HandshakeMessage handshake) { EncryptionTypes allowedEncryption = settings.AllowedEncryption & encryption; bool supportsRC4Header = allowedEncryption.HasFlag(EncryptionTypes.RC4Header); bool supportsRC4Full = allowedEncryption.HasFlag(EncryptionTypes.RC4Full); bool supportsPlainText = allowedEncryption.HasFlag(EncryptionTypes.PlainText); if ((settings.PreferEncryption || !supportsPlainText) && (supportsRC4Header || supportsRC4Full)) { // First switch to the threadpool as creating encrypted sockets runs expensive computations in the ctor await MainLoop.SwitchToThreadpool(); var encSocket = new PeerAEncryption(infoHash, allowedEncryption, handshake?.Encode()); await encSocket.HandshakeAsync(connection).ConfigureAwait(false); if (encSocket.Decryptor is RC4Header && !supportsRC4Header) { throw new EncryptionException("Decryptor was RC4Header but that is not allowed"); } if (encSocket.Decryptor is RC4 && !supportsRC4Full) { throw new EncryptionException("Decryptor was RC4Full but that is not allowed"); } return(new EncryptorResult(encSocket.Decryptor, encSocket.Encryptor, null)); } else if (supportsPlainText) { if (handshake != null) { int length = handshake.ByteLength; byte[] buffer = ClientEngine.BufferPool.Rent(length); handshake.Encode(buffer, 0); try { await NetworkIO.SendAsync(connection, buffer, 0, length, null, null, null).ConfigureAwait(false); } finally { ClientEngine.BufferPool.Return(buffer); } } return(new EncryptorResult(PlainTextEncryption.Instance, PlainTextEncryption.Instance, null)); } connection.Dispose(); throw new EncryptionException("Invalid handshake received and no decryption works"); }
static async ReusableTask <EncryptorResult> DoCheckOutgoingConnectionAsync(IConnection2 connection, EncryptionTypes encryption, EngineSettings settings, InfoHash infoHash, HandshakeMessage handshake) { var allowedEncryption = settings.AllowedEncryption & encryption; var supportsRC4Header = allowedEncryption.HasFlag(EncryptionTypes.RC4Header); var supportsRC4Full = allowedEncryption.HasFlag(EncryptionTypes.RC4Full); var supportsPlainText = allowedEncryption.HasFlag(EncryptionTypes.PlainText); if ((settings.PreferEncryption || !supportsPlainText) && (supportsRC4Header || supportsRC4Full)) { var encSocket = new PeerAEncryption(infoHash, allowedEncryption, handshake?.Encode()); await encSocket.HandshakeAsync(connection); if (encSocket.Decryptor is RC4Header && !supportsRC4Header) { throw new EncryptionException("Decryptor was RC4Header but that is not allowed"); } if (encSocket.Decryptor is RC4 && !supportsRC4Full) { throw new EncryptionException("Decryptor was RC4Full but that is not allowed"); } return(new EncryptorResult(encSocket.Decryptor, encSocket.Encryptor, null)); } else if (supportsPlainText) { if (handshake != null) { var length = handshake.ByteLength; var buffer = ClientEngine.BufferPool.Rent(length); handshake.Encode(buffer, 0); try { await NetworkIO.SendAsync(connection, buffer, 0, length, null, null, null); } finally { ClientEngine.BufferPool.Return(buffer); } } return(new EncryptorResult(PlainTextEncryption.Instance, PlainTextEncryption.Instance, null)); } connection.Dispose(); throw new EncryptionException("Invalid handshake received and no decryption works"); }
public void SendClientKey(Stream stream) { byte[] clientKeys = _cipherSuite.KeyExchangeAlgorithm.GetClientKeys(VERSION, VERSION, _rsaPublicKey); if (VERSION != ProtocolVersion.SSL3_0) { byte[] tmpArray = new byte[clientKeys.Length + 2]; tmpArray[0] = (byte)(clientKeys.Length >> 8); tmpArray[1] = (byte)(clientKeys.Length); Buffer.BlockCopy(clientKeys, 0, tmpArray, 2, clientKeys.Length); clientKeys = tmpArray; } HandshakeMessage keyex = new HandshakeMessage(HandshakeMessageType.ClientKeyExchange, VERSION, clientKeys); Record record = new Record(22, VERSION); record.Fragment = keyex.Encode(); _recordHandler.ProcessOutputRecord(record); SendRecord(stream, record); }
static async ReusableTask <EncryptorResult> DoCheckOutgoingConnectionAsync(IPeerConnection connection, IList <EncryptionType> preferredEncryption, InfoHash infoHash, HandshakeMessage?handshake, Factories factories) { bool supportsRC4Header = preferredEncryption.Contains(EncryptionType.RC4Header); bool supportsRC4Full = preferredEncryption.Contains(EncryptionType.RC4Full); bool supportsPlainText = preferredEncryption.Contains(EncryptionType.PlainText); // First switch to the threadpool as creating encrypted sockets runs expensive computations in the ctor await MainLoop.SwitchToThreadpool(); Memory <byte> handshakeBuffer = default; using var releaser = handshake == null ? default : NetworkIO.BufferPool.Rent(handshake.ByteLength, out handshakeBuffer); handshake?.Encode(handshakeBuffer.Span); if (preferredEncryption[0] != EncryptionType.PlainText) { using var encSocket = new PeerAEncryption(factories, infoHash, preferredEncryption, handshakeBuffer); await encSocket.HandshakeAsync(connection).ConfigureAwait(false); if (encSocket.Decryptor is RC4Header && !supportsRC4Header) { throw new EncryptionException("Decryptor was RC4Header but that is not allowed"); } if (encSocket.Decryptor is RC4 && !supportsRC4Full) { throw new EncryptionException("Decryptor was RC4Full but that is not allowed"); } return(new EncryptorResult(encSocket.Decryptor !, encSocket.Encryptor !, null)); } else if (supportsPlainText) { if (handshakeBuffer.Length > 0) { await NetworkIO.SendAsync(connection, handshakeBuffer, null, null, null).ConfigureAwait(false); } return(new EncryptorResult(PlainTextEncryption.Instance, PlainTextEncryption.Instance, null)); } connection.Dispose(); throw new EncryptionException("Invalid handshake received and no decryption works"); }
static async ReusableTask <EncryptorResult> DoCheckOutgoingConnectionAsync(IConnection connection, IList <EncryptionType> preferredEncryption, InfoHash infoHash, HandshakeMessage handshake) { bool supportsRC4Header = preferredEncryption.Contains(EncryptionType.RC4Header); bool supportsRC4Full = preferredEncryption.Contains(EncryptionType.RC4Full); bool supportsPlainText = preferredEncryption.Contains(EncryptionType.PlainText); // First switch to the threadpool as creating encrypted sockets runs expensive computations in the ctor await MainLoop.SwitchToThreadpool(); if (preferredEncryption[0] != EncryptionType.PlainText) { var encSocket = new PeerAEncryption(infoHash, preferredEncryption, handshake?.Encode()); await encSocket.HandshakeAsync(connection).ConfigureAwait(false); if (encSocket.Decryptor is RC4Header && !supportsRC4Header) { throw new EncryptionException("Decryptor was RC4Header but that is not allowed"); } if (encSocket.Decryptor is RC4 && !supportsRC4Full) { throw new EncryptionException("Decryptor was RC4Full but that is not allowed"); } return(new EncryptorResult(encSocket.Decryptor, encSocket.Encryptor, null)); } else if (supportsPlainText) { if (handshake != null) { int length = handshake.ByteLength; using (NetworkIO.BufferPool.Rent(length, out ByteBuffer buffer)) { handshake.Encode(buffer.Data, 0); await NetworkIO.SendAsync(connection, buffer, 0, length, null, null, null).ConfigureAwait(false); } } return(new EncryptorResult(PlainTextEncryption.Instance, PlainTextEncryption.Instance, null)); } connection.Dispose(); throw new EncryptionException("Invalid handshake received and no decryption works"); }
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); } }