public void TestMultipartEncryptedEncryptAlgorithmUsingKeys()
{
var body = new TextPart("plain")
{
Text = "This is some cleartext that we'll end up encrypting..."
};
var self = new MailboxAddress("MimeKit UnitTests", "*****@*****.**");
IList <PgpPublicKey> recipients;
using (var ctx = new DummyOpenPgpContext()) {
recipients = ctx.GetPublicKeys(new [] { self });
}
foreach (EncryptionAlgorithm algorithm in Enum.GetValues(typeof(EncryptionAlgorithm)))
{
if (algorithm == EncryptionAlgorithm.RC240 ||
algorithm == EncryptionAlgorithm.RC264 ||
algorithm == EncryptionAlgorithm.RC2128)
{
continue;
}
var encrypted = MultipartEncrypted.Encrypt(algorithm, recipients, body);
//using (var file = File.Create ("pgp-encrypted.asc"))
// encrypted.WriteTo (file);
var decrypted = encrypted.Decrypt();
Assert.IsInstanceOf <TextPart> (decrypted, "Decrypted part is not the expected type.");
Assert.AreEqual(body.Text, ((TextPart)decrypted).Text, "Decrypted content is not the same as the original.");
}
}
static PgpMimeTests()
{
Environment.SetEnvironmentVariable("GNUPGHOME", Path.GetFullPath("."));
var dataDir = Path.Combine("..", "..", "TestData", "openpgp");
CryptographyContext.Register(typeof(DummyOpenPgpContext));
foreach (var name in new [] { "pubring.gpg", "pubring.gpg~", "secring.gpg", "secring.gpg~", "gpg.conf" })
{
if (File.Exists(name))
{
File.Delete(name);
}
}
using (var ctx = new DummyOpenPgpContext()) {
using (var seckeys = File.OpenRead(Path.Combine(dataDir, "mimekit.gpg.sec")))
ctx.ImportSecretKeys(seckeys);
using (var pubkeys = File.OpenRead(Path.Combine(dataDir, "mimekit.gpg.pub")))
ctx.Import(pubkeys);
}
File.Copy(Path.Combine(dataDir, "gpg.conf"), "gpg.conf", true);
}
public void TestPgpMimeSigning ()
{
var self = new MailboxAddress ("MimeKit UnitTests", "*****@*****.**");
var cleartext = new TextPart ("plain");
cleartext.Text = "This is some cleartext that we'll end up signing...";
using (var ctx = new DummyOpenPgpContext ()) {
var multipart = MultipartSigned.Create (ctx, self, DigestAlgorithm.Sha1, cleartext);
Assert.AreEqual (2, multipart.Count, "The multipart/signed has an unexpected number of children.");
var protocol = multipart.ContentType.Parameters["protocol"];
Assert.AreEqual (ctx.SignatureProtocol, protocol, "The multipart/signed protocol does not match.");
Assert.IsInstanceOfType (typeof (TextPart), multipart[0], "The first child is not a text part.");
Assert.IsInstanceOfType (typeof (ApplicationPgpSignature), multipart[1], "The second child is not a detached signature.");
var signatures = multipart.Verify (ctx);
Assert.AreEqual (1, signatures.Count, "Verify returned an unexpected number of signatures.");
foreach (var signature in signatures) {
try {
bool valid = signature.Verify ();
Assert.IsTrue (valid, "Bad signature from {0}", signature.SignerCertificate.Email);
} catch (DigitalSignatureVerifyException ex) {
Assert.Fail ("Failed to verify signature: {0}", ex);
}
}
}
}
public void TestPgpMimeEncryption()
{
var body = new TextPart("plain")
{
Text = "This is some cleartext that we'll end up encrypting..."
};
var self = new MailboxAddress("MimeKit UnitTests", "*****@*****.**");
var message = new MimeMessage {
Subject = "Test of signing with OpenPGP"
};
message.From.Add(self);
message.To.Add(self);
message.Body = body;
using (var ctx = new DummyOpenPgpContext()) {
message.Encrypt(ctx);
Assert.IsInstanceOf <MultipartEncrypted> (message.Body);
var encrypted = (MultipartEncrypted)message.Body;
//using (var file = File.Create ("pgp-encrypted.asc"))
// encrypted.WriteTo (file);
var decrypted = encrypted.Decrypt(ctx);
Assert.IsInstanceOf <TextPart> (decrypted, "Decrypted part is not the expected type.");
Assert.AreEqual(body.Text, ((TextPart)decrypted).Text, "Decrypted content is not the same as the original.");
}
}
public void TestPgpMimeSigning()
{
var self = new MailboxAddress("MimeKit UnitTests", "*****@*****.**");
var cleartext = new TextPart("plain");
cleartext.Text = "This is some cleartext that we'll end up signing...";
using (var ctx = new DummyOpenPgpContext()) {
var multipart = MultipartSigned.Create(ctx, self, DigestAlgorithm.Sha1, cleartext);
Assert.AreEqual(2, multipart.Count, "The multipart/signed has an unexpected number of children.");
var protocol = multipart.ContentType.Parameters["protocol"];
Assert.AreEqual(ctx.SignatureProtocol, protocol, "The multipart/signed protocol does not match.");
Assert.IsInstanceOfType(typeof(TextPart), multipart[0], "The first child is not a text part.");
Assert.IsInstanceOfType(typeof(ApplicationPgpSignature), multipart[1], "The second child is not a detached signature.");
var signatures = multipart.Verify(ctx);
Assert.AreEqual(1, signatures.Count, "Verify returned an unexpected number of signatures.");
foreach (var signature in signatures)
{
try {
bool valid = signature.Verify();
Assert.IsTrue(valid, "Bad signature from {0}", signature.SignerCertificate.Email);
} catch (DigitalSignatureVerifyException ex) {
Assert.Fail("Failed to verify signature: {0}", ex);
}
}
}
}
public void TestMultipartSignedSignUsingKeys()
{
var body = new TextPart("plain")
{
Text = "This is some cleartext that we'll end up signing..."
};
var self = new SecureMailboxAddress("MimeKit UnitTests", "*****@*****.**", "44CD48EEC90D8849961F36BA50DCD107AB0821A2");
PgpSecretKey signer;
using (var ctx = new DummyOpenPgpContext()) {
signer = ctx.GetSigningKey(self);
foreach (DigestAlgorithm digest in Enum.GetValues(typeof(DigestAlgorithm)))
{
if (digest == DigestAlgorithm.None ||
digest == DigestAlgorithm.DoubleSha ||
digest == DigestAlgorithm.Tiger192 ||
digest == DigestAlgorithm.Haval5160 ||
digest == DigestAlgorithm.MD4)
{
continue;
}
var multipart = MultipartSigned.Create(signer, digest, body);
Assert.AreEqual(2, multipart.Count, "The multipart/signed has an unexpected number of children.");
var protocol = multipart.ContentType.Parameters["protocol"];
Assert.AreEqual("application/pgp-signature", protocol, "The multipart/signed protocol does not match.");
var micalg = multipart.ContentType.Parameters["micalg"];
var algorithm = ctx.GetDigestAlgorithm(micalg);
Assert.AreEqual(digest, algorithm, "The multipart/signed micalg does not match.");
Assert.IsInstanceOf <TextPart> (multipart[0], "The first child is not a text part.");
Assert.IsInstanceOf <ApplicationPgpSignature> (multipart[1], "The second child is not a detached signature.");
var signatures = multipart.Verify();
Assert.AreEqual(1, signatures.Count, "Verify returned an unexpected number of signatures.");
foreach (var signature in signatures)
{
try {
bool valid = signature.Verify();
Assert.IsTrue(valid, "Bad signature from {0}", signature.SignerCertificate.Email);
} catch (DigitalSignatureVerifyException ex) {
Assert.Fail("Failed to verify signature: {0}", ex);
}
}
}
}
}
public void SetUp()
{
Environment.SetEnvironmentVariable ("GNUPGHOME", Path.GetFullPath ("."));
var dataDir = Path.Combine ("..", "..", "TestData", "openpgp");
using (var ctx = new DummyOpenPgpContext ()) {
using (var seckeys = File.OpenRead (Path.Combine (dataDir, "mimekit.gpg.sec")))
ctx.ImportSecretKeys (seckeys);
using (var pubkeys = File.OpenRead (Path.Combine (dataDir, "mimekit.gpg.pub")))
ctx.Import (pubkeys);
}
}
public void SetUp()
{
Environment.SetEnvironmentVariable("GNUPGHOME", Path.GetFullPath("."));
var dataDir = Path.Combine("..", "..", "TestData", "openpgp");
using (var ctx = new DummyOpenPgpContext()) {
using (var seckeys = File.OpenRead(Path.Combine(dataDir, "mimekit.gpg.sec")))
ctx.ImportSecretKeys(seckeys);
using (var pubkeys = File.OpenRead(Path.Combine(dataDir, "mimekit.gpg.pub")))
ctx.Import(pubkeys);
}
}
public void TestMimeMessageSignAndEncrypt()
{
var body = new TextPart("plain")
{
Text = "This is some cleartext that we'll end up signing and encrypting..."
};
var self = new SecureMailboxAddress("MimeKit UnitTests", "*****@*****.**", "AB0821A2");
var message = new MimeMessage {
Subject = "Test of signing with OpenPGP"
};
DigitalSignatureCollection signatures;
using (var ctx = new DummyOpenPgpContext()) {
// throws because no Body has been set
Assert.Throws <InvalidOperationException> (() => message.SignAndEncrypt(ctx));
message.Body = body;
// throws because no sender has been set
Assert.Throws <InvalidOperationException> (() => message.SignAndEncrypt(ctx));
message.From.Add(self);
message.To.Add(self);
message.SignAndEncrypt(ctx);
Assert.IsInstanceOf <MultipartEncrypted> (message.Body);
var encrypted = (MultipartEncrypted)message.Body;
//using (var file = File.Create ("pgp-signed-encrypted.asc"))
// encrypted.WriteTo (file);
var decrypted = encrypted.Decrypt(ctx, out signatures);
Assert.IsInstanceOf <TextPart> (decrypted, "Decrypted part is not the expected type.");
Assert.AreEqual(body.Text, ((TextPart)decrypted).Text, "Decrypted content is not the same as the original.");
Assert.AreEqual(1, signatures.Count, "Verify returned an unexpected number of signatures.");
foreach (var signature in signatures)
{
try {
bool valid = signature.Verify();
Assert.IsTrue(valid, "Bad signature from {0}", signature.SignerCertificate.Email);
} catch (DigitalSignatureVerifyException ex) {
Assert.Fail("Failed to verify signature: {0}", ex);
}
}
}
}
public void TestMimeMessageSign()
{
var body = new TextPart("plain")
{
Text = "This is some cleartext that we'll end up signing..."
};
var self = new MailboxAddress("MimeKit UnitTests", "*****@*****.**");
var message = new MimeMessage {
Subject = "Test of signing with OpenPGP"
};
using (var ctx = new DummyOpenPgpContext()) {
// throws because no Body is set
Assert.Throws <InvalidOperationException> (() => message.Sign(ctx));
message.Body = body;
// throws because no sender is set
Assert.Throws <InvalidOperationException> (() => message.Sign(ctx));
message.From.Add(self);
// ok, now we can sign
message.Sign(ctx);
Assert.IsInstanceOf <MultipartSigned> (message.Body);
var multipart = (MultipartSigned)message.Body;
Assert.AreEqual(2, multipart.Count, "The multipart/signed has an unexpected number of children.");
var protocol = multipart.ContentType.Parameters["protocol"];
Assert.AreEqual(ctx.SignatureProtocol, protocol, "The multipart/signed protocol does not match.");
Assert.IsInstanceOf <TextPart> (multipart[0], "The first child is not a text part.");
Assert.IsInstanceOf <ApplicationPgpSignature> (multipart[1], "The second child is not a detached signature.");
var signatures = multipart.Verify(ctx);
Assert.AreEqual(1, signatures.Count, "Verify returned an unexpected number of signatures.");
foreach (var signature in signatures)
{
try {
bool valid = signature.Verify();
Assert.IsTrue(valid, "Bad signature from {0}", signature.SignerCertificate.Email);
} catch (DigitalSignatureVerifyException ex) {
Assert.Fail("Failed to verify signature: {0}", ex);
}
}
}
}
public void TestExport()
{
var self = new MailboxAddress("MimeKit UnitTests", "*****@*****.**");
using (var ctx = new DummyOpenPgpContext()) {
Assert.AreEqual("application/pgp-keys", ctx.KeyExchangeProtocol, "The key-exchange protocol does not match.");
var exported = ctx.Export(new [] { self });
Assert.IsNotNull(exported, "The exported MIME part should not be null.");
Assert.IsInstanceOf <MimePart> (exported, "The exported MIME part should be a MimePart.");
Assert.AreEqual("application/pgp-keys", exported.ContentType.MimeType);
}
}
public void TestSupports()
{
var supports = new [] { "application/pgp-encrypted", "application/pgp-signature", "application/pgp-keys",
"application/x-pgp-encrypted", "application/x-pgp-signature", "application/x-pgp-keys" };
using (var ctx = new DummyOpenPgpContext()) {
for (int i = 0; i < supports.Length; i++)
{
Assert.IsTrue(ctx.Supports(supports[i]), supports[i]);
}
Assert.IsFalse(ctx.Supports("application/octet-stream"), "application/octet-stream");
Assert.IsFalse(ctx.Supports("text/plain"), "text/plain");
}
}
public void TestDefaultEncryptionAlgorithm()
{
using (var ctx = new DummyOpenPgpContext()) {
foreach (EncryptionAlgorithm algorithm in Enum.GetValues(typeof(EncryptionAlgorithm)))
{
if (algorithm == EncryptionAlgorithm.RC240 ||
algorithm == EncryptionAlgorithm.RC264 ||
algorithm == EncryptionAlgorithm.RC2128)
{
Assert.Throws <NotSupportedException> (() => ctx.DefaultEncryptionAlgorithm = algorithm);
continue;
}
ctx.DefaultEncryptionAlgorithm = algorithm;
Assert.AreEqual(algorithm, ctx.DefaultEncryptionAlgorithm, "Default encryption algorithm does not match.");
}
}
}
static PgpMimeTests ()
{
Environment.SetEnvironmentVariable ("GNUPGHOME", Path.GetFullPath ("."));
var dataDir = Path.Combine ("..", "..", "TestData", "openpgp");
CryptographyContext.Register (typeof (DummyOpenPgpContext));
foreach (var name in new [] { "pubring.gpg", "pubring.gpg~", "secring.gpg", "secring.gpg~" }) {
if (File.Exists (name))
File.Delete (name);
}
using (var ctx = new DummyOpenPgpContext ()) {
using (var seckeys = File.OpenRead (Path.Combine (dataDir, "mimekit.gpg.sec")))
ctx.ImportSecretKeys (seckeys);
using (var pubkeys = File.OpenRead (Path.Combine (dataDir, "mimekit.gpg.pub")))
ctx.Import (pubkeys);
}
}
public void TestAlgorithmMappings()
{
using (var ctx = new DummyOpenPgpContext()) {
foreach (DigestAlgorithm digest in Enum.GetValues(typeof(DigestAlgorithm)))
{
if (digest == DigestAlgorithm.None || digest == DigestAlgorithm.DoubleSha)
{
continue;
}
var name = ctx.GetDigestAlgorithmName(digest);
var algo = ctx.GetDigestAlgorithm(name);
Assert.AreEqual(digest, algo);
}
Assert.AreEqual(DigestAlgorithm.MD5, OpenPgpContext.GetDigestAlgorithm(Org.BouncyCastle.Bcpg.HashAlgorithmTag.MD5));
Assert.AreEqual(DigestAlgorithm.Sha1, OpenPgpContext.GetDigestAlgorithm(Org.BouncyCastle.Bcpg.HashAlgorithmTag.Sha1));
Assert.AreEqual(DigestAlgorithm.RipeMD160, OpenPgpContext.GetDigestAlgorithm(Org.BouncyCastle.Bcpg.HashAlgorithmTag.RipeMD160));
Assert.AreEqual(DigestAlgorithm.DoubleSha, OpenPgpContext.GetDigestAlgorithm(Org.BouncyCastle.Bcpg.HashAlgorithmTag.DoubleSha));
Assert.AreEqual(DigestAlgorithm.MD2, OpenPgpContext.GetDigestAlgorithm(Org.BouncyCastle.Bcpg.HashAlgorithmTag.MD2));
Assert.AreEqual(DigestAlgorithm.Tiger192, OpenPgpContext.GetDigestAlgorithm(Org.BouncyCastle.Bcpg.HashAlgorithmTag.Tiger192));
Assert.AreEqual(DigestAlgorithm.Haval5160, OpenPgpContext.GetDigestAlgorithm(Org.BouncyCastle.Bcpg.HashAlgorithmTag.Haval5pass160));
Assert.AreEqual(DigestAlgorithm.Sha256, OpenPgpContext.GetDigestAlgorithm(Org.BouncyCastle.Bcpg.HashAlgorithmTag.Sha256));
Assert.AreEqual(DigestAlgorithm.Sha384, OpenPgpContext.GetDigestAlgorithm(Org.BouncyCastle.Bcpg.HashAlgorithmTag.Sha384));
Assert.AreEqual(DigestAlgorithm.Sha512, OpenPgpContext.GetDigestAlgorithm(Org.BouncyCastle.Bcpg.HashAlgorithmTag.Sha512));
Assert.AreEqual(DigestAlgorithm.Sha224, OpenPgpContext.GetDigestAlgorithm(Org.BouncyCastle.Bcpg.HashAlgorithmTag.Sha224));
Assert.AreEqual(PublicKeyAlgorithm.RsaGeneral, OpenPgpContext.GetPublicKeyAlgorithm(Org.BouncyCastle.Bcpg.PublicKeyAlgorithmTag.RsaGeneral));
Assert.AreEqual(PublicKeyAlgorithm.RsaEncrypt, OpenPgpContext.GetPublicKeyAlgorithm(Org.BouncyCastle.Bcpg.PublicKeyAlgorithmTag.RsaEncrypt));
Assert.AreEqual(PublicKeyAlgorithm.RsaSign, OpenPgpContext.GetPublicKeyAlgorithm(Org.BouncyCastle.Bcpg.PublicKeyAlgorithmTag.RsaSign));
Assert.AreEqual(PublicKeyAlgorithm.ElGamalGeneral, OpenPgpContext.GetPublicKeyAlgorithm(Org.BouncyCastle.Bcpg.PublicKeyAlgorithmTag.ElGamalGeneral));
Assert.AreEqual(PublicKeyAlgorithm.ElGamalEncrypt, OpenPgpContext.GetPublicKeyAlgorithm(Org.BouncyCastle.Bcpg.PublicKeyAlgorithmTag.ElGamalEncrypt));
Assert.AreEqual(PublicKeyAlgorithm.Dsa, OpenPgpContext.GetPublicKeyAlgorithm(Org.BouncyCastle.Bcpg.PublicKeyAlgorithmTag.Dsa));
Assert.AreEqual(PublicKeyAlgorithm.EllipticCurve, OpenPgpContext.GetPublicKeyAlgorithm(Org.BouncyCastle.Bcpg.PublicKeyAlgorithmTag.ECDH));
Assert.AreEqual(PublicKeyAlgorithm.EllipticCurveDsa, OpenPgpContext.GetPublicKeyAlgorithm(Org.BouncyCastle.Bcpg.PublicKeyAlgorithmTag.ECDsa));
Assert.AreEqual(PublicKeyAlgorithm.DiffieHellman, OpenPgpContext.GetPublicKeyAlgorithm(Org.BouncyCastle.Bcpg.PublicKeyAlgorithmTag.DiffieHellman));
//Assert.AreEqual (PublicKeyAlgorithm.EdwardsCurveDsa, OpenPgpContext.GetPublicKeyAlgorithm (Org.BouncyCastle.Bcpg.PublicKeyAlgorithmTag.EdDSA));
}
}
public void TestMultipartEncryptedSignAndEncryptALgorithmUsingKeys()
{
var body = new TextPart("plain")
{
Text = "This is some cleartext that we'll end up signing and encrypting..."
};
var self = new SecureMailboxAddress("MimeKit UnitTests", "*****@*****.**", "AB0821A2");
DigitalSignatureCollection signatures;
IList <PgpPublicKey> recipients;
PgpSecretKey signer;
using (var ctx = new DummyOpenPgpContext()) {
recipients = ctx.GetPublicKeys(new [] { self });
signer = ctx.GetSigningKey(self);
}
var encrypted = MultipartEncrypted.SignAndEncrypt(signer, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, recipients, body);
//using (var file = File.Create ("pgp-signed-encrypted.asc"))
// encrypted.WriteTo (file);
var decrypted = encrypted.Decrypt(out signatures);
Assert.IsInstanceOf <TextPart> (decrypted, "Decrypted part is not the expected type.");
Assert.AreEqual(body.Text, ((TextPart)decrypted).Text, "Decrypted content is not the same as the original.");
Assert.AreEqual(1, signatures.Count, "Verify returned an unexpected number of signatures.");
foreach (var signature in signatures)
{
try {
bool valid = signature.Verify();
Assert.IsTrue(valid, "Bad signature from {0}", signature.SignerCertificate.Email);
} catch (DigitalSignatureVerifyException ex) {
Assert.Fail("Failed to verify signature: {0}", ex);
}
}
}
public void TestMimeMessageEncrypt()
{
var body = new TextPart("plain")
{
Text = "This is some cleartext that we'll end up encrypting..."
};
var self = new SecureMailboxAddress("MimeKit UnitTests", "*****@*****.**", "44CD48EEC90D8849961F36BA50DCD107AB0821A2");
var message = new MimeMessage {
Subject = "Test of signing with OpenPGP"
};
using (var ctx = new DummyOpenPgpContext()) {
// throws because no Body has been set
Assert.Throws <InvalidOperationException> (() => message.Encrypt(ctx));
message.Body = body;
// throws because no recipients have been set
Assert.Throws <InvalidOperationException> (() => message.Encrypt(ctx));
message.From.Add(self);
message.To.Add(self);
message.Encrypt(ctx);
Assert.IsInstanceOf <MultipartEncrypted> (message.Body);
var encrypted = (MultipartEncrypted)message.Body;
//using (var file = File.Create ("pgp-encrypted.asc"))
// encrypted.WriteTo (file);
var decrypted = encrypted.Decrypt(ctx);
Assert.IsInstanceOf <TextPart> (decrypted, "Decrypted part is not the expected type.");
Assert.AreEqual(body.Text, ((TextPart)decrypted).Text, "Decrypted content is not the same as the original.");
}
}
public void TestPgpMimeSignAndEncrypt()
{
var self = new MailboxAddress("MimeKit UnitTests", "*****@*****.**");
var recipients = new List <MailboxAddress> ();
// encrypt to ourselves...
recipients.Add(self);
var cleartext = new TextPart("plain");
cleartext.Text = "This is some cleartext that we'll end up encrypting...";
using (var ctx = new DummyOpenPgpContext()) {
var encrypted = MultipartEncrypted.Create(ctx, self, DigestAlgorithm.Sha1, recipients, cleartext);
//using (var file = File.Create ("pgp-signed-encrypted.asc"))
// encrypted.WriteTo (file);
DigitalSignatureCollection signatures;
var decrypted = encrypted.Decrypt(ctx, out signatures);
Assert.IsInstanceOfType(typeof(TextPart), decrypted, "Decrypted part is not the expected type.");
Assert.AreEqual(cleartext.Text, ((TextPart)decrypted).Text, "Decrypted content is not the same as the original.");
Assert.AreEqual(1, signatures.Count, "Verify returned an unexpected number of signatures.");
foreach (var signature in signatures)
{
try {
bool valid = signature.Verify();
Assert.IsTrue(valid, "Bad signature from {0}", signature.SignerCertificate.Email);
} catch (DigitalSignatureVerifyException ex) {
Assert.Fail("Failed to verify signature: {0}", ex);
}
}
}
}
public void TestMimeMessageSign ()
{
var body = new TextPart ("plain") { Text = "This is some cleartext that we'll end up signing..." };
var self = new MailboxAddress ("MimeKit UnitTests", "*****@*****.**");
var message = new MimeMessage { Subject = "Test of signing with OpenPGP" };
message.From.Add (self);
message.Body = body;
using (var ctx = new DummyOpenPgpContext ()) {
message.Sign (ctx);
Assert.IsInstanceOf<MultipartSigned> (message.Body);
var multipart = (MultipartSigned) message.Body;
Assert.AreEqual (2, multipart.Count, "The multipart/signed has an unexpected number of children.");
var protocol = multipart.ContentType.Parameters["protocol"];
Assert.AreEqual (ctx.SignatureProtocol, protocol, "The multipart/signed protocol does not match.");
Assert.IsInstanceOf<TextPart> (multipart[0], "The first child is not a text part.");
Assert.IsInstanceOf<ApplicationPgpSignature> (multipart[1], "The second child is not a detached signature.");
var signatures = multipart.Verify (ctx);
Assert.AreEqual (1, signatures.Count, "Verify returned an unexpected number of signatures.");
foreach (var signature in signatures) {
try {
bool valid = signature.Verify ();
Assert.IsTrue (valid, "Bad signature from {0}", signature.SignerCertificate.Email);
} catch (DigitalSignatureVerifyException ex) {
Assert.Fail ("Failed to verify signature: {0}", ex);
}
}
}
}
public void TestPgpMimeEncryption()
{
var self = new MailboxAddress("MimeKit UnitTests", "*****@*****.**");
var recipients = new List <MailboxAddress> ();
// encrypt to ourselves...
recipients.Add(self);
var cleartext = new TextPart("plain");
cleartext.Text = "This is some cleartext that we'll end up encrypting...";
using (var ctx = new DummyOpenPgpContext()) {
var encrypted = MultipartEncrypted.Create(ctx, recipients, cleartext);
//using (var file = File.Create ("pgp-encrypted.asc"))
// encrypted.WriteTo (file);
var decrypted = encrypted.Decrypt(ctx);
Assert.IsInstanceOfType(typeof(TextPart), decrypted, "Decrypted part is not the expected type.");
Assert.AreEqual(cleartext.Text, ((TextPart)decrypted).Text, "Decrypted content is not the same as the original.");
}
}
public void TestPgpMimeSignAndEncrypt()
{
var self = new MailboxAddress ("MimeKit UnitTests", "*****@*****.**");
var recipients = new List<MailboxAddress> ();
// encrypt to ourselves...
recipients.Add (self);
var cleartext = new TextPart ("plain");
cleartext.Text = "This is some cleartext that we'll end up encrypting...";
using (var ctx = new DummyOpenPgpContext ()) {
var encrypted = MultipartEncrypted.Create (ctx, self, DigestAlgorithm.Sha1, recipients, cleartext);
//using (var file = File.Create ("pgp-signed-encrypted.asc"))
// encrypted.WriteTo (file);
DigitalSignatureCollection signatures;
var decrypted = encrypted.Decrypt (ctx, out signatures);
Assert.IsInstanceOfType (typeof (TextPart), decrypted, "Decrypted part is not the expected type.");
Assert.AreEqual (cleartext.Text, ((TextPart) decrypted).Text, "Decrypted content is not the same as the original.");
Assert.AreEqual (1, signatures.Count, "Verify returned an unexpected number of signatures.");
foreach (var signature in signatures) {
try {
bool valid = signature.Verify ();
Assert.IsTrue (valid, "Bad signature from {0}", signature.SignerCertificate.Email);
} catch (DigitalSignatureVerifyException ex) {
Assert.Fail ("Failed to verify signature: {0}", ex);
}
}
}
}
public void TestArgumentExceptions()
{
using (var ctx = new DummyOpenPgpContext()) {
var mailboxes = new [] { new MailboxAddress("MimeKit UnitTests", "*****@*****.**") };
var emptyMailboxes = new MailboxAddress[0];
var pubkeys = ctx.GetPublicKeys(mailboxes);
var key = ctx.GetSigningKey(mailboxes[0]);
var emptyPubkeys = new PgpPublicKey[0];
var stream = new MemoryStream();
Assert.Throws <ArgumentNullException> (() => new ApplicationPgpEncrypted((MimeEntityConstructorArgs)null));
Assert.Throws <ArgumentNullException> (() => new ApplicationPgpSignature((MimeEntityConstructorArgs)null));
Assert.Throws <ArgumentNullException> (() => new ApplicationPgpSignature((Stream)null));
// Accept
Assert.Throws <ArgumentNullException> (() => new ApplicationPgpEncrypted().Accept(null));
Assert.Throws <ArgumentNullException> (() => new ApplicationPgpSignature(stream).Accept(null));
// Decrypt
Assert.Throws <ArgumentNullException> (() => ctx.Decrypt(null), "Decrypt");
// Encrypt
Assert.Throws <ArgumentNullException> (() => ctx.Encrypt(EncryptionAlgorithm.Cast5, (MailboxAddress[])null, stream), "Encrypt");
Assert.Throws <ArgumentNullException> (() => ctx.Encrypt(EncryptionAlgorithm.Cast5, (PgpPublicKey[])null, stream), "Encrypt");
Assert.Throws <ArgumentNullException> (() => ctx.Encrypt((MailboxAddress[])null, stream), "Encrypt");
Assert.Throws <ArgumentNullException> (() => ctx.Encrypt((PgpPublicKey[])null, stream), "Encrypt");
Assert.Throws <ArgumentException> (() => ctx.Encrypt(EncryptionAlgorithm.Cast5, emptyMailboxes, stream), "Encrypt");
Assert.Throws <ArgumentException> (() => ctx.Encrypt(EncryptionAlgorithm.Cast5, emptyPubkeys, stream), "Encrypt");
Assert.Throws <ArgumentException> (() => ctx.Encrypt(emptyMailboxes, stream), "Encrypt");
Assert.Throws <ArgumentException> (() => ctx.Encrypt(emptyPubkeys, stream), "Encrypt");
Assert.Throws <ArgumentNullException> (() => ctx.Encrypt(EncryptionAlgorithm.Cast5, mailboxes, null), "Encrypt");
Assert.Throws <ArgumentNullException> (() => ctx.Encrypt(EncryptionAlgorithm.Cast5, pubkeys, null), "Encrypt");
Assert.Throws <ArgumentNullException> (() => ctx.Encrypt(mailboxes, null), "Encrypt");
Assert.Throws <ArgumentNullException> (() => ctx.Encrypt(pubkeys, null), "Encrypt");
// Export
Assert.Throws <ArgumentNullException> (() => ctx.Export((PgpPublicKeyRingBundle)null), "Export");
Assert.Throws <ArgumentNullException> (() => ctx.Export((MailboxAddress[])null), "Export");
Assert.Throws <ArgumentNullException> (() => ctx.Export((PgpPublicKey[])null), "Export");
// GetDecryptedStream
Assert.Throws <ArgumentNullException> (() => ctx.GetDecryptedStream(null), "GetDecryptedStream");
// GetDigestAlgorithmName
Assert.Throws <ArgumentOutOfRangeException> (() => ctx.GetDigestAlgorithmName(DigestAlgorithm.None), "GetDigestAlgorithmName");
// Import
Assert.Throws <ArgumentNullException> (() => ctx.Import((Stream)null), "Import");
Assert.Throws <ArgumentNullException> (() => ctx.Import((PgpPublicKeyRing)null), "Import");
Assert.Throws <ArgumentNullException> (() => ctx.Import((PgpPublicKeyRingBundle)null), "Import");
Assert.Throws <ArgumentNullException> (() => ctx.Import((PgpSecretKeyRing)null), "Import");
Assert.Throws <ArgumentNullException> (() => ctx.Import((PgpSecretKeyRingBundle)null), "Import");
// ImportSecretKeys
Assert.Throws <ArgumentNullException> (() => ctx.ImportSecretKeys(null), "ImportSecretKeys");
// Sign
Assert.Throws <ArgumentNullException> (() => ctx.Sign((MailboxAddress)null, DigestAlgorithm.Sha1, stream), "Sign");
Assert.Throws <ArgumentNullException> (() => ctx.Sign((PgpSecretKey)null, DigestAlgorithm.Sha1, stream), "Sign");
Assert.Throws <ArgumentNullException> (() => ctx.Sign(mailboxes[0], DigestAlgorithm.Sha1, null), "Sign");
Assert.Throws <ArgumentNullException> (() => ctx.Sign(key, DigestAlgorithm.Sha1, null), "Sign");
// SignAndEncrypt
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt((MailboxAddress)null, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, mailboxes, stream), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt((PgpSecretKey)null, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, pubkeys, stream), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt(mailboxes[0], DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, (MailboxAddress[])null, stream), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt(key, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, (PgpPublicKey[])null, stream), "SignAndEncrypt");
Assert.Throws <ArgumentException> (() => ctx.SignAndEncrypt(mailboxes[0], DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, emptyMailboxes, stream), "SignAndEncrypt");
Assert.Throws <ArgumentException> (() => ctx.SignAndEncrypt(key, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, emptyPubkeys, stream), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt(mailboxes[0], DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, mailboxes, null), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt(key, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, pubkeys, null), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt((MailboxAddress)null, DigestAlgorithm.Sha1, mailboxes, stream), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt((PgpSecretKey)null, DigestAlgorithm.Sha1, pubkeys, stream), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt(mailboxes[0], DigestAlgorithm.Sha1, (MailboxAddress[])null, stream), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt(key, DigestAlgorithm.Sha1, (PgpPublicKey[])null, stream), "SignAndEncrypt");
Assert.Throws <ArgumentException> (() => ctx.SignAndEncrypt(mailboxes[0], DigestAlgorithm.Sha1, emptyMailboxes, stream), "SignAndEncrypt");
Assert.Throws <ArgumentException> (() => ctx.SignAndEncrypt(key, DigestAlgorithm.Sha1, emptyPubkeys, stream), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt(mailboxes[0], DigestAlgorithm.Sha1, mailboxes, null), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt(key, DigestAlgorithm.Sha1, pubkeys, null), "SignAndEncrypt");
// Supports
Assert.Throws <ArgumentNullException> (() => ctx.Supports(null), "Supports");
// Verify
Assert.Throws <ArgumentNullException> (() => ctx.Verify(null, stream), "Verify");
Assert.Throws <ArgumentNullException> (() => ctx.Verify(stream, null), "Verify");
}
}
public void TestArgumentExceptions()
{
Assert.Throws <ArgumentNullException> (() => CryptographyContext.Create(null));
Assert.Throws <ArgumentNullException> (() => CryptographyContext.Register((Type)null));
Assert.Throws <ArgumentNullException> (() => CryptographyContext.Register((Func <OpenPgpContext>)null));
Assert.Throws <ArgumentNullException> (() => CryptographyContext.Register((Func <SecureMimeContext>)null));
using (var ctx = new DummyOpenPgpContext()) {
var mailboxes = new [] { new MailboxAddress("MimeKit UnitTests", "*****@*****.**") };
var emptyMailboxes = new MailboxAddress[0];
var pubkeys = ctx.GetPublicKeys(mailboxes);
var key = ctx.GetSigningKey(mailboxes[0]);
var emptyPubkeys = new PgpPublicKey[0];
var stream = new MemoryStream();
Assert.Throws <ArgumentException> (() => ctx.KeyServer = new Uri("relative/uri", UriKind.Relative));
Assert.Throws <ArgumentNullException> (() => ctx.GetDigestAlgorithm(null));
Assert.Throws <ArgumentOutOfRangeException> (() => ctx.GetDigestAlgorithmName(DigestAlgorithm.DoubleSha));
Assert.Throws <NotSupportedException> (() => OpenPgpContext.GetHashAlgorithm(DigestAlgorithm.DoubleSha));
Assert.Throws <NotSupportedException> (() => OpenPgpContext.GetHashAlgorithm(DigestAlgorithm.Tiger192));
Assert.Throws <NotSupportedException> (() => OpenPgpContext.GetHashAlgorithm(DigestAlgorithm.Haval5160));
Assert.Throws <NotSupportedException> (() => OpenPgpContext.GetHashAlgorithm(DigestAlgorithm.MD4));
Assert.Throws <ArgumentOutOfRangeException> (() => OpenPgpContext.GetDigestAlgorithm((Org.BouncyCastle.Bcpg.HashAlgorithmTag) 1024));
Assert.Throws <ArgumentNullException> (() => new ApplicationPgpEncrypted((MimeEntityConstructorArgs)null));
Assert.Throws <ArgumentNullException> (() => new ApplicationPgpSignature((MimeEntityConstructorArgs)null));
Assert.Throws <ArgumentNullException> (() => new ApplicationPgpSignature((Stream)null));
// Accept
Assert.Throws <ArgumentNullException> (() => new ApplicationPgpEncrypted().Accept(null));
Assert.Throws <ArgumentNullException> (() => new ApplicationPgpSignature(stream).Accept(null));
// Decrypt
Assert.Throws <ArgumentNullException> (() => ctx.Decrypt(null), "Decrypt");
// Encrypt
Assert.Throws <ArgumentNullException> (() => ctx.Encrypt(EncryptionAlgorithm.Cast5, (MailboxAddress[])null, stream), "Encrypt");
Assert.Throws <ArgumentNullException> (() => ctx.Encrypt(EncryptionAlgorithm.Cast5, (PgpPublicKey[])null, stream), "Encrypt");
Assert.Throws <ArgumentNullException> (() => ctx.Encrypt((MailboxAddress[])null, stream), "Encrypt");
Assert.Throws <ArgumentNullException> (() => ctx.Encrypt((PgpPublicKey[])null, stream), "Encrypt");
Assert.Throws <ArgumentException> (() => ctx.Encrypt(EncryptionAlgorithm.Cast5, emptyMailboxes, stream), "Encrypt");
Assert.Throws <ArgumentException> (() => ctx.Encrypt(EncryptionAlgorithm.Cast5, emptyPubkeys, stream), "Encrypt");
Assert.Throws <ArgumentException> (() => ctx.Encrypt(emptyMailboxes, stream), "Encrypt");
Assert.Throws <ArgumentException> (() => ctx.Encrypt(emptyPubkeys, stream), "Encrypt");
Assert.Throws <ArgumentNullException> (() => ctx.Encrypt(EncryptionAlgorithm.Cast5, mailboxes, null), "Encrypt");
Assert.Throws <ArgumentNullException> (() => ctx.Encrypt(EncryptionAlgorithm.Cast5, pubkeys, null), "Encrypt");
Assert.Throws <ArgumentNullException> (() => ctx.Encrypt(mailboxes, null), "Encrypt");
Assert.Throws <ArgumentNullException> (() => ctx.Encrypt(pubkeys, null), "Encrypt");
// Export
Assert.Throws <ArgumentNullException> (() => ctx.Export((PgpPublicKeyRingBundle)null), "Export");
Assert.Throws <ArgumentNullException> (() => ctx.Export((MailboxAddress[])null), "Export");
Assert.Throws <ArgumentNullException> (() => ctx.Export((PgpPublicKey[])null), "Export");
// GetDecryptedStream
Assert.Throws <ArgumentNullException> (() => ctx.GetDecryptedStream(null), "GetDecryptedStream");
// GetDigestAlgorithmName
Assert.Throws <ArgumentOutOfRangeException> (() => ctx.GetDigestAlgorithmName(DigestAlgorithm.None), "GetDigestAlgorithmName");
// Import
Assert.Throws <ArgumentNullException> (() => ctx.Import((Stream)null), "Import");
Assert.Throws <ArgumentNullException> (() => ctx.Import((PgpPublicKeyRing)null), "Import");
Assert.Throws <ArgumentNullException> (() => ctx.Import((PgpPublicKeyRingBundle)null), "Import");
Assert.Throws <ArgumentNullException> (() => ctx.Import((PgpSecretKeyRing)null), "Import");
Assert.Throws <ArgumentNullException> (() => ctx.Import((PgpSecretKeyRingBundle)null), "Import");
// ImportSecretKeys
Assert.Throws <ArgumentNullException> (() => ctx.ImportSecretKeys(null), "ImportSecretKeys");
// Sign
Assert.Throws <ArgumentNullException> (() => ctx.Sign((MailboxAddress)null, DigestAlgorithm.Sha1, stream), "Sign");
Assert.Throws <ArgumentNullException> (() => ctx.Sign((PgpSecretKey)null, DigestAlgorithm.Sha1, stream), "Sign");
Assert.Throws <ArgumentNullException> (() => ctx.Sign(mailboxes[0], DigestAlgorithm.Sha1, null), "Sign");
Assert.Throws <ArgumentNullException> (() => ctx.Sign(key, DigestAlgorithm.Sha1, null), "Sign");
// SignAndEncrypt
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt((MailboxAddress)null, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, mailboxes, stream), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt((PgpSecretKey)null, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, pubkeys, stream), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt(mailboxes[0], DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, (MailboxAddress[])null, stream), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt(key, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, (PgpPublicKey[])null, stream), "SignAndEncrypt");
Assert.Throws <ArgumentException> (() => ctx.SignAndEncrypt(mailboxes[0], DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, emptyMailboxes, stream), "SignAndEncrypt");
Assert.Throws <ArgumentException> (() => ctx.SignAndEncrypt(key, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, emptyPubkeys, stream), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt(mailboxes[0], DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, mailboxes, null), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt(key, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, pubkeys, null), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt((MailboxAddress)null, DigestAlgorithm.Sha1, mailboxes, stream), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt((PgpSecretKey)null, DigestAlgorithm.Sha1, pubkeys, stream), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt(mailboxes[0], DigestAlgorithm.Sha1, (MailboxAddress[])null, stream), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt(key, DigestAlgorithm.Sha1, (PgpPublicKey[])null, stream), "SignAndEncrypt");
Assert.Throws <ArgumentException> (() => ctx.SignAndEncrypt(mailboxes[0], DigestAlgorithm.Sha1, emptyMailboxes, stream), "SignAndEncrypt");
Assert.Throws <ArgumentException> (() => ctx.SignAndEncrypt(key, DigestAlgorithm.Sha1, emptyPubkeys, stream), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt(mailboxes[0], DigestAlgorithm.Sha1, mailboxes, null), "SignAndEncrypt");
Assert.Throws <ArgumentNullException> (() => ctx.SignAndEncrypt(key, DigestAlgorithm.Sha1, pubkeys, null), "SignAndEncrypt");
// Supports
Assert.Throws <ArgumentNullException> (() => ctx.Supports(null), "Supports");
// Verify
Assert.Throws <ArgumentNullException> (() => ctx.Verify(null, stream), "Verify");
Assert.Throws <ArgumentNullException> (() => ctx.Verify(stream, null), "Verify");
}
}
public void TestPgpMimeEncryption()
{
var self = new MailboxAddress ("MimeKit UnitTests", "*****@*****.**");
var recipients = new List<MailboxAddress> ();
// encrypt to ourselves...
recipients.Add (self);
var cleartext = new TextPart ("plain");
cleartext.Text = "This is some cleartext that we'll end up encrypting...";
using (var ctx = new DummyOpenPgpContext ()) {
var encrypted = MultipartEncrypted.Create (ctx, recipients, cleartext);
//using (var file = File.Create ("pgp-encrypted.asc"))
// encrypted.WriteTo (file);
var decrypted = encrypted.Decrypt (ctx);
Assert.IsInstanceOfType (typeof (TextPart), decrypted, "Decrypted part is not the expected type.");
Assert.AreEqual (cleartext.Text, ((TextPart) decrypted).Text, "Decrypted content is not the same as the original.");
}
}
public void TestMimeMessageEncrypt ()
{
var body = new TextPart ("plain") { Text = "This is some cleartext that we'll end up encrypting..." };
var self = new SecureMailboxAddress ("MimeKit UnitTests", "*****@*****.**", "44CD48EEC90D8849961F36BA50DCD107AB0821A2");
var message = new MimeMessage { Subject = "Test of signing with OpenPGP" };
message.From.Add (self);
message.To.Add (self);
message.Body = body;
using (var ctx = new DummyOpenPgpContext ()) {
message.Encrypt (ctx);
Assert.IsInstanceOf<MultipartEncrypted> (message.Body);
var encrypted = (MultipartEncrypted) message.Body;
//using (var file = File.Create ("pgp-encrypted.asc"))
// encrypted.WriteTo (file);
var decrypted = encrypted.Decrypt (ctx);
Assert.IsInstanceOf<TextPart> (decrypted, "Decrypted part is not the expected type.");
Assert.AreEqual (body.Text, ((TextPart) decrypted).Text, "Decrypted content is not the same as the original.");
}
}
public void TestMultipartSignedSignUsingKeys ()
{
var body = new TextPart ("plain") { Text = "This is some cleartext that we'll end up signing..." };
var self = new SecureMailboxAddress ("MimeKit UnitTests", "*****@*****.**", "44CD48EEC90D8849961F36BA50DCD107AB0821A2");
PgpSecretKey signer;
using (var ctx = new DummyOpenPgpContext ()) {
signer = ctx.GetSigningKey (self);
foreach (DigestAlgorithm digest in Enum.GetValues (typeof (DigestAlgorithm))) {
if (digest == DigestAlgorithm.None ||
digest == DigestAlgorithm.DoubleSha ||
digest == DigestAlgorithm.Tiger192 ||
digest == DigestAlgorithm.Haval5160 ||
digest == DigestAlgorithm.MD4)
continue;
var multipart = MultipartSigned.Create (signer, digest, body);
Assert.AreEqual (2, multipart.Count, "The multipart/signed has an unexpected number of children.");
var protocol = multipart.ContentType.Parameters["protocol"];
Assert.AreEqual ("application/pgp-signature", protocol, "The multipart/signed protocol does not match.");
var micalg = multipart.ContentType.Parameters["micalg"];
var algorithm = ctx.GetDigestAlgorithm (micalg);
Assert.AreEqual (digest, algorithm, "The multipart/signed micalg does not match.");
Assert.IsInstanceOf<TextPart> (multipart[0], "The first child is not a text part.");
Assert.IsInstanceOf<ApplicationPgpSignature> (multipart[1], "The second child is not a detached signature.");
var signatures = multipart.Verify ();
Assert.AreEqual (1, signatures.Count, "Verify returned an unexpected number of signatures.");
foreach (var signature in signatures) {
try {
bool valid = signature.Verify ();
Assert.IsTrue (valid, "Bad signature from {0}", signature.SignerCertificate.Email);
} catch (DigitalSignatureVerifyException ex) {
Assert.Fail ("Failed to verify signature: {0}", ex);
}
}
}
}
}
public void TestMimeMessageSignAndEncrypt ()
{
var body = new TextPart ("plain") { Text = "This is some cleartext that we'll end up signing and encrypting..." };
var self = new SecureMailboxAddress ("MimeKit UnitTests", "*****@*****.**", "AB0821A2");
var message = new MimeMessage { Subject = "Test of signing with OpenPGP" };
DigitalSignatureCollection signatures;
message.From.Add (self);
message.To.Add (self);
message.Body = body;
using (var ctx = new DummyOpenPgpContext ()) {
message.SignAndEncrypt (ctx);
Assert.IsInstanceOf<MultipartEncrypted> (message.Body);
var encrypted = (MultipartEncrypted) message.Body;
//using (var file = File.Create ("pgp-signed-encrypted.asc"))
// encrypted.WriteTo (file);
var decrypted = encrypted.Decrypt (ctx, out signatures);
Assert.IsInstanceOf<TextPart> (decrypted, "Decrypted part is not the expected type.");
Assert.AreEqual (body.Text, ((TextPart) decrypted).Text, "Decrypted content is not the same as the original.");
Assert.AreEqual (1, signatures.Count, "Verify returned an unexpected number of signatures.");
foreach (var signature in signatures) {
try {
bool valid = signature.Verify ();
Assert.IsTrue (valid, "Bad signature from {0}", signature.SignerCertificate.Email);
} catch (DigitalSignatureVerifyException ex) {
Assert.Fail ("Failed to verify signature: {0}", ex);
}
}
}
}
public void TestMultipartEncryptedEncryptAlgorithmUsingKeys ()
{
var body = new TextPart ("plain") { Text = "This is some cleartext that we'll end up encrypting..." };
var self = new MailboxAddress ("MimeKit UnitTests", "*****@*****.**");
IList<PgpPublicKey> recipients;
using (var ctx = new DummyOpenPgpContext ()) {
recipients = ctx.GetPublicKeys (new [] { self });
}
foreach (EncryptionAlgorithm algorithm in Enum.GetValues (typeof (EncryptionAlgorithm))) {
if (algorithm == EncryptionAlgorithm.RC240 ||
algorithm == EncryptionAlgorithm.RC264 ||
algorithm == EncryptionAlgorithm.RC2128)
continue;
var encrypted = MultipartEncrypted.Encrypt (algorithm, recipients, body);
//using (var file = File.Create ("pgp-encrypted.asc"))
// encrypted.WriteTo (file);
var decrypted = encrypted.Decrypt ();
Assert.IsInstanceOf<TextPart> (decrypted, "Decrypted part is not the expected type.");
Assert.AreEqual (body.Text, ((TextPart) decrypted).Text, "Decrypted content is not the same as the original.");
}
}
public void TestMultipartEncryptedSignAndEncryptALgorithmUsingKeys ()
{
var body = new TextPart ("plain") { Text = "This is some cleartext that we'll end up signing and encrypting..." };
var self = new SecureMailboxAddress ("MimeKit UnitTests", "*****@*****.**", "AB0821A2");
DigitalSignatureCollection signatures;
IList<PgpPublicKey> recipients;
PgpSecretKey signer;
using (var ctx = new DummyOpenPgpContext ()) {
recipients = ctx.GetPublicKeys (new [] { self });
signer = ctx.GetSigningKey (self);
}
var encrypted = MultipartEncrypted.SignAndEncrypt (signer, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, recipients, body);
//using (var file = File.Create ("pgp-signed-encrypted.asc"))
// encrypted.WriteTo (file);
var decrypted = encrypted.Decrypt (out signatures);
Assert.IsInstanceOf<TextPart> (decrypted, "Decrypted part is not the expected type.");
Assert.AreEqual (body.Text, ((TextPart) decrypted).Text, "Decrypted content is not the same as the original.");
Assert.AreEqual (1, signatures.Count, "Verify returned an unexpected number of signatures.");
foreach (var signature in signatures) {
try {
bool valid = signature.Verify ();
Assert.IsTrue (valid, "Bad signature from {0}", signature.SignerCertificate.Email);
} catch (DigitalSignatureVerifyException ex) {
Assert.Fail ("Failed to verify signature: {0}", ex);
}
}
}
public void TestExport ()
{
var self = new MailboxAddress ("MimeKit UnitTests", "*****@*****.**");
using (var ctx = new DummyOpenPgpContext ()) {
Assert.AreEqual ("application/pgp-keys", ctx.KeyExchangeProtocol, "The key-exchange protocol does not match.");
var exported = ctx.Export (new [] { self });
Assert.IsNotNull (exported, "The exported MIME part should not be null.");
Assert.IsInstanceOf<MimePart> (exported, "The exported MIME part should be a MimePart.");
Assert.AreEqual ("application/pgp-keys", exported.ContentType.MimeType);
}
}
public void TestDefaultEncryptionAlgorithm ()
{
using (var ctx = new DummyOpenPgpContext ()) {
foreach (EncryptionAlgorithm algorithm in Enum.GetValues (typeof (EncryptionAlgorithm))) {
if (algorithm == EncryptionAlgorithm.RC240 ||
algorithm == EncryptionAlgorithm.RC264 ||
algorithm == EncryptionAlgorithm.RC2128) {
Assert.Throws<NotSupportedException> (() => ctx.DefaultEncryptionAlgorithm = algorithm);
continue;
}
ctx.DefaultEncryptionAlgorithm = algorithm;
Assert.AreEqual (algorithm, ctx.DefaultEncryptionAlgorithm, "Default encryption algorithm does not match.");
}
}
}
public void TestSupports ()
{
var supports = new [] { "application/pgp-encrypted", "application/pgp-signature", "application/pgp-keys",
"application/x-pgp-encrypted", "application/x-pgp-signature", "application/x-pgp-keys" };
using (var ctx = new DummyOpenPgpContext ()) {
for (int i = 0; i < supports.Length; i++)
Assert.IsTrue (ctx.Supports (supports[i]), supports[i]);
Assert.IsFalse (ctx.Supports ("application/octet-stream"), "application/octet-stream");
Assert.IsFalse (ctx.Supports ("text/plain"), "text/plain");
}
}
public void TestArgumentExceptions ()
{
using (var ctx = new DummyOpenPgpContext ()) {
var mailboxes = new [] { new MailboxAddress ("MimeKit UnitTests", "*****@*****.**") };
var emptyMailboxes = new MailboxAddress[0];
var pubkeys = ctx.GetPublicKeys (mailboxes);
var key = ctx.GetSigningKey (mailboxes[0]);
var emptyPubkeys = new PgpPublicKey[0];
var stream = new MemoryStream ();
Assert.Throws<ArgumentNullException> (() => new ApplicationPgpEncrypted ((MimeEntityConstructorArgs) null));
Assert.Throws<ArgumentNullException> (() => new ApplicationPgpSignature ((MimeEntityConstructorArgs) null));
Assert.Throws<ArgumentNullException> (() => new ApplicationPgpSignature ((Stream) null));
// Accept
Assert.Throws<ArgumentNullException> (() => new ApplicationPgpEncrypted ().Accept (null));
Assert.Throws<ArgumentNullException> (() => new ApplicationPgpSignature (stream).Accept (null));
// Decrypt
Assert.Throws<ArgumentNullException> (() => ctx.Decrypt (null), "Decrypt");
// Encrypt
Assert.Throws<ArgumentNullException> (() => ctx.Encrypt (EncryptionAlgorithm.Cast5, (MailboxAddress[]) null, stream), "Encrypt");
Assert.Throws<ArgumentNullException> (() => ctx.Encrypt (EncryptionAlgorithm.Cast5, (PgpPublicKey[]) null, stream), "Encrypt");
Assert.Throws<ArgumentNullException> (() => ctx.Encrypt ((MailboxAddress[]) null, stream), "Encrypt");
Assert.Throws<ArgumentNullException> (() => ctx.Encrypt ((PgpPublicKey[]) null, stream), "Encrypt");
Assert.Throws<ArgumentException> (() => ctx.Encrypt (EncryptionAlgorithm.Cast5, emptyMailboxes, stream), "Encrypt");
Assert.Throws<ArgumentException> (() => ctx.Encrypt (EncryptionAlgorithm.Cast5, emptyPubkeys, stream), "Encrypt");
Assert.Throws<ArgumentException> (() => ctx.Encrypt (emptyMailboxes, stream), "Encrypt");
Assert.Throws<ArgumentException> (() => ctx.Encrypt (emptyPubkeys, stream), "Encrypt");
Assert.Throws<ArgumentNullException> (() => ctx.Encrypt (EncryptionAlgorithm.Cast5, mailboxes, null), "Encrypt");
Assert.Throws<ArgumentNullException> (() => ctx.Encrypt (EncryptionAlgorithm.Cast5, pubkeys, null), "Encrypt");
Assert.Throws<ArgumentNullException> (() => ctx.Encrypt (mailboxes, null), "Encrypt");
Assert.Throws<ArgumentNullException> (() => ctx.Encrypt (pubkeys, null), "Encrypt");
// Export
Assert.Throws<ArgumentNullException> (() => ctx.Export ((PgpPublicKeyRingBundle) null), "Export");
Assert.Throws<ArgumentNullException> (() => ctx.Export ((MailboxAddress[]) null), "Export");
Assert.Throws<ArgumentNullException> (() => ctx.Export ((PgpPublicKey[]) null), "Export");
// GetDecryptedStream
Assert.Throws<ArgumentNullException> (() => ctx.GetDecryptedStream (null), "GetDecryptedStream");
// GetDigestAlgorithmName
Assert.Throws<ArgumentOutOfRangeException> (() => ctx.GetDigestAlgorithmName (DigestAlgorithm.None), "GetDigestAlgorithmName");
// Import
Assert.Throws<ArgumentNullException> (() => ctx.Import ((Stream) null), "Import");
Assert.Throws<ArgumentNullException> (() => ctx.Import ((PgpPublicKeyRing) null), "Import");
Assert.Throws<ArgumentNullException> (() => ctx.Import ((PgpPublicKeyRingBundle) null), "Import");
Assert.Throws<ArgumentNullException> (() => ctx.Import ((PgpSecretKeyRing) null), "Import");
Assert.Throws<ArgumentNullException> (() => ctx.Import ((PgpSecretKeyRingBundle) null), "Import");
// ImportSecretKeys
Assert.Throws<ArgumentNullException> (() => ctx.ImportSecretKeys (null), "ImportSecretKeys");
// Sign
Assert.Throws<ArgumentNullException> (() => ctx.Sign ((MailboxAddress) null, DigestAlgorithm.Sha1, stream), "Sign");
Assert.Throws<ArgumentNullException> (() => ctx.Sign ((PgpSecretKey) null, DigestAlgorithm.Sha1, stream), "Sign");
Assert.Throws<ArgumentNullException> (() => ctx.Sign (mailboxes[0], DigestAlgorithm.Sha1, null), "Sign");
Assert.Throws<ArgumentNullException> (() => ctx.Sign (key, DigestAlgorithm.Sha1, null), "Sign");
// SignAndEncrypt
Assert.Throws<ArgumentNullException> (() => ctx.SignAndEncrypt ((MailboxAddress) null, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, mailboxes, stream), "SignAndEncrypt");
Assert.Throws<ArgumentNullException> (() => ctx.SignAndEncrypt ((PgpSecretKey) null, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, pubkeys, stream), "SignAndEncrypt");
Assert.Throws<ArgumentNullException> (() => ctx.SignAndEncrypt (mailboxes[0], DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, (MailboxAddress[]) null, stream), "SignAndEncrypt");
Assert.Throws<ArgumentNullException> (() => ctx.SignAndEncrypt (key, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, (PgpPublicKey[]) null, stream), "SignAndEncrypt");
Assert.Throws<ArgumentException> (() => ctx.SignAndEncrypt (mailboxes[0], DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, emptyMailboxes, stream), "SignAndEncrypt");
Assert.Throws<ArgumentException> (() => ctx.SignAndEncrypt (key, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, emptyPubkeys, stream), "SignAndEncrypt");
Assert.Throws<ArgumentNullException> (() => ctx.SignAndEncrypt (mailboxes[0], DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, mailboxes, null), "SignAndEncrypt");
Assert.Throws<ArgumentNullException> (() => ctx.SignAndEncrypt (key, DigestAlgorithm.Sha1, EncryptionAlgorithm.Cast5, pubkeys, null), "SignAndEncrypt");
Assert.Throws<ArgumentNullException> (() => ctx.SignAndEncrypt ((MailboxAddress) null, DigestAlgorithm.Sha1, mailboxes, stream), "SignAndEncrypt");
Assert.Throws<ArgumentNullException> (() => ctx.SignAndEncrypt ((PgpSecretKey) null, DigestAlgorithm.Sha1, pubkeys, stream), "SignAndEncrypt");
Assert.Throws<ArgumentNullException> (() => ctx.SignAndEncrypt (mailboxes[0], DigestAlgorithm.Sha1, (MailboxAddress[]) null, stream), "SignAndEncrypt");
Assert.Throws<ArgumentNullException> (() => ctx.SignAndEncrypt (key, DigestAlgorithm.Sha1, (PgpPublicKey[]) null, stream), "SignAndEncrypt");
Assert.Throws<ArgumentException> (() => ctx.SignAndEncrypt (mailboxes[0], DigestAlgorithm.Sha1, emptyMailboxes, stream), "SignAndEncrypt");
Assert.Throws<ArgumentException> (() => ctx.SignAndEncrypt (key, DigestAlgorithm.Sha1, emptyPubkeys, stream), "SignAndEncrypt");
Assert.Throws<ArgumentNullException> (() => ctx.SignAndEncrypt (mailboxes[0], DigestAlgorithm.Sha1, mailboxes, null), "SignAndEncrypt");
Assert.Throws<ArgumentNullException> (() => ctx.SignAndEncrypt (key, DigestAlgorithm.Sha1, pubkeys, null), "SignAndEncrypt");
// Supports
Assert.Throws<ArgumentNullException> (() => ctx.Supports (null), "Supports");
// Verify
Assert.Throws<ArgumentNullException> (() => ctx.Verify (null, stream), "Verify");
Assert.Throws<ArgumentNullException> (() => ctx.Verify (stream, null), "Verify");
}
}