basesocketconnectioncreator.cs

来自「ActiveSync数据同步」· CS 代码 · 共 578 行 · 第 1/2 页

                        //----- Socket!
                        int writeBytes = connection.Socket.EndSend(ar);

                        if (writeBytes < writeMessage.PacketRemaining)
                        {
                            //----- Continue to send until all bytes are sent!
                            writeMessage.PacketOffSet += writeBytes;
                            connection.Socket.BeginSend(writeMessage.PacketBuffer, writeMessage.PacketOffSet, writeMessage.PacketRemaining, SocketFlags.None, new AsyncCallback(InitializeConnectionSendCallback), callbackData);
                        }
                        else
                        {
                          
                          writeMessage = null;
                          callbackData = null;

                          FHost.FireOnConnected(connection);

                        }

                    }

                }
                catch (Exception ex)
                {
                    FHost.FireOnException(connection, ex);
                }

            }


        }

        #endregion

        #region InitializeConnectionReceiveCallback

        private void InitializeConnectionReceiveCallback(IAsyncResult ar)
        {

            if (!Disposed)
            {

                BaseSocketConnection connection = null;
                MessageBuffer readMessage = null;

                try
                {

                    CallbackData callbackData = (CallbackData)ar.AsyncState;

                    connection = callbackData.Connection;
                    readMessage = callbackData.Buffer;

                    if (connection.Active)
                    {

                        bool readSocket = true;
                        bool completed = false;

                        int readBytes = connection.Socket.EndReceive(ar);

                        if (readBytes > 0)
                        {

                            readMessage.PacketOffSet += readBytes;
                            byte[] message = null;

                            try
                            {
                                message = Convert.FromBase64String(Encoding.GetEncoding(1252).GetString(readMessage.PacketBuffer, 0, readMessage.PacketOffSet));
                            }
                            catch (FormatException)
                            {
                                //----- Base64 transformation error!
                            }

                            if ((message != null) && (Encoding.GetEncoding(1252).GetString(message).Contains("</AuthMessage>")))
                            {

                                //----- Get RSA provider!
                                RSACryptoServiceProvider serverPrivateKey;
                                RSACryptoServiceProvider clientPublicKey = new RSACryptoServiceProvider();
                                byte[] signMessage;

                                FCryptoService.OnSymmetricAuthenticate(connection, out serverPrivateKey, out signMessage);

                                //----- Deserialize authentication message!
                                MemoryStream m = new MemoryStream();
                                m.Write(message, 0, message.Length);
                                m.Position = 0;

                                XmlSerializer xml = new XmlSerializer(typeof(AuthMessage));
                                AuthMessage am = (AuthMessage)xml.Deserialize(m);

                                //----- Generates symmetric algoritm!
                                SymmetricAlgorithm sa = CryptUtils.CreateSymmetricAlgoritm(connection.EncryptType);
                                sa.Key = serverPrivateKey.Decrypt(am.SessionKey, false);
                                sa.IV = serverPrivateKey.Decrypt(am.SessionIV, false);

                                //----- Adjust connection cryptors!
                                connection.Encryptor = sa.CreateEncryptor();
                                connection.Decryptor = sa.CreateDecryptor();

                                //----- Verify sign!
                                clientPublicKey.FromXmlString(Encoding.UTF8.GetString(CryptUtils.DecryptDataForAuthenticate(sa, am.SourceKey, PaddingMode.ISO10126)));

                                m.SetLength(0);
                                m.Write(am.SourceKey, 0, am.SourceKey.Length);
                                m.Write(am.SessionKey, 0, am.SessionKey.Length);
                                m.Write(signMessage, 0, signMessage.Length);

                                if (clientPublicKey.VerifyData(CryptUtils.EncryptDataForAuthenticate(sa, m.ToArray(), PaddingMode.PKCS7), new SHA1CryptoServiceProvider(), am.Sign))
                                {
                                    completed = true;
                                }

                                readSocket = false;

                                m.Close();
                                am.SessionIV.Initialize();
                                am.SessionKey.Initialize();
                                serverPrivateKey.Clear();
                                clientPublicKey.Clear();

                                readMessage = null;
                                callbackData = null;

                                if (!completed)
                                {
                                    throw new SymmetricAuthenticationException("Symmetric sign error.");
                                }

                                FHost.FireOnConnected(connection);

                            }

                            if (readSocket)
                            {
                                connection.Socket.BeginReceive(readMessage.PacketBuffer, readMessage.PacketOffSet, readMessage.PacketRemaining, SocketFlags.None, new AsyncCallback(InitializeConnectionReceiveCallback), callbackData);
                            }

                        }
                        else
                        {
                            throw new SymmetricAuthenticationException("Symmetric authentication error.");
                        }

                    }

                }
                catch (Exception ex)
                {
                    FHost.FireOnException(connection, ex);
                }

            }


        }

        #endregion

        #region SslAuthenticateCallback

        private void SslAuthenticateCallback(IAsyncResult ar)
        {

            if (!Disposed)
            {

                BaseSocketConnection connection = null;
                SslStream stream = null;
                bool completed = false;

                try
                {

                    AuthenticateCallbackData callbackData = (AuthenticateCallbackData)ar.AsyncState;

                    connection = callbackData.Connection;
                    stream = callbackData.Stream;

                    if (connection.Active)
                    {

                        if (callbackData.HostType == HostType.htClient)
                        {
                            stream.EndAuthenticateAsClient(ar);
                        }
                        else
                        {
                            stream.EndAuthenticateAsServer(ar);
                        }

                        if ((stream.IsSigned && stream.IsEncrypted))
                        {
                            completed = true;
                        }

                        callbackData = null;  
                        connection.Stream = stream;

                        if (!completed)
                        {
                            throw new SSLAuthenticationException("Ssl authenticate is not signed or not encrypted.");
                        }

                        FHost.FireOnConnected(connection);

                    }

                }
                catch (Exception ex)
                {
                    FHost.FireOnException(connection, ex);
                }

            }

        }

        #endregion

        #region ValidateServerCertificateCallback

        private bool ValidateServerCertificateCallback(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
        {

            bool acceptCertificate = false;
            FCryptoService.OnSSLClientValidateServerCertificate(certificate, chain, sslPolicyErrors, out acceptCertificate);
            
            return acceptCertificate;

        }

        #endregion

        #region Abstract Methods

        public abstract void Start();
        public abstract void Stop();

        #endregion

        #endregion

        #region Properties

        internal BaseSocketConnectionHost Host
        {
            get { return FHost; }
        }

        public string Name
        {
          get { return FName; }
        }

        public ICryptoService CryptoService
        {
            get { return FCryptoService; }
            set { FCryptoService = value; } 
        }

        public EncryptType EncryptType
        {
            get { return FEncryptType; }
            set { FEncryptType = value; }
        }

        internal IPEndPoint InternalLocalEndPoint
        {
            get { return FLocalEndPoint; }
            set { FLocalEndPoint = value; }
        }

        public CompressionType CompressionType
        {
            get { return FCompressionType; }
            set { FCompressionType = value; }
        }

        #endregion

    }

}