disable broken tests on net_4_0

[mcs.git] / class / System.ServiceModel / Mono.Security.Protocol.Tls / RecordProtocol.cs

// Transport Security Layer (TLS)
// Copyright (c) 2003-2004 Carlos Guzman Alvarez
// Copyright (C) 2006-2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System;
using System.Collections;
using System.IO;
using System.Threading;

using Mono.Security.Protocol.Tls.Handshake;

namespace Mono.Security.Protocol.Tls
{
        internal abstract class RecordProtocol
        {
                #region Fields

                private static ManualResetEvent record_processing = new ManualResetEvent (true);

                protected Stream        innerStream;
                protected Context       context;

                #endregion

                #region Properties

                public Context Context
                {
                        get { return this.context; }
                        set { this.context = value; }
                }

                #endregion

                #region Constructors

                public RecordProtocol(Stream innerStream, Context context)
                {
                        this.innerStream                        = innerStream;
                        this.context                            = context;
                        this.context.RecordProtocol = this;
                }

                #endregion

                #region Abstract Methods

                public virtual void SendRecord(HandshakeType type)
                {

                        IAsyncResult ar = this.BeginSendRecord(type, null, null);

                        this.EndSendRecord(ar);

                }

                protected abstract void ProcessHandshakeMessage(TlsStream handMsg);

                protected virtual void ProcessChangeCipherSpec ()
                {
                        Context ctx = this.Context;

                        // Reset sequence numbers
                        ctx.ReadSequenceNumber = 0;

                        if (ctx is ClientContext) {
                                ctx.EndSwitchingSecurityParameters (true);
                        } else {
                                ctx.StartSwitchingSecurityParameters (false);
                        }
                }

                public virtual HandshakeMessage GetMessage(HandshakeType type)
                {
                        throw new NotSupportedException();
                }

                #endregion

                #region Receive Record Async Result
                private class ReceiveRecordAsyncResult : IAsyncResult
                {
                        private object locker = new object ();
                        private AsyncCallback _userCallback;
                        private object _userState;
                        private Exception _asyncException;
                        private ManualResetEvent handle;
                        private byte[] _resultingBuffer;
                        private Stream _record;
                        private bool completed;

                        private byte[] _initialBuffer;

                        public ReceiveRecordAsyncResult(AsyncCallback userCallback, object userState, byte[] initialBuffer, Stream record)
                        {
                                _userCallback = userCallback;
                                _userState = userState;
                                _initialBuffer = initialBuffer;
                                _record = record;
                        }

                        public Stream Record
                        {
                                get { return _record; }
                        }

                        public byte[] ResultingBuffer
                        {
                                get { return _resultingBuffer; }
                        }

                        public byte[] InitialBuffer
                        {
                                get { return _initialBuffer; }
                        }

                        public object AsyncState
                        {
                                get { return _userState; }
                        }

                        public Exception AsyncException
                        {
                                get { return _asyncException; }
                        }

                        public bool CompletedWithError
                        {
                                get {
                                        if (!IsCompleted)
                                                return false; // Perhaps throw InvalidOperationExcetion?

                                        return null != _asyncException;
                                }
                        }

                        public WaitHandle AsyncWaitHandle
                        {
                                get {
                                        lock (locker) {
                                                if (handle == null)
                                                        handle = new ManualResetEvent (completed);
                                        }
                                        return handle;
                                }
                                
                        }

                        public bool CompletedSynchronously
                        {
                                get { return false; }
                        }

                        public bool IsCompleted
                        {
                                get {
                                        lock (locker) {
                                                return completed;
                                        }
                                }
                        }

                        private void SetComplete(Exception ex, byte[] resultingBuffer)
                        {
                                lock (locker) {
                                        if (completed)
                                                return;

                                        completed = true;
                                        _asyncException = ex;
                                        _resultingBuffer = resultingBuffer;
                                        if (handle != null)
                                                handle.Set ();

                                        if (_userCallback != null)
                                                _userCallback.BeginInvoke (this, null, null);
                                }
                        }

                        public void SetComplete(Exception ex)
                        {
                                SetComplete(ex, null);
                        }

                        public void SetComplete(byte[] resultingBuffer)
                        {
                                SetComplete(null, resultingBuffer);
                        }

                        public void SetComplete()
                        {
                                SetComplete(null, null);
                        }
                }
                #endregion

                #region Receive Record Async Result
                private class SendRecordAsyncResult : IAsyncResult
                {
                        private object locker = new object ();
                        private AsyncCallback _userCallback;
                        private object _userState;
                        private Exception _asyncException;
                        private ManualResetEvent handle;
                        private HandshakeMessage _message;
                        private bool completed;

                        public SendRecordAsyncResult(AsyncCallback userCallback, object userState, HandshakeMessage message)
                        {
                                _userCallback = userCallback;
                                _userState = userState;
                                _message = message;
                        }

                        public HandshakeMessage Message
                        {
                                get { return _message; }
                        }

                        public object AsyncState
                        {
                                get { return _userState; }
                        }

                        public Exception AsyncException
                        {
                                get { return _asyncException; }
                        }

                        public bool CompletedWithError
                        {
                                get {
                                        if (!IsCompleted)
                                                return false; // Perhaps throw InvalidOperationExcetion?

                                        return null != _asyncException;
                                }
                        }

                        public WaitHandle AsyncWaitHandle
                        {
                                get {
                                        lock (locker) {
                                                if (handle == null)
                                                        handle = new ManualResetEvent (completed);
                                        }
                                        return handle;
                                }
                                
                        }

                        public bool CompletedSynchronously
                        {
                                get { return false; }
                        }

                        public bool IsCompleted
                        {
                                get {
                                        lock (locker) {
                                                return completed;
                                        }
                                }
                        }

                        public void SetComplete(Exception ex)
                        {
                                lock (locker) {
                                        if (completed)
                                                return;

                                        completed = true;
                                        if (handle != null)
                                                handle.Set ();

                                        if (_userCallback != null)
                                                _userCallback.BeginInvoke (this, null, null);

                                        _asyncException = ex;
                                }
                        }

                        public void SetComplete()
                        {
                                SetComplete(null);
                        }
                }
                #endregion

                #region Reveive Record Methods

                public IAsyncResult BeginReceiveRecord(Stream record, AsyncCallback callback, object state)
                {
                        if (this.context.ConnectionEnd)
                        {
                                throw new TlsException(
                                        AlertDescription.InternalError,
                                        "The session is finished and it's no longer valid.");
                        }

                        record_processing.Reset ();
                        byte[] recordTypeBuffer = new byte[1];

                        ReceiveRecordAsyncResult internalResult = new ReceiveRecordAsyncResult(callback, state, recordTypeBuffer, record);

                        record.BeginRead(internalResult.InitialBuffer, 0, internalResult.InitialBuffer.Length, new AsyncCallback(InternalReceiveRecordCallback), internalResult);

                        return internalResult;
                }

                private void InternalReceiveRecordCallback(IAsyncResult asyncResult)
                {
                        ReceiveRecordAsyncResult internalResult = asyncResult.AsyncState as ReceiveRecordAsyncResult;
                        Stream record = internalResult.Record;

                        try
                        {
                                
                                int bytesRead = internalResult.Record.EndRead(asyncResult);

                                //We're at the end of the stream. Time to bail.
                                if (bytesRead == 0)
                                {
                                        internalResult.SetComplete((byte[])null);
                                        return;
                                }

                                // Try to read the Record Content Type
                                int type = internalResult.InitialBuffer[0];

                                // Set last handshake message received to None
                                this.context.LastHandshakeMsg = HandshakeType.ClientHello;

                                ContentType     contentType     = (ContentType)type;
                                byte[] buffer = this.ReadRecordBuffer(type, record);
                                if (buffer == null)
                                {
                                        // record incomplete (at the moment)
                                        internalResult.SetComplete((byte[])null);
                                        return;
                                }

                                // Decrypt message contents if needed
                                if (contentType == ContentType.Alert && buffer.Length == 2)
                                {
                                }
                                else if ((this.Context.Read != null) && (this.Context.Read.Cipher != null))
                                {
                                        buffer = this.decryptRecordFragment (contentType, buffer);
                                        DebugHelper.WriteLine ("Decrypted record data", buffer);
                                }

                                // Process record
                                switch (contentType)
                                {
                                        case ContentType.Alert:
                                                this.ProcessAlert((AlertLevel)buffer [0], (AlertDescription)buffer [1]);
                                                if (record.CanSeek) 
                                                {
                                                        // don't reprocess that memory block
                                                        record.SetLength (0); 
                                                }
                                                buffer = null;
                                                break;

                                        case ContentType.ChangeCipherSpec:
                                                this.ProcessChangeCipherSpec();
                                                break;

                                        case ContentType.ApplicationData:
                                                break;

                                        case ContentType.Handshake:
                                                TlsStream message = new TlsStream (buffer);
                                                while (!message.EOF)
                                                {
                                                        this.ProcessHandshakeMessage(message);
                                                }
                                                break;

                                        case (ContentType)0x80:
                                                this.context.HandshakeMessages.Write (buffer);
                                                break;

                                        default:
                                                throw new TlsException(
                                                        AlertDescription.UnexpectedMessage,
                                                        "Unknown record received from server.");
                                }

                                internalResult.SetComplete(buffer);
                        }
                        catch (Exception ex)
                        {
                                internalResult.SetComplete(ex);
                        }

                }

