コード例 #1
0
        public void connection_should_be_closed_by_remote_party(string endpointProperty, bool secure)
        {
            IPEndPoint     endpoint       = (IPEndPoint)_nodes[0].GetType().GetProperty(endpointProperty).GetValue(_nodes[0], null);
            var            connectedEvent = new ManualResetEvent(false);
            var            closedEvent    = new ManualResetEvent(false);
            ITcpConnection connection;

            if (!secure)
            {
                connection = TcpConnection.CreateConnectingTcpConnection(
                    Guid.NewGuid(),
                    endpoint,
                    new TcpClientConnector(),
                    TimeSpan.FromSeconds(5),
                    (conn) => connectedEvent.Set(),
                    (conn, error) => {
                    Assert.Fail($"Connection failed: {error}");
                },
                    false);
            }
            else
            {
                connection = TcpConnectionSsl.CreateConnectingConnection(
                    Guid.NewGuid(),
                    endpoint.GetHost(),
                    endpoint,
                    delegate { return(true, null); },
コード例 #2
0
        public async Task connection_should_be_closed_by_remote_party(string endpointProperty, bool secure)
        {
            IPEndPoint endpoint    = (IPEndPoint)_nodes[0].GetType().GetProperty(endpointProperty).GetValue(_nodes[0], null);
            var        closedEvent = new ManualResetEventSlim();
            TaskCompletionSource <SocketError> connectionResult = new (TaskCreationOptions.RunContinuationsAsynchronously);

            ITcpConnection connection;

            if (!secure)
            {
                connection = TcpConnection.CreateConnectingTcpConnection(
                    Guid.NewGuid(),
                    endpoint,
                    new TcpClientConnector(),
                    TimeSpan.FromSeconds(5),
                    (conn) => connectionResult.TrySetResult(SocketError.Success),
                    (conn, error) => connectionResult.TrySetResult(error),
                    false);
            }
            else
            {
                connection = TcpConnectionSsl.CreateConnectingConnection(
                    Guid.NewGuid(),
                    endpoint.GetHost(),
                    endpoint,
                    delegate { return(true, null); },
コード例 #3
0
        [TestCase(false, false, false, false, true)]     //do not require valid client or server certificate
        public void should_connect_to_each_other_and_send_data_depending_on_certificate_validity_and_settings(
            bool useValidServerCertificate,
            bool useValidClientCertificate,
            bool validateServerCertificate,
            bool validateClientCertificate,
            bool shouldConnectSuccessfully
            )
        {
            var serverEndPoint    = new IPEndPoint(_ip, _port);
            var serverCertificate = useValidServerCertificate
                                ? ssl_connections.GetServerCertificate()
                                : ssl_connections.GetUntrustedCertificate();
            var clientCertificate = useValidClientCertificate
                                ? ssl_connections.GetClientCertificate()
                                : ssl_connections.GetUntrustedCertificate();
            var rootCertificates = new X509Certificate2Collection(ssl_connections.GetRootCertificate());


            var sent = new byte[1000];

            new Random().NextBytes(sent);

            var received = new MemoryStream();

            var done = new ManualResetEventSlim();

            var listener = new TcpServerListener(serverEndPoint);

            listener.StartListening((endPoint, socket) => {
                var ssl = TcpConnectionSsl.CreateServerFromSocket(Guid.NewGuid(), endPoint, socket, serverCertificate,
                                                                  (cert, chain, err) => validateClientCertificate ? ClusterVNode.ValidateClientCertificateWithTrustedRootCerts(cert, chain, err, rootCertificates) : (true, null),
                                                                  verbose: true);
                ssl.ConnectionClosed += (x, y) => done.Set();
                if (ssl.IsClosed)
                {
                    done.Set();
                }

                Action <ITcpConnection, IEnumerable <ArraySegment <byte> > > callback = null;
                callback = (x, y) => {
                    foreach (var arraySegment in y)
                    {
                        received.Write(arraySegment.Array, arraySegment.Offset, arraySegment.Count);
                        Log.Information("Received: {0} bytes, total: {1}.", arraySegment.Count, received.Length);
                    }

                    if (received.Length >= sent.Length)
                    {
                        Log.Information("Done receiving...");
                        done.Set();
                    }
                    else
                    {
                        Log.Information("Receiving...");
                        ssl.ReceiveAsync(callback);
                    }
                };
                Log.Information("Receiving...");
                ssl.ReceiveAsync(callback);
            }, "Secure");

            var clientSsl = TcpConnectionSsl.CreateConnectingConnection(
                Guid.NewGuid(),
                serverEndPoint.GetHost(),
                serverEndPoint,
                (cert, chain, err) => validateServerCertificate ? ClusterVNode.ValidateServerCertificateWithTrustedRootCerts(cert, chain, err, rootCertificates) : (true, null),
                new X509CertificateCollection {
                clientCertificate
            },
コード例 #4
0
        [TestCase(false, false, false, false, true)]     //do not require valid client or server certificate
        public void should_connect_to_each_other_and_send_data_depending_on_certificate_validity_and_settings(
            bool useValidServerCertificate,
            bool useValidClientCertificate,
            bool validateServerCertificate,
            bool validateClientCertificate,
            bool shouldConnectSuccessfully
            )
        {
            var serverEndPoint    = new IPEndPoint(_ip, _port);
            var serverCertificate = useValidServerCertificate
                                ? ssl_connections.GetServerCertificate()
                                : ssl_connections.GetUntrustedCertificate();
            var clientCertificate = useValidClientCertificate
                                ? ssl_connections.GetOtherServerCertificate()
                                : ssl_connections.GetUntrustedCertificate();
            var rootCertificates = new X509Certificate2Collection(ssl_connections.GetRootCertificate());


            var sent = new byte[1000];

            new Random().NextBytes(sent);

            var received = new MemoryStream();

            var done = new ManualResetEventSlim();

            var listener = new TcpServerListener(serverEndPoint);

            listener.StartListening((endPoint, socket) => {
                var ssl = TcpConnectionSsl.CreateServerFromSocket(Guid.NewGuid(), endPoint, socket, () => serverCertificate,
                                                                  (cert, chain, err) => validateClientCertificate ? ClusterVNode <string> .ValidateClientCertificate(cert, chain, err, () => null, () => rootCertificates) : (true, null),
                                                                  verbose: true);
                ssl.ConnectionClosed += (x, y) => done.Set();
                if (ssl.IsClosed)
                {
                    done.Set();
                }

                Action <ITcpConnection, IEnumerable <ArraySegment <byte> > > callback = null;
                callback = (x, y) => {
                    foreach (var arraySegment in y)
                    {
                        received.Write(arraySegment.Array, arraySegment.Offset, arraySegment.Count);
                        Log.Information("Received: {0} bytes, total: {1}.", arraySegment.Count, received.Length);
                    }

                    if (received.Length >= sent.Length)
                    {
                        Log.Information("Done receiving...");
                        done.Set();
                    }
                    else
                    {
                        Log.Information("Receiving...");
                        ssl.ReceiveAsync(callback);
                    }
                };
                Log.Information("Receiving...");
                ssl.ReceiveAsync(callback);
            }, "Secure");

            var clientSsl = TcpConnectionSsl.CreateConnectingConnection(
                Guid.NewGuid(),
                serverEndPoint.GetHost(),
                serverEndPoint,
                (cert, chain, err) => validateServerCertificate ? ClusterVNode <string> .ValidateServerCertificate(cert, chain, err, () => null, () => rootCertificates) : (true, null),
                () => new X509CertificateCollection {
                clientCertificate
            },
                new TcpClientConnector(),
                TcpConnectionManager.ConnectionTimeout,
                conn => {
                Log.Information("Sending bytes...");
                conn.EnqueueSend(new[] { new ArraySegment <byte>(sent) });
            },
                (conn, err) => {
                Log.Error("Connecting failed: {0}.", err);
                done.Set();
            },
                verbose: true);

            Assert.IsTrue(done.Wait(20000), "Took too long to receive completion.");

            Log.Information("Stopping listener...");
            listener.Stop();
            Log.Information("Closing client TLS connection...");
            clientSsl.Close("Normal close.");
            Log.Information("Checking received data...");

            if (shouldConnectSuccessfully)
            {
                Assert.AreEqual(sent, received.ToArray());
            }
            else
            {
                Assert.AreEqual(new byte[0], received.ToArray());
            }
        }