Example #1
0
        public void TestManInMiddle(string fileName, string injectedWithPersonalKey, string injectedWithOrgKey)
        {
            //
            // Take an encrypted message, add additional recipients
            //
            OutgoingMessage outgoing = m_tester.ProcessOutgoingFile(fileName);
            string          message  = outgoing.SerializeMessage();
            IncomingMessage incoming = new IncomingMessage(message, outgoing.Recipients, outgoing.Sender);

            Assert.DoesNotThrow(() => m_tester.AgentB.ProcessIncoming(incoming));
            //
            // Add additional recipient not in original message
            //
            DirectAddressCollection recipients = new DirectAddressCollection(outgoing.Recipients);

            recipients.Add(new DirectAddress(injectedWithPersonalKey));
            incoming = new IncomingMessage(message, recipients, outgoing.Sender);
            Assert.Throws <AgentException>(() => m_tester.AgentB.ProcessIncoming(incoming));
            //
            // Replace recipient entirely
            //
            recipients.Clear();
            recipients.Add(new DirectAddress(injectedWithPersonalKey));
            incoming = new IncomingMessage(message, recipients, outgoing.Sender);
            Assert.Throws <AgentException>(() => m_tester.AgentB.ProcessIncoming(incoming));
            //
            // Inject recipient with org certs
            //
            recipients.Clear();
            recipients.Add(outgoing.Recipients);
            recipients.Add(new DirectAddress(injectedWithOrgKey));
            incoming = new IncomingMessage(message, recipients, outgoing.Sender);
            Assert.Throws <AgentException>(() => m_tester.AgentB.ProcessIncoming(incoming));
        }
Example #2
0
        public void TestBasic()
        {
            m_agent.Settings.InternalMessage.EnableRelay = true;
            m_agent.Settings.Notifications.AutoResponse  = true;

            Message msg = Message.Load(string.Format(TestMessage, Guid.NewGuid()));

            msg.RequestNotification();

            OutgoingMessage outgoing = null;
            IncomingMessage incoming = null;

            base.ProcessEndToEnd(m_agent, msg, out outgoing, out incoming);

            int i = 0;

            foreach (NotificationMessage notification in m_producer.Produce(incoming))
            {
                DirectAddress sender = incoming.DomainRecipients[i++];
                Assert.Equal(sender.Address, notification.FromValue, MailStandard.Comparer);
            }

            m_agent.Settings.InternalMessage.PickupFolder = Path.GetTempPath();
            Assert.DoesNotThrow(() => m_agent.ProcessMessage(this.LoadMessage(outgoing.SerializeMessage())));
        }
Example #3
0
        public void TestPrivateKeyLookupFailure()
        {
            string fileName    = "simple.eml";
            string messageText = m_tester.ReadMessageText(fileName);

            Message message = MailParser.ParseMessage(messageText);

            message.ToValue = "*****@*****.**";  // this should force a key lookup failure
            AgentTester.CheckErrorCode <AgentException, AgentError>(
                () => m_tester.AgentA.ProcessOutgoing(new OutgoingMessage(message)),
                AgentError.NoTrustedRecipients
                );

            DirectAgent badAgent = new DirectAgent(new StaticDomainResolver(m_tester.AgentA.Domains.Domains.ToArray()),
                                                   new NullResolver(), // returns null private certs
                                                   m_tester.AgentA.PublicCertResolver,
                                                   m_tester.AgentA.TrustAnchors);

            message = MailParser.ParseMessage(messageText);
            AgentTester.CheckErrorCode <AgentException, AgentError>(
                () => badAgent.ProcessOutgoing(new OutgoingMessage(message)),
                AgentError.CouldNotResolvePrivateKey
                );

            OutgoingMessage outgoing = m_tester.AgentA.ProcessOutgoing(messageText);

            badAgent = new DirectAgent(new StaticDomainResolver(m_tester.AgentB.Domains.Domains.ToArray()),
                                       new NullResolver(),            // returns null private certs
                                       m_tester.AgentB.PublicCertResolver,
                                       m_tester.AgentB.TrustAnchors);

            AgentTester.CheckErrorCode <AgentException, AgentError>(
                () => badAgent.ProcessIncoming(outgoing.SerializeMessage()),
                AgentError.CouldNotResolvePrivateKey
                );

            badAgent = new DirectAgent(new StaticDomainResolver(m_tester.AgentB.Domains.Domains.ToArray()),
                                       new NullResolver(true),            // returns empty private cert collections
                                       m_tester.AgentB.PublicCertResolver,
                                       m_tester.AgentB.TrustAnchors);

            AgentTester.CheckErrorCode <AgentException, AgentError>(
                () => badAgent.ProcessIncoming(outgoing.SerializeMessage()),
                AgentError.CouldNotResolvePrivateKey
                );
        }
Example #4
0
 internal void ProcessEndToEnd(SmtpAgent agent, Message msg, out OutgoingMessage outgoing, out IncomingMessage incoming)
 {
     outgoing = agent.SecurityAgent.ProcessOutgoing(new MessageEnvelope(msg));
     incoming = agent.SecurityAgent.ProcessIncoming(new MessageEnvelope(outgoing.SerializeMessage()));
 }