public void TestFiles(string fileName)
{
string filePath = Path.Combine("Mail\\TestFiles", fileName);
string mailtext = File.ReadAllText(filePath);
Message message = null;
Assert.DoesNotThrow(() => message = Message.Load(mailtext));
if (SMIMEStandard.IsContentMultipartSignature(message.ParsedContentType))
{
SignedEntity signedEntity = null;
Assert.DoesNotThrow(() => signedEntity = SignedEntity.Load(message));
message.Headers = message.Headers.SelectNonMimeHeaders();
message.UpdateBody(signedEntity.Content); // this will merge in content + content specific mime headers
}
Message extracted = null;
Assert.DoesNotThrow(() => extracted = WrappedMessage.ExtractInner(message));
Header to = null;
Assert.DoesNotThrow(() => to = extracted.To);
MailAddressCollection addresses = null;
Assert.DoesNotThrow(() => addresses = MailParser.ParseAddressCollection(to));
Assert.True(addresses.Count > 0);
Assert.DoesNotThrow(() => MailParser.ParseMailAddress(extracted.From));
}
internal void VerifyOutgoingMessage(CDO.Message message)
{
Assert.True(string.IsNullOrEmpty(message.Subject));
ContentType contentType = new ContentType(message.GetContentType());
Assert.True(SMIMEStandard.IsContentEncrypted(contentType));
}
protected virtual MessageEnvelope ProcessEnvelope(ISmtpMessage message, MessageEnvelope envelope)
{
//
// OUTGOING:
// Non-Encrypted messages from within the domain are treated as OUTGOING.
// Encrypted messages from within the domain are OPTIONALLY treated as Incoming
// - Only if InternalRelay is enabled
// INCOMING:
// All messages sent by sources OUTSIDE the domain are ALWAYS treated as INCOMING
//
// The following boolean logic is the way it is to make it *easy to read*
//
bool isSenderInDomain = this.SecurityAgent.Domains.IsManaged(envelope.Sender);
bool isOutgoing;
if (isSenderInDomain)
{
isOutgoing = true;
if (SMIMEStandard.IsEncrypted(envelope.Message))
{
if (!m_settings.AllowInternalRelay)
{
throw new SmtpAgentException(SmtpAgentError.InternalRelayDisabled);
}
isOutgoing = false;
}
}
else
{
isOutgoing = false;
}
if (isOutgoing)
{
envelope = this.ProcessOutgoing(message, envelope);
}
else
{
envelope = this.ProcessIncoming(message, envelope);
}
if (envelope == null)
{
throw new SmtpAgentException(SmtpAgentError.InvalidEnvelopeFromAgent);
}
return(envelope);
}
/// <summary>
/// Decrypt (optionally) the given message and try to extract signatures
/// </summary>
bool DecryptSignatures(IncomingMessage message, X509Certificate2 certificate, out SignedCms signatures, out MimeEntity payload)
{
MimeEntity decryptedEntity = null;
signatures = null;
payload = null;
if (certificate != null)
{
decryptedEntity = m_cryptographer.DecryptEntity(message.GetEncryptedBytes(m_cryptographer), certificate);
}
else
{
decryptedEntity = message.Message;
}
if (decryptedEntity == null)
{
return(false);
}
if (SMIMEStandard.IsContentEnvelopedSignature(decryptedEntity.ParsedContentType))
{
signatures = m_cryptographer.DeserializeEnvelopedSignature(decryptedEntity);
payload = MimeSerializer.Default.Deserialize <MimeEntity>(signatures.ContentInfo.Content);
}
else if (SMIMEStandard.IsContentMultipartSignature(decryptedEntity.ParsedContentType))
{
SignedEntity signedEntity = SignedEntity.Load(decryptedEntity);
signatures = m_cryptographer.DeserializeDetachedSignature(signedEntity);
payload = signedEntity.Content;
}
else
{
throw new AgentException(AgentError.UnsignedMessage);
}
return(true);
}
public void TestWithMessageObjects()
{
var message = MimeSerializer.Default.Deserialize <Message>(m_tester.ReadMessageText("simple.eml"));
var outgoing = new OutgoingMessage(message);
outgoing = m_tester.AgentA.ProcessOutgoing(outgoing);
Assert.True(outgoing.Message.HasHeader(MailStandard.Headers.Date));
Assert.True(SMIMEStandard.IsEncrypted(outgoing.Message));
VerifyTrusted(outgoing.Recipients, m_tester.AgentA.MinTrustRequirement);
Assert.True(outgoing.RejectedRecipients.Count == 0);
var incoming = new IncomingMessage(outgoing.Message);
incoming = m_tester.AgentB.ProcessIncoming(incoming);
Assert.False(SMIMEStandard.IsEncrypted(incoming.Message));
Assert.False(WrappedMessage.IsWrapped(incoming.Message));
VerifyTrusted(incoming.Recipients, m_tester.AgentB.MinTrustRequirement);
Assert.True(outgoing.RejectedRecipients.Count == 0);
}
internal void VerifyIncomingMessage(CDO.Message message)
{
ContentType contentType = new ContentType(message.GetContentType());
Assert.False(SMIMEStandard.IsContentEncrypted(contentType));
}
public void TestFailedDSN_SecurityAndTrustOutGoingOnly_AlwaysGenerate_AllRecipientsRejected(
string untrustedRecipientMessage
, List <DSNPerRecipient> perRecipientExpected)
{
CleanMessages(m_agent.Settings);
CleanMonitor();
m_agent.Settings.InternalMessage.EnableRelay = true;
m_agent.Settings.Notifications.AutoResponse = false; //don't care. This is MDN specific
m_agent.Settings.Notifications.AlwaysAck = false; //don't care. This is MDN specific
m_agent.Settings.Notifications.AutoDsnFailureCreation =
NotificationSettings.AutoDsnOption.Always.ToString();
MdnMemoryStore.Clear();
Mock <ClientSettings> mockClientSettings = MockMdnClientSettings();
m_agent.Settings.MdnMonitor = mockClientSettings.Object;
//
// Process loopback messages. Leaves un-encrypted mdns in pickup folder
// Go ahead and pick them up and Process them as if they where being handled
// by the SmtpAgent by way of (IIS)SMTP hand off.
//
var sendingMessage = LoadMessage(untrustedRecipientMessage);
Assert.Equal(
string.Format("Error={0}", AgentError.NoTrustedRecipients),
Assert.Throws <OutgoingAgentException>(() => m_agent.ProcessMessage(sendingMessage)).Message
);
//No trusted recipients so not encrypted.
ContentType contentType = new ContentType(sendingMessage.GetContentType());
Assert.False(SMIMEStandard.IsContentEncrypted(contentType));
//
// grab the clear text dsn and delete others.
// Process them as outgoing messages
//
bool foundDsn = false;
foreach (var pickupMessage in PickupMessages())
{
string messageText = File.ReadAllText(pickupMessage);
if (messageText.Contains("message/delivery-status"))
{
foundDsn = true;
Assert.DoesNotThrow(() => RunMdnOutBoundProcessingTest(LoadMessage(messageText)));
//
// assert not in the monitor store.
// DSN messages are not monitored.
//
var queryMdn = BuildQueryFromDSN(LoadMessage(messageText));
var mdn = MdnMemoryStore.FirstOrDefault(m => m.MdnIdentifier == queryMdn.MdnIdentifier);
Assert.Null(mdn);
}
}
Assert.True(foundDsn);
//
// Now the messages are encrypted and can be handled as inbound messages.
//
foundDsn = false;
foreach (var pickupMessage in PickupMessages())
{
foundDsn = true;
string messageText = File.ReadAllText(pickupMessage);
CDO.Message message = LoadMessage(messageText);
Assert.DoesNotThrow(() => RunMdnInBoundProcessingTest(message));
var dsnMessage = new CDOSmtpMessage(message).GetEnvelope();
Assert.True(dsnMessage.Message.IsDSN());
Assert.False(dsnMessage.Message.IsMDN());
var dsn = DSNParser.Parse(dsnMessage.Message);
foreach (var perRecipient in dsn.PerRecipient)
{
Assert.Equal(perRecipientExpected.Count, dsn.PerRecipient.Count());
string finalRecipient = perRecipient.FinalRecipient.Address;
var expectedPerRecipient = perRecipientExpected.Find(d => d.FinalRecipient.Address == finalRecipient);
Assert.Equal(expectedPerRecipient.Action, perRecipient.Action);
Assert.Equal(expectedPerRecipient.Status, perRecipient.Status);
}
}
Assert.True(foundDsn);
//Ensure no MDNs where created by the DSN.
Assert.True(!PickupMessages().Any());
m_agent.Settings.InternalMessage.EnableRelay = false;
}
public void TestDigestMicalgParameter(DigestAlgorithm algo)
{
ContentType type = SignedEntity.CreateContentType(algo);
Assert.True(type.Parameters["micalg"] == SMIMEStandard.ToString(algo));
}
