public async Task ProcessAll_EhloStartTlsTest_NotTrusted()
        {
            var responseMessagesPreEncrypt = @"220-STARTTLS
220 example.com greets test.example.com (EHLO)
250 Ok, begin encryption (STARTTLS)
";
            var mockMailReference          = new MockMailReference(
                "mock-1",
                "*****@*****.**",
                new[] { "*****@*****.**" }.ToImmutableList(),
                true,
                "Some text",
                _queue);

            _queue.References.Add(mockMailReference);
            _dns.AddMx("external.example.com", "test.example.com", 10);
            _dns.AddIp("test.example.com", IPAddress.Parse("10.20.30.40"));

            (Stream keep, Stream give) = PairedStream.Create();

            using (var recieveStream = new RedirectableStream(keep))
                using (var reader = new StreamReader(recieveStream))
                {
                    Task <IReadOnlyList <IMailReference> > sendMailsTask = Task.Run(
                        () => _transfer.TrySendMailsToStream(
                            "external.example.com",
                            new[] { mockMailReference },
                            // ReSharper disable once AccessToDisposedClosure
                            new UnclosableStream(give),
                            CancellationToken.None));

                    _transfer.RemoteCertificateValidationCallback = (sender, certificate, chain, errors) => false;

                    byte[] responseBytes = Encoding.ASCII.GetBytes(responseMessagesPreEncrypt);
                    await keep.WriteAsync(responseBytes, 0, responseBytes.Length);

                    await AssertCommandRecieved(reader, "EHLO");
                    await AssertCommandRecieved(reader, "STARTTLS");

                    var encrypted = new SslStream(keep);

                    await encrypted.AuthenticateAsServerAsync(TestHelpers.GetSelfSigned());

                    Assert.NotEmpty(await sendMailsTask);

                    Assert.Equal(1, _queue.References.Count);
                    Assert.Equal(0, _queue.DeletedReferences.Count);

                    encrypted.Dispose();
                    keep.Dispose();
                    give.Dispose();
                }
        }
Exemple #2
0
            public TestConnection(ITestOutputHelper output)
            {
                (Stream a, Stream b) = PairedStream.Create();
                LocalStream          = new RedirectableStream(a);
                Reader = new StreamReader(LocalStream);
                Writer = new StreamWriter(LocalStream)
                {
                    AutoFlush = true
                };


                var builder = new ContainerBuilder();

                builder.RegisterAssemblyTypes(typeof(SmtpSession).GetTypeInfo().Assembly)
                .Where(t => t.GetTypeInfo().GetCustomAttribute <SmtpCommandAttribute>() != null)
                .Keyed <ISmtpCommand>(t => t.GetTypeInfo().GetCustomAttribute <SmtpCommandAttribute>().Name);
                builder.RegisterInstance(TestHelpers.MakeSettings("test.vaettir.net"))
                .As <AgentSettings>()
                .As <AgentSettings>();

                builder.RegisterType <SmtpSession>()
                .As <SmtpSession>()
                .As <ISmtpMessageChannel>()
                .As <IMailBuilder>()
                .As <IProtocolSession>();
                builder.RegisterType <SmtpAuthenticationTransport>()
                .As <IAuthenticationTransport>();

                builder.RegisterInstance(new SecurableConnection(b, PrivateKeyHolder.Fixed(s_serverCert)))
                .As <IConnectionSecurity>()
                .As <SecurableConnection>();

                builder.RegisterInstance(new TestOutputLogger(output))
                .As <ILogger>();

                builder.RegisterInstance(new ConnectionInformation("127.0.0.1", "128.0.0.1"));

                Container = builder.Build();

                Connection = Container.Resolve <SecurableConnection>();
                Session    = Container.Resolve <SmtpSession>();

                CancellationTokenSource = new CancellationTokenSource();
                CancellationToken token = CancellationTokenSource.Token;

                SessionTask = Task.Run(() => Session.RunAsync(token), token);
            }