Esempio n. 1
0
        internal bool Init(int sslMode, int sslVerify, IntPtr certificate, int cert_len, IntPtr szCertPwd, ref int sslContextHandle)
        {
            SslData data = new SslData();

            data.m_sslVersion = (SslProtocols.None);

            if ((sslMode & 0x18) != 0)
            {
                data.m_sslVersion = SslProtocols.Default;
            }
            else if ((sslMode & 0x10) != 0)
            {
                data.m_sslVersion = SslProtocols.Tls;
            }
            else if ((sslMode & 0x8) != 0)
            {
                data.m_sslVersion = SslProtocols.Ssl3;
            }
            else if ((sslMode & 0x4) != 0)
            {
                data.m_sslVersion = SslProtocols.Ssl2;
            }

            data.m_sslVerify = (SslVerification)sslVerify;
            if (certificate != IntPtr.Zero)
            {
                data.m_cert = CreateCert(certificate, cert_len, Marshal.PtrToStringAnsi(szCertPwd));
            }

            lock (this)
            {
                _sslDataCollection[_sslDataCollectionIndex] = data;

                sslContextHandle = _sslDataCollectionIndex;

                System.Threading.Interlocked.Increment(ref _sslDataCollectionIndex);
            }

            return(true);
        }
Esempio n. 2
0
        public int Connect(int socket, IntPtr szTargetHost, int sslContextHandle)
        {
            SslStreamData ssd;

            if (GetSslData(socket, out ssd))
            {
                switch (ssd.m_state)
                {
                case SslStreamData.SslAsyncState.Processing:
                    return((int)SocketError.WouldBlock);

                case SslStreamData.SslAsyncState.Finished:
                    ssd.m_state = SslStreamData.SslAsyncState.InUse;
                    _socketsDriver.SetSslSocket(socket);
                    return((int)SocketError.Success);

                case SslStreamData.SslAsyncState.Failed:
                    ssd.m_state = SslStreamData.SslAsyncState.Init;
                    Console.Error.WriteLine("Connect Failed...");
                    return((int)SocketError.SocketError);

                case SslStreamData.SslAsyncState.InUse:
                    Console.Error.WriteLine("Connect InUse...");
                    return((int)SocketError.Success);
                }
            }
            else
            {
                ssd = new SslStreamData();

                lock (_sslStreams)
                {
                    _sslStreams[socket] = ssd;
                }
            }

            ssd.m_state = SslStreamData.SslAsyncState.Processing;

            try
            {
                Socket sock = null;

                if (!_socketsDriver.GetSocket(socket, out sock))
                {
                    return((int)SocketError.SocketError);
                }

                NetworkStream ns     = new NetworkStream(sock);
                SslStream     stream = new SslStream(ns, true);

                ssd.m_stream = stream;

                SslData sd = _sslDataCollection[sslContextHandle];

                string targHost = Marshal.PtrToStringAnsi(szTargetHost);

                X509CertificateCollection certs = new X509CertificateCollection();

                if (sd.m_cert != null)
                {
                    certs.Add(sd.m_cert);
                }

                IAsyncResult iar = stream.BeginAuthenticateAsClient(targHost, certs, sd.m_sslVersion, false, new AsyncCallback(EndSslConnect), socket);
            }
            catch (Exception ae)
            {
                ssd.m_state = SslStreamData.SslAsyncState.Init;
                Console.Error.WriteLine("BeginAuthenticateAsClient " + ae.Message);
                return((int)SocketError.SocketError);
            }

            return((int)SocketError.WouldBlock);
        }
Esempio n. 3
0
        public int Accept(int socket, int sslContextHandle)
        {
            SslStreamData ssd;

            if (GetSslData(socket, out ssd))
            {
                switch (ssd.m_state)
                {
                case SslStreamData.SslAsyncState.Processing:
                    return((int)SocketError.WouldBlock);

                case SslStreamData.SslAsyncState.Finished:
                    ssd.m_state = SslStreamData.SslAsyncState.InUse;
                    _socketsDriver.SetSslSocket(socket);
                    return((int)SocketError.Success);

                case SslStreamData.SslAsyncState.Failed:
                    ssd.m_state = SslStreamData.SslAsyncState.Init;
                    Console.Error.WriteLine("Accept Failed...");
                    return((int)SocketError.SocketError);

                case SslStreamData.SslAsyncState.InUse:
                    Console.Error.WriteLine("Accept InUse...");
                    return((int)SocketError.SocketError);
                }
            }
            else
            {
                ssd = new SslStreamData();

                lock (_sslStreams)
                {
                    _sslStreams[socket] = ssd;
                }
            }

            ssd.m_state = SslStreamData.SslAsyncState.Processing;

            try
            {
                Socket sock = null;

                if (!_socketsDriver.GetSocket(socket, out sock))
                {
                    return((int)SocketError.SocketError);
                }

                NetworkStream ns     = new NetworkStream(sock);
                SslStream     stream = new SslStream(ns, true);

                ssd.m_stream = stream;

                SslData sd = _sslDataCollection[sslContextHandle];

                stream.BeginAuthenticateAsServer(sd.m_cert, sd.m_sslVerify == SslVerification.CertificateRequired, sd.m_sslVersion, false, new AsyncCallback(EndSslAccept), socket);
            }
            catch (Exception ae)
            {
                ssd.m_state = SslStreamData.SslAsyncState.Init;
                Console.Error.WriteLine("BeginAuthenticateAsServer " + ae.Message);
                return((int)SocketError.SocketError);
            }

            return((int)SocketError.WouldBlock);
        }
Esempio n. 4
0
        internal bool Init(int sslMode, int sslVerify, IntPtr certificate, int cert_len, IntPtr szCertPwd, ref int sslContextHandle)
        {
            SslData data = new SslData();

            data.m_sslVersion = (SslProtocols.None);

            if ((sslMode & 0x18) != 0)
            {
                data.m_sslVersion = SslProtocols.Default;
            }
            else if ((sslMode & 0x10) != 0)
            {
                data.m_sslVersion = SslProtocols.Tls;
            }
            else if ((sslMode & 0x8) != 0)
            {
                data.m_sslVersion = SslProtocols.Ssl3;
            }
            else if ((sslMode & 0x4) != 0)
            {
                data.m_sslVersion = SslProtocols.Ssl2;
            }

            data.m_sslVerify = (SslVerification)sslVerify;
            if (certificate != IntPtr.Zero)
            {
                if (cert_len == 4)
                {
                    SessionData ctx = ((SessionDriver)this.Hal.Session).GetSessionCtx(sslContextHandle);

                    if (ctx == null)
                    {
                        return(false);
                    }

                    CryptokiObject obj = ctx.ObjectCtx.GetObject(Marshal.ReadInt32(certificate));

                    if (obj == null || obj.Type != CryptokiObjectType.Cert)
                    {
                        return(false);
                    }

                    data.m_cert = obj.Data as X509Certificate2;
                }
                else
                {
                    data.m_cert = CreateCert(certificate, cert_len, Marshal.PtrToStringAnsi(szCertPwd));
                }
            }

            lock (this)
            {
                _sslDataCollection[_sslDataCollectionIndex] = data;

                sslContextHandle = _sslDataCollectionIndex;

                System.Threading.Interlocked.Increment(ref _sslDataCollectionIndex);
            }

            return(true);
        }