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));
}
public void AddMessage(Guid groupId, ParticipantMessage message, VerifiedParticipant participant)
{
var groupDetails = groupRepository.GetGroup(groupId);
var groupPubKey = File.ReadAllText(groupDetails.Name + "PublicKey.txt");
var rsaPubKey = RsaKeyUtils.GetDeserializedKPublicKey(groupPubKey);
SignedEntity signedEntity = new SignedEntity(FromBase64String(participant.PublicKey), FromBase64String(participant.Signature));
bool isVerified = signatureVerifier.Verify(signedEntity, rsaPubKey);
if (isVerified)
{
groupRepository.SaveMessage(participant, message);
}
}
public void TestDispositionHeaders()
{
string messageText = m_tester.ReadMessageText("simple.eml");
Message message = MimeSerializer.Default.Deserialize <Message>(messageText);
SignedEntity signedEntity = m_cryptographer.Sign(message, m_cert);
string disposition = signedEntity.Signature.ContentDisposition;
Assert.True(!string.IsNullOrEmpty(disposition));
Assert.True(SMIMEStandard.SignatureDisposition == disposition);
MimeEntity encryptedEntity = m_cryptographer.Encrypt(message, m_cert);
disposition = encryptedEntity.ContentDisposition;
Assert.True(!string.IsNullOrEmpty(disposition));
Assert.True(SMIMEStandard.EncryptedEnvelopeDisposition == disposition);
}
//
// First sign, THEN encrypt the message
//
void SignAndEncryptMessage(OutgoingMessage message)
{
SignedEntity signedEntity = m_cryptographer.Sign(message.Message, message.Sender.Certificates);
if (m_encryptionEnabled)
{
//
// Encrypt the outbound message with all known trusted certs
//
MimeEntity encryptedEntity = m_cryptographer.Encrypt(signedEntity, message.Recipients.GetCertificates());
//
// Alter message content to contain encrypted data
//
message.Message.UpdateBody(encryptedEntity);
}
else
{
message.Message.UpdateBody(signedEntity);
}
}
public void TestCryptographerLineLengths()
{
string messageText = m_tester.ReadMessageText("simple.eml");
Message message = MimeSerializer.Default.Deserialize <Message>(messageText);
SignedEntity signedEntity = m_cryptographer.Sign(message, m_cert);
string signedEntityText = signedEntity.Aggregate("", (s, e) => s += e.ToString());
string[] signedEntityLines = signedEntityText.Split(new[] { "\r\n" }, StringSplitOptions.None);
int longestDecryptedLine = signedEntityLines.Max(l => l.Length);
MimeEntity encryptedEntity = m_cryptographer.Encrypt(signedEntity.ToEntity(), m_cert);
string encryptedEntityText = encryptedEntity.ToString();
string[] encryptedEntityLines = encryptedEntityText.Split(new[] { "\r\n" }, StringSplitOptions.None);
int longestEncryptedLine = encryptedEntityLines.Max(l => l.Length);
//RFC 2822 Section 2.1.1 sets a maximum line length of 998 + CRLF.
//https://www.ietf.org/rfc/rfc2822.txt
Assert.True(longestEncryptedLine < 998);
Assert.True(longestDecryptedLine < 998);
}
/// <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);
}
/// <summary>
/// Transforms a <see cref="SignedEntity"/> to the associated <see cref="SignedCms"/> instance.
/// SignedCms is in PKCS#7 format.
/// </summary>
/// <param name="entity">The <see cref="SignedEntity"/> to deserialize</param>
/// <returns>The corresponding <see cref="SignedCms"/></returns>
public SignedCms DeserializeDetachedSignature(SignedEntity entity)
{
return(m_innerSoftwareCryptographer.DeserializeDetachedSignature(entity));
}
public void TestDigestMicalgParameter(DigestAlgorithm algo)
{
ContentType type = SignedEntity.CreateContentType(algo);
Assert.True(type.Parameters["micalg"] == SMIMEStandard.ToString(algo));
}
/// <summary>
/// Not Implemented.
/// </summary>
/// <param name="entity">The <see cref="SignedEntity"/> to deserialize</param>
/// <returns>The corresponding <see cref="SignedCms"/></returns>
public SignedCms DeserializeDetachedSignature(SignedEntity entity)
{
throw new NotImplementedException();
}