                public byte[] EndReceiveRecord(IAsyncResult asyncResult)
                {
                        ReceiveRecordAsyncResult internalResult = asyncResult as ReceiveRecordAsyncResult;

                        if (null == internalResult)
                                throw new ArgumentException("Either the provided async result is null or was not created by this RecordProtocol.");

                        if (!internalResult.IsCompleted)
                                internalResult.AsyncWaitHandle.WaitOne();

                        if (internalResult.CompletedWithError)
                                throw internalResult.AsyncException;

                        byte[] result = internalResult.ResultingBuffer;
                        record_processing.Set ();
                        return result;
                }

                public byte[] ReceiveRecord(Stream record)
                {

                        IAsyncResult ar = this.BeginReceiveRecord(record, null, null);
                        return this.EndReceiveRecord(ar);

                }

                private byte[] ReadRecordBuffer (int contentType, Stream record)
                {
                        switch (contentType)
                        {
                                case 0x80:
                                        return this.ReadClientHelloV2(record);

                                default:
                                        if (!Enum.IsDefined(typeof(ContentType), (ContentType)contentType))
                                        {
                                                throw new TlsException(AlertDescription.DecodeError);
                                        }
                                        return this.ReadStandardRecordBuffer(record);
                        }
                }

                private byte[] ReadClientHelloV2 (Stream record)
                {
                        int msgLength = record.ReadByte ();
                        // process further only if the whole record is available
                        if (record.CanSeek && (msgLength + 1 > record.Length)) 
                        {
                                return null;
                        }

                        byte[] message = new byte[msgLength];
                        record.Read (message, 0, msgLength);

                        int msgType             = message [0];
                        if (msgType != 1)
                        {
                                throw new TlsException(AlertDescription.DecodeError);
                        }
                        int protocol = (message [1] << 8 | message [2]);
                        int cipherSpecLength = (message [3] << 8 | message [4]);
                        int sessionIdLength = (message [5] << 8 | message [6]);
                        int challengeLength = (message [7] << 8 | message [8]);
                        int length = (challengeLength > 32) ? 32 : challengeLength;

                        // Read CipherSpecs
                        byte[] cipherSpecV2 = new byte[cipherSpecLength];
                        Buffer.BlockCopy (message, 9, cipherSpecV2, 0, cipherSpecLength);

                        // Read session ID
                        byte[] sessionId = new byte[sessionIdLength];
                        Buffer.BlockCopy (message, 9 + cipherSpecLength, sessionId, 0, sessionIdLength);

                        // Read challenge ID
                        byte[] challenge = new byte[challengeLength];
                        Buffer.BlockCopy (message, 9 + cipherSpecLength + sessionIdLength, challenge, 0, challengeLength);
                
                        if (challengeLength < 16 || cipherSpecLength == 0 || (cipherSpecLength % 3) != 0)
                        {
                                throw new TlsException(AlertDescription.DecodeError);
                        }

                        // Updated the Session ID
                        if (sessionId.Length > 0)
                        {
                                this.context.SessionId = sessionId;
                        }

                        // Update the protocol version
                        this.Context.ChangeProtocol((short)protocol);

                        // Select the Cipher suite
                        this.ProcessCipherSpecV2Buffer(this.Context.SecurityProtocol, cipherSpecV2);

                        // Updated the Client Random
                        this.context.ClientRandom = new byte [32]; // Always 32
                        // 1. if challenge is bigger than 32 bytes only use the last 32 bytes
                        // 2. right justify (0) challenge in ClientRandom if less than 32
                        Buffer.BlockCopy (challenge, challenge.Length - length, this.context.ClientRandom, 32 - length, length);

                        // Set 
                        this.context.LastHandshakeMsg = HandshakeType.ClientHello;
                        this.context.ProtocolNegotiated = true;

                        return message;
                }

                private byte[] ReadStandardRecordBuffer (Stream record)
                {
                        byte[] header = new byte[4];
                        if (record.Read (header, 0, 4) != 4)
                                throw new TlsException ("buffer underrun");
                        
                        short protocol = (short)((header [0] << 8) | header [1]);
                        short length = (short)((header [2] << 8) | header [3]);

                        // process further only if the whole record is available
                        // note: the first 5 bytes aren't part of the length
                        if (record.CanSeek && (length + 5 > record.Length)) 
                        {
                                return null;
                        }
                        
                        // Read Record data
                        int     totalReceived = 0;
                        byte[]  buffer          = new byte[length];
                        while (totalReceived != length)
                        {
                                int justReceived = record.Read(buffer, totalReceived, buffer.Length - totalReceived);

                                //Make sure we get some data so we don't end up in an infinite loop here before shutdown.
                                if (0 == justReceived)
                                {
                                        throw new TlsException(AlertDescription.CloseNotify, "Received 0 bytes from stream. It must be closed.");
                                }

                                totalReceived += justReceived;
                        }

                        // Check that the message has a valid protocol version
                        if (protocol != this.context.Protocol && this.context.ProtocolNegotiated)
                        {
                                throw new TlsException(
                                        AlertDescription.ProtocolVersion, "Invalid protocol version on message received");
                        }

                        DebugHelper.WriteLine("Record data", buffer);

                        return buffer;
                }

                private void ProcessAlert(AlertLevel alertLevel, AlertDescription alertDesc)
                {
                        switch (alertLevel)
                        {
                                case AlertLevel.Fatal:
                                        throw new TlsException(alertLevel, alertDesc);

                                case AlertLevel.Warning:
                                default:
                                switch (alertDesc)
                                {
                                        case AlertDescription.CloseNotify:
                                                this.context.ConnectionEnd = true;
                                                break;
                                }
                                break;
                        }
                }

                #endregion

                #region Send Alert Methods

                public void SendAlert(AlertDescription description)
                {
                        this.SendAlert(new Alert(description));
                }

                public void SendAlert(
                        AlertLevel                      level, 
                        AlertDescription        description)
                {
                        this.SendAlert(new Alert(level, description));
                }

                public void SendAlert(Alert alert)
                {
                        AlertLevel level;
                        AlertDescription description;
                        bool close;

                        if (alert == null) {
                                DebugHelper.WriteLine(">>>> Write Alert NULL");
                                level = AlertLevel.Fatal;
                                description = AlertDescription.InternalError;
                                close = true;
                        } else {
                                DebugHelper.WriteLine(">>>> Write Alert ({0}|{1})", alert.Description, alert.Message);
                                level = alert.Level;
                                description = alert.Description;
                                close = alert.IsCloseNotify;
                        }

                        // Write record
                        this.SendRecord (ContentType.Alert, new byte[2] { (byte) level, (byte) description });

                        if (close)
                        {
                                this.context.ConnectionEnd = true;
                        }
                }

                #endregion

                #region Send Record Methods

                public void SendChangeCipherSpec()
                {
                        DebugHelper.WriteLine(">>>> Write Change Cipher Spec");

                        // Send Change Cipher Spec message with the current cipher
                        // or as plain text if this is the initial negotiation
                        this.SendRecord(ContentType.ChangeCipherSpec, new byte[] {1});

                        Context ctx = this.context;

                        // Reset sequence numbers
                        ctx.WriteSequenceNumber = 0;

                        // all further data sent will be encrypted with the negotiated
                        // security parameters (now the current parameters)
                        if (ctx is ClientContext) {
                                ctx.StartSwitchingSecurityParameters (true);
                        } else {
                                ctx.EndSwitchingSecurityParameters (false);
                        }
                }

                public IAsyncResult BeginSendRecord(HandshakeType handshakeType, AsyncCallback callback, object state)
                {
                        HandshakeMessage msg = this.GetMessage(handshakeType);

                        msg.Process();

                        DebugHelper.WriteLine(">>>> Write handshake record ({0}|{1})", context.Protocol, msg.ContentType);

                        SendRecordAsyncResult internalResult = new SendRecordAsyncResult(callback, state, msg);

                        this.BeginSendRecord(msg.ContentType, msg.EncodeMessage(), new AsyncCallback(InternalSendRecordCallback), internalResult);

                        return internalResult;
                }

                private void InternalSendRecordCallback(IAsyncResult ar)
                {
                        SendRecordAsyncResult internalResult = ar.AsyncState as SendRecordAsyncResult;
                        
                        try
                        {
                                this.EndSendRecord(ar);

                                // Update session
                                internalResult.Message.Update();

                                // Reset message contents
                                internalResult.Message.Reset();

                                internalResult.SetComplete();
                        }
                        catch (Exception ex)
                        {
                                internalResult.SetComplete(ex);
                        }
                }

                public IAsyncResult BeginSendRecord(ContentType contentType, byte[] recordData, AsyncCallback callback, object state)
                {
                        if (this.context.ConnectionEnd)
                        {
                                throw new TlsException(
                                        AlertDescription.InternalError,
                                        "The session is finished and it's no longer valid.");
                        }

                        byte[] record = this.EncodeRecord(contentType, recordData);

                        return this.innerStream.BeginWrite(record, 0, record.Length, callback, state);
                }

                public void EndSendRecord(IAsyncResult asyncResult)
                {
                        if (asyncResult is SendRecordAsyncResult)
                        {
                                SendRecordAsyncResult internalResult = asyncResult as SendRecordAsyncResult;
                                if (!internalResult.IsCompleted)
                                        internalResult.AsyncWaitHandle.WaitOne();
                                if (internalResult.CompletedWithError)
                                        throw internalResult.AsyncException;
                        }
                        else
                        {
                                this.innerStream.EndWrite(asyncResult);
                        }
                }

                public void SendRecord(ContentType contentType, byte[] recordData)
                {
                        IAsyncResult ar = this.BeginSendRecord(contentType, recordData, null, null);

                        this.EndSendRecord(ar);
                }

                public byte[] EncodeRecord(ContentType contentType, byte[] recordData)
                {
                        return this.EncodeRecord(
                                contentType,
                                recordData,
                                0,
                                recordData.Length);
                }

                public byte[] EncodeRecord(
                        ContentType     contentType, 
                        byte[]          recordData,
                        int                     offset,
                        int                     count)
                {
                        if (this.context.ConnectionEnd)
                        {
                                throw new TlsException(
                                        AlertDescription.InternalError,
                                        "The session is finished and it's no longer valid.");
                        }

                        TlsStream record = new TlsStream();

                        int     position = offset;

                        while (position < ( offset + count ))
                        {
                                short   fragmentLength = 0;
                                byte[]  fragment;

                                if ((count + offset - position) > Context.MAX_FRAGMENT_SIZE)
                                {
                                        fragmentLength = Context.MAX_FRAGMENT_SIZE;
                                }
                                else
                                {
                                        fragmentLength = (short)(count + offset - position);
                                }

                                // Fill the fragment data
                                fragment = new byte[fragmentLength];
                                Buffer.BlockCopy(recordData, position, fragment, 0, fragmentLength);

                                if ((this.Context.Write != null) && (this.Context.Write.Cipher != null))
                                {
                                        // Encrypt fragment
                                        fragment = this.encryptRecordFragment (contentType, fragment);
                                }

                                // Write tls message
                                record.Write((byte)contentType);
                                record.Write(this.context.Protocol);
                                record.Write((short)fragment.Length);
                                record.Write(fragment);

                                DebugHelper.WriteLine("Record data", fragment);

                                // Update buffer position
                                position += fragmentLength;
                        }

                        return record.ToArray();
                }
                
                #endregion

                #region Cryptography Methods

                private byte[] encryptRecordFragment(
                        ContentType     contentType, 
                        byte[]          fragment)
                {
                        byte[] mac      = null;

                        // Calculate message MAC
                        if (this.Context is ClientContext)
                        {
                                mac = this.context.Write.Cipher.ComputeClientRecordMAC(contentType, fragment);
                        }       
                        else
                        {
                                mac = this.context.Write.Cipher.ComputeServerRecordMAC (contentType, fragment);
                        }

                        DebugHelper.WriteLine(">>>> Record MAC", mac);

                        // Encrypt the message
                        byte[] ecr = this.context.Write.Cipher.EncryptRecord (fragment, mac);

                        // Update sequence number
                        this.context.WriteSequenceNumber++;

                        return ecr;
                }

                private byte[] decryptRecordFragment(
                        ContentType     contentType, 
                        byte[]          fragment)
                {
                        byte[]  dcrFragment             = null;
                        byte[]  dcrMAC                  = null;

                        try
                        {
                                this.context.Read.Cipher.DecryptRecord (fragment, out dcrFragment, out dcrMAC);
                        }
                        catch
                        {
                                if (this.context is ServerContext)
                                {
                                        this.Context.RecordProtocol.SendAlert(AlertDescription.DecryptionFailed);
                                }

                                throw;
                        }
                        
                        // Generate record MAC
                        byte[] mac = null;

                        if (this.Context is ClientContext)
                        {
                                mac = this.context.Read.Cipher.ComputeServerRecordMAC(contentType, dcrFragment);
                        }
                        else
                        {
                                mac = this.context.Read.Cipher.ComputeClientRecordMAC (contentType, dcrFragment);
                        }

                        DebugHelper.WriteLine(">>>> Record MAC", mac);

                        // Check record MAC
                        if (!Compare (mac, dcrMAC))
                        {
                                throw new TlsException(AlertDescription.BadRecordMAC, "Bad record MAC");
                        }

                        // Update sequence number
                        this.context.ReadSequenceNumber++;

                        return dcrFragment;
                }

                private bool Compare (byte[] array1, byte[] array2)
                {
                        if (array1 == null)
                                return (array2 == null);
                        if (array2 == null)
                                return false;
                        if (array1.Length != array2.Length)
                                return false;
                        for (int i = 0; i < array1.Length; i++) {
                                if (array1[i] != array2[i])
                                        return false;
                        }
                        return true;
                }

                #endregion

                #region CipherSpecV2 processing

                private void ProcessCipherSpecV2Buffer (SecurityProtocolType protocol, byte[] buffer)
                {
                        TlsStream codes = new TlsStream(buffer);

                        string prefix = (protocol == SecurityProtocolType.Ssl3) ? "SSL_" : "TLS_";

                        while (codes.Position < codes.Length)
                        {
                                byte check = codes.ReadByte();

                                if (check == 0)
                                {
                                        // SSL/TLS cipher spec
                                        short code = codes.ReadInt16(); 
                                        int index = this.Context.SupportedCiphers.IndexOf(code);
                                        if (index != -1)
                                        {
                                                this.Context.Negotiating.Cipher = this.Context.SupportedCiphers[index];
                                                break;
                                        }
                                }
                                else
                                {
                                        byte[] tmp = new byte[2];
                                        codes.Read(tmp, 0, tmp.Length);

                                        int tmpCode = ((check & 0xff) << 16) | ((tmp[0] & 0xff) << 8) | (tmp[1] & 0xff);
                                        CipherSuite cipher = this.MapV2CipherCode(prefix, tmpCode);

                                        if (cipher != null)
                                        {
                                                this.Context.Negotiating.Cipher = cipher;
                                                break;
                                        }
                                }
                        }

                        if (this.Context.Negotiating == null)
                        {
                                throw new TlsException(AlertDescription.InsuficientSecurity, "Insuficient Security");
                        }
                }

                private CipherSuite MapV2CipherCode(string prefix, int code)
                {
                        try
                        {
                                switch (code)
                                {
                                        case 65664:
                                                // TLS_RC4_128_WITH_MD5
                                                return this.Context.SupportedCiphers[prefix + "RSA_WITH_RC4_128_MD5"];
                                        
                                        case 131200:
                                                // TLS_RC4_128_EXPORT40_WITH_MD5
                                                return this.Context.SupportedCiphers[prefix + "RSA_EXPORT_WITH_RC4_40_MD5"];
                                        
                                        case 196736:
                                                // TLS_RC2_CBC_128_CBC_WITH_MD5
                                                return this.Context.SupportedCiphers[prefix + "RSA_EXPORT_WITH_RC2_CBC_40_MD5"];
                                        
                                        case 262272:
                                                // TLS_RC2_CBC_128_CBC_EXPORT40_WITH_MD5
                                                return this.Context.SupportedCiphers[prefix + "RSA_EXPORT_WITH_RC2_CBC_40_MD5"];
                                        
                                        case 327808:
                                                // TLS_IDEA_128_CBC_WITH_MD5
                                                return null;
                                        
                                        case 393280:
                                                // TLS_DES_64_CBC_WITH_MD5
                                                return null;

                                        case 458944:
                                                // TLS_DES_192_EDE3_CBC_WITH_MD5
                                                return null;

                                        default:
                                                return null;
                                }
                        }
                        catch
                        {
                                return null;
                        }
                }

                #endregion
        }
}