private void MixedTest(
PgpPrivateKey pgpPrivKey,
PgpKey pgpPubKey)
{
byte[] text = Encoding.ASCII.GetBytes("hello world!\n");
MemoryStream bcOut = new MemoryStream();
var messageGenerator = new PgpMessageGenerator(bcOut);
using (var encryptedGenerator = messageGenerator.CreateEncrypted(PgpSymmetricKeyAlgorithm.Aes128, withIntegrityPacket: true))
{
encryptedGenerator.AddMethod(pgpPubKey);
encryptedGenerator.AddMethod("password", PgpHashAlgorithm.Sha1);
using (var literalStream = encryptedGenerator.CreateLiteral(PgpDataFormat.Binary, "_CONSOLE", DateTime.UtcNow))
{
literalStream.Write(text);
}
}
byte[] encData = bcOut.ToArray();
// Asymmetric
var encryptedMessage = (PgpEncryptedMessage)PgpMessage.ReadMessage(encData);
var literalMessage = (PgpLiteralMessage)encryptedMessage.DecryptMessage(pgpPrivKey);
CheckLiteralData(literalMessage, text);
// PBE
encryptedMessage = (PgpEncryptedMessage)PgpMessage.ReadMessage(encData);
literalMessage = (PgpLiteralMessage)encryptedMessage.DecryptMessage("password");
CheckLiteralData(literalMessage, text);
}
private void PerformTestSig(
PgpHashAlgorithm hashAlgorithm,
PgpKey pubKey,
PgpPrivateKey privKey)
{
const string data = "hello world!";
byte[] dataBytes = Encoding.ASCII.GetBytes(data);
DateTime testDateTime = new DateTime(1973, 7, 27);
MemoryStream bOut = new MemoryStream();
var messageGenerator = new PgpMessageGenerator(bOut);
using (var compressedGenerator = messageGenerator.CreateCompressed(PgpCompressionAlgorithm.Zip))
using (var signingGenerator = compressedGenerator.CreateSigned(PgpSignatureType.BinaryDocument, privKey, hashAlgorithm))
using (var literalStream = signingGenerator.CreateLiteral(PgpDataFormat.Binary, "_CONSOLE", testDateTime))
{
literalStream.Write(dataBytes);
}
// Verify generated signature
bOut.Position = 0;
var compressedMessage = (PgpCompressedMessage)PgpMessage.ReadMessage(bOut);
var signedMessage = (PgpSignedMessage)compressedMessage.ReadMessage();
var literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage();
Assert.AreEqual(testDateTime, literalMessage.ModificationTime);
literalMessage.GetStream().CopyTo(Stream.Null);
Assert.IsTrue(signedMessage.Verify(pubKey));
}
private void EncryptDecryptTest(ECDiffieHellman ecdh)
{
byte[] text = Encoding.ASCII.GetBytes("hello world!");
PgpKeyPair ecdhKeyPair = new PgpKeyPair(ecdh, DateTime.UtcNow);
// Encrypt text
MemoryStream cbOut = new MemoryStream();
var messageGenerator = new PgpMessageGenerator(cbOut);
using (var encryptedGenerator = messageGenerator.CreateEncrypted(PgpSymmetricKeyAlgorithm.Cast5))
{
encryptedGenerator.AddMethod(ecdhKeyPair.PublicKey);
using (var literalStream = encryptedGenerator.CreateLiteral(PgpDataFormat.Utf8, "_CONSOLE", DateTime.UtcNow))
literalStream.Write(text);
}
// Read it back
cbOut.Position = 0;
var encryptedMessage = (PgpEncryptedMessage)PgpMessage.ReadMessage(cbOut);
var literalMessage = (PgpLiteralMessage)encryptedMessage.DecryptMessage(ecdhKeyPair.PrivateKey);
var bytes = Streams.ReadAll(literalMessage.GetStream());
Assert.AreEqual(text, bytes);
}
public void ReadBackTest(bool oldFormat)
{
Random rand = new Random();
byte[] buf = new byte[MAX];
byte[] buf2 = new byte[MAX];
rand.NextBytes(buf);
for (int i = 1; i != MAX; i++)
{
using MemoryStream bOut = new MemoryStream();
var messageGenerator = new PgpMessageGenerator(new PacketWriter(bOut, oldFormat));
using (var outputStream = messageGenerator.CreateLiteral(PgpDataFormat.Binary, "_CONSOLE", DateTime.UtcNow))
outputStream.Write(buf, 0, i);
bOut.Position = 0;
var literalMessage = (PgpLiteralMessage)PgpMessage.ReadMessage(bOut);
Array.Clear(buf2, 0, i);
int bytesRead = literalMessage.GetStream().Read(buf2.AsSpan(0, i));
Assert.AreEqual(i, bytesRead);
Assert.IsTrue(buf2.AsSpan(0, i).SequenceEqual(buf.AsSpan(0, i)), "failed readback test");
}
}
//[TestCase("DSA-2048-224.sec", "DSA-2048-224.pub", PgpHashAlgorithm.Sha256)]
//[TestCase("DSA-2048-224.sec", "DSA-2048-224.pub", PgpHashAlgorithm.Sha512)]
public void GenerateTest(string privateKeyFile, string publicKeyFile, PgpHashAlgorithm digest)
{
PgpSecretKeyRing secRing = loadSecretKey(privateKeyFile);
PgpPublicKeyRing pubRing = loadPublicKey(publicKeyFile);
string data = "hello world!";
byte[] dataBytes = Encoding.ASCII.GetBytes(data);
MemoryStream bOut = new MemoryStream();
DateTime testDate = new DateTime((DateTime.UtcNow.Ticks / TimeSpan.TicksPerSecond) * TimeSpan.TicksPerSecond);
var messageGenerator = new PgpMessageGenerator(bOut);
using (var signingGenerator = messageGenerator.CreateSigned(PgpSignatureType.BinaryDocument, secRing.GetSecretKey().ExtractPrivateKey("test"), digest))
using (var literalStream = signingGenerator.CreateLiteral(PgpDataFormat.Binary, "_CONSOLE", testDate))
{
literalStream.Write(dataBytes);
}
bOut.Position = 0;
var signedMessage = (PgpSignedMessage)PgpMessage.ReadMessage(bOut);
Assert.AreEqual(digest, signedMessage.HashAlgorithm);
Assert.AreEqual(PgpPublicKeyAlgorithm.Dsa, signedMessage.KeyAlgorithm);
var literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage();
Assert.AreEqual(testDate, literalMessage.ModificationTime);
literalMessage.GetStream().CopyTo(Stream.Null);
Assert.IsTrue(signedMessage.Verify(pubRing.GetPublicKey()));
}
public void SignatureGenerateAndVerify()
{
var pgpPub = new PgpPublicKeyRing(testPubKeyRing);
var pubKey = pgpPub.GetPublicKey();
var sKey = new PgpSecretKeyRing(testPrivKeyRing);
var secretKey = sKey.GetSecretKey();
var privKey = secretKey.ExtractPrivateKey(pass);
// Generate signature
MemoryStream bOut = new MemoryStream();
DateTime testDateTime = new DateTime(1973, 7, 27);
var messageGenerator = new PgpMessageGenerator(bOut);
using (var compressedGenerator = messageGenerator.CreateCompressed(PgpCompressionAlgorithm.Zip))
using (var signingGenerator = compressedGenerator.CreateSigned(PgpSignatureType.BinaryDocument, privKey, PgpHashAlgorithm.Sha1))
using (var literalStream = signingGenerator.CreateLiteral(PgpDataFormat.Binary, "_CONSOLE", testDateTime))
literalStream.Write(text);
// Verify generated signature
bOut.Position = 0;
var compressedMessage = (PgpCompressedMessage)PgpMessage.ReadMessage(bOut);
var signedMessage = (PgpSignedMessage)compressedMessage.ReadMessage();
var literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage();
Assert.AreEqual(testDateTime, literalMessage.ModificationTime);
literalMessage.GetStream().CopyTo(Stream.Null);
Assert.IsTrue(signedMessage.Verify(pubKey));
}
private void verifySignature(
byte[] encodedSig,
PgpHashAlgorithm hashAlgorithm,
PgpKey pubKey,
byte[] original,
bool checkTime = false)
{
var now = DateTime.UtcNow;
var signedMessage = (PgpSignedMessage)PgpMessage.ReadMessage(encodedSig);
var literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage();
literalMessage.GetStream().CopyTo(Stream.Null);
Assert.IsTrue(signedMessage.Verify(pubKey, out DateTime creationTime));
Assert.IsTrue(!checkTime || Math.Abs((creationTime - now).TotalMinutes) < 10);
Assert.AreEqual(pubKey.KeyId, signedMessage.KeyId);
/*
* sig.InitVerify(pubKey);
*
* sig.Update(original);
* sig.Update(original);
*
* if (!sig.Verify())
* {
* Fail("Failed generated signature check against original data");
* }*/
}
public void NestedSignatures()
{
var keyPairOuter = new PgpKeyPair(DSA.Create(512), DateTime.UtcNow);
var keyPairInner = new PgpKeyPair(DSA.Create(512), DateTime.UtcNow);
byte[] msg = Encoding.ASCII.GetBytes("hello world!");
var encodedStream = new MemoryStream();
var messageGenerator = new PgpMessageGenerator(encodedStream);
using (var signedGeneratorOuter = messageGenerator.CreateSigned(PgpSignatureType.BinaryDocument, keyPairOuter.PrivateKey, PgpHashAlgorithm.Sha256))
using (var signedGeneratorInner = signedGeneratorOuter.CreateSigned(PgpSignatureType.BinaryDocument, keyPairInner.PrivateKey, PgpHashAlgorithm.Sha1))
using (var literalStream = signedGeneratorInner.CreateLiteral(PgpDataFormat.Binary, "", DateTime.UtcNow))
{
literalStream.Write(msg);
}
encodedStream.Position = 0;
var signedMessageOuter = (PgpSignedMessage)PgpMessage.ReadMessage(encodedStream);
var signedMessageInner = (PgpSignedMessage)signedMessageOuter.ReadMessage();
var literalMessage = (PgpLiteralMessage)signedMessageInner.ReadMessage();
// Skip over literal data
literalMessage.GetStream().CopyTo(Stream.Null);
// NOTE: The order is significant
Assert.IsTrue(signedMessageInner.Verify(keyPairInner.PublicKey));
Assert.IsTrue(signedMessageOuter.Verify(keyPairOuter.PublicKey));
}
public void EncryptDecryptX25519KeysTest()
{
PgpPublicKeyRing publicKeyRing = new PgpPublicKeyRing(testX25519PubKey);
PgpSecretKeyRing secretKeyRing = new PgpSecretKeyRing(testX25519PrivKey);
PgpSecretKey secretKey = secretKeyRing.GetSecretKey(0x6c37367cd2f455c5);
byte[] text = Encoding.ASCII.GetBytes("hello world!");
// Encrypt text
MemoryStream cbOut = new MemoryStream();
var messageGenerator = new PgpMessageGenerator(cbOut);
using (var encryptedGenerator = messageGenerator.CreateEncrypted(PgpSymmetricKeyAlgorithm.Cast5))
{
encryptedGenerator.AddMethod(publicKeyRing.GetPublicKey(0x6c37367cd2f455c5));
using (var literalStream = encryptedGenerator.CreateLiteral(PgpDataFormat.Utf8, "_CONSOLE", DateTime.UtcNow))
literalStream.Write(text);
}
// Read it back
cbOut.Position = 0;
var encryptedMessage = (PgpEncryptedMessage)PgpMessage.ReadMessage(cbOut);
var literalMessage = (PgpLiteralMessage)encryptedMessage.DecryptMessage(secretKey.ExtractPrivateKey("test"));
var bytes = Streams.ReadAll(literalMessage.GetStream());
Assert.AreEqual(text, bytes);
}
public void GenerateMessage()
{
string data = "hello world!";
byte[] dataBytes = Encoding.ASCII.GetBytes(data);
DateTime testDateTime = new DateTime(1973, 7, 27);
MemoryStream bOut = new MemoryStream();
var messageGenerator = new PgpMessageGenerator(bOut);
using (var compressedGenerator = messageGenerator.CreateCompressed(PgpCompressionAlgorithm.Zip))
using (var signingGenerator = compressedGenerator.CreateSigned(PgpSignatureType.BinaryDocument, pgpPrivKey, PgpHashAlgorithm.Sha1))
{
signingGenerator.HashedAttributes.SetSignerUserId(true, secretKey.GetUserIds().First().UserId);
using (var literalStream = signingGenerator.CreateLiteral(PgpDataFormat.Binary, "_CONSOLE", testDateTime))
{
literalStream.Write(dataBytes);
}
}
bOut.Position = 0;
var compressedMessage = (PgpCompressedMessage)PgpMessage.ReadMessage(bOut);
var signedMessage = (PgpSignedMessage)compressedMessage.ReadMessage();
var literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage();
literalMessage.GetStream().CopyTo(Stream.Null);
Assert.IsTrue(signedMessage.Verify(pubKey));
}
public void NestedSignatures()
{
var keyPairOuter = new PgpKeyPair(DSA.Create(512), DateTime.UtcNow);
var keyPairInner = new PgpKeyPair(DSA.Create(512), DateTime.UtcNow);
byte[] msg = Encoding.ASCII.GetBytes("hello world!");
var encodedStream = new MemoryStream();
using (var messageGenerator = new PgpMessageGenerator(new ArmoredPacketWriter(encodedStream, useClearText: true)))
using (var signedGeneratorOuter = messageGenerator.CreateSigned(PgpSignatureType.CanonicalTextDocument, keyPairOuter.PrivateKey, PgpHashAlgorithm.Sha256))
using (var signedGeneratorInner = signedGeneratorOuter.CreateSigned(PgpSignatureType.CanonicalTextDocument, keyPairInner.PrivateKey, PgpHashAlgorithm.Sha1))
using (var literalStream = signedGeneratorInner.CreateLiteral(PgpDataFormat.Binary, "", DateTime.UtcNow))
{
literalStream.Write(msg);
}
encodedStream = new MemoryStream(encodedStream.ToArray(), false);
var signedMessageOuter = (PgpSignedMessage)PgpMessage.ReadMessage(new ArmoredPacketReader(encodedStream));
var signedMessageInner = (PgpSignedMessage)signedMessageOuter.ReadMessage();
var literalMessage = (PgpLiteralMessage)signedMessageInner.ReadMessage();
// Skip over literal data
var bytes = Streams.ReadAll(literalMessage.GetStream());
Assert.AreEqual(msg, bytes);
// NOTE: The order is significant
Assert.IsTrue(signedMessageInner.Verify(keyPairInner.PublicKey));
Assert.IsTrue(signedMessageOuter.Verify(keyPairOuter.PublicKey));
}
public void SampleMessage()
{
var encryptedMessage = (PgpEncryptedMessage)PgpMessage.ReadMessage(testPBEAsym);
var literalMessage = (PgpLiteralMessage)encryptedMessage.DecryptMessage("password");
byte[] bytes = Streams.ReadAll(literalMessage.GetStream());
Assert.AreEqual(Encoding.ASCII.GetBytes("Sat 10.02.07\r\n"), bytes);
}
public void VerifyMessage()
{
var compressedMessage = (PgpCompressedMessage)PgpMessage.ReadMessage(sig1);
var signedMessage = (PgpSignedMessage)compressedMessage.ReadMessage();
var literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage();
literalMessage.GetStream().CopyTo(Stream.Null);
Assert.IsTrue(signedMessage.Verify(pubKey));
}
private void TestDecrypt(PgpSecretKeyRing secretKeyRing)
{
var encryptedMessage = (PgpEncryptedMessage)PgpMessage.ReadMessage(testMessage);
var secretKey = secretKeyRing.GetSecretKey(encryptedMessage.KeyIds.First());
//Assert.NotNull(secretKey);
/*var literalMessage = (PgpLiteralMessage)encryptedMessage.DecryptMessage(secretKey.ExtractPrivateKey("test".ToCharArray()));
* var bytes = Streams.ReadAll(literalMessage.GetStream());
* Assert.AreEqual(text, bytes);*/
}
//[TestCase("DSA-7680-384.pub", "dsa-7680-384-sign.gpg")]
//[TestCase("DSA-15360-512.pub", "dsa-15360-512-sign.gpg")]
public void SignatureVerifyTest(string publicKeyFile, string sigFile)
{
PgpPublicKeyRing publicKey = loadPublicKey(publicKeyFile);
var compressedMessage = (PgpCompressedMessage)PgpMessage.ReadMessage(loadSig(sigFile));
var signedMessage = (PgpSignedMessage)compressedMessage.ReadMessage();
var literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage();
literalMessage.GetStream().CopyTo(Stream.Null);
Assert.IsTrue(signedMessage.Verify(publicKey.GetPublicKey()));
}
public void IncorrectDashEncoding()
{
var reader = new ArmoredPacketReader(new MemoryStream(Encoding.ASCII.GetBytes(incorrectDashEncoding)));
var signedMessage = (PgpSignedMessage)PgpMessage.ReadMessage(reader);
var literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage();
var bytes = Streams.ReadAll(literalMessage.GetStream());
// NOTE: We normalize to CRLF line ending. If we change that then this test needs to be adjusted.
Assert.AreEqual(incorrectDashMessage, Encoding.ASCII.GetString(bytes));
// NOTE: The signature is bogus but that's not what we test here
}
public void DecryptMessage()
{
var secretKey = FindSuitableKeyForEncryption();
var privateKey = secretKey.ExtractPrivateKey(pass);
var encryptedMessage = (PgpEncryptedMessage)PgpMessage.ReadMessage(encMessage);
var compressedMessage = (PgpCompressedMessage)encryptedMessage.DecryptMessage(privateKey);
var literalMessage = (PgpLiteralMessage)compressedMessage.ReadMessage();
Assert.AreEqual("test.txt", literalMessage.FileName);
byte[] bytes = Streams.ReadAll(literalMessage.GetStream());
Assert.AreEqual(text, bytes);
}
public void GnuPGCrossCheck()
{
var secretKeyRing = new PgpSecretKeyRing(testX25519PrivKey);
var secretKey = secretKeyRing.GetSecretKey(0x6c37367cd2f455c5);
var pgpPrivKey = secretKey.ExtractPrivateKey("test");
var encryptedMessage = (PgpEncryptedMessage)PgpMessage.ReadMessage(testX25519Message);
var compressedMessage = (PgpCompressedMessage)encryptedMessage.DecryptMessage(pgpPrivKey);
var literalMessage = (PgpLiteralMessage)compressedMessage.ReadMessage();
byte[] bytes = Streams.ReadAll(literalMessage.GetStream());
Assert.AreEqual(Encoding.ASCII.GetBytes("hello world!"), bytes);
}
public void DoTestEncMessage()
{
var encryptedMessage = (PgpEncryptedMessage)PgpMessage.ReadMessage(encMessage);
var publicKeyRing = new PgpPublicKeyRing(testPubKey);
var publicKey = publicKeyRing.GetPublicKey(encryptedMessage.KeyIds.First());
var secretKey = PgpSecretKey.ParseSecretKeyFromSExpr(new MemoryStream(sExprKeySub, false), "test", publicKey);
var privateKey = secretKey.ExtractPrivateKey("");
var compressedMessage = (PgpCompressedMessage)encryptedMessage.DecryptMessage(privateKey);
var literalMessage = (PgpLiteralMessage)compressedMessage.ReadMessage();
Assert.AreEqual("test.txt", literalMessage.FileName);
}
private byte[] DecryptMessage(byte[] message)
{
var encryptedMessage = (PgpEncryptedMessage)PgpMessage.ReadMessage(message);
var compressedMessage = (PgpCompressedMessage)encryptedMessage.DecryptMessage(pass);
var literalMessage = (PgpLiteralMessage)compressedMessage.ReadMessage();
Assert.IsTrue(literalMessage.FileName.Equals("test.txt") || literalMessage.FileName.Equals("_CONSOLE"));
Assert.AreEqual(TestDateTime, literalMessage.ModificationTime);
byte[] bytes = Streams.ReadAll(literalMessage.GetStream());
if (encryptedMessage.IsIntegrityProtected)
{
Assert.IsTrue(encryptedMessage.Verify());
}
return(bytes);
}
public void DecryptAndVerifyMessage()
{
var pgpPub = new PgpPublicKeyRing(testPubKeyRing);
var pubKey = pgpPub.GetPublicKey();
var secretKey = FindSuitableKeyForEncryption();
var privateKey = secretKey.ExtractPrivateKey(pass);
var encryptedMessage = (PgpEncryptedMessage)PgpMessage.ReadMessage(signedAndEncMessage);
var compressedMessage = (PgpCompressedMessage)encryptedMessage.DecryptMessage(privateKey);
var signedMessage = (PgpSignedMessage)compressedMessage.ReadMessage();
var literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage();
Assert.AreEqual("test.txt", literalMessage.FileName);
var bytes = Streams.ReadAll(literalMessage.GetStream());
Assert.AreEqual(text, bytes);
Assert.IsTrue(signedMessage.Verify(pubKey));
}
public void MessageTest(string type, string message)
{
/*ArmoredInputStream aIn = new ArmoredInputStream(
* new MemoryStream(Encoding.ASCII.GetBytes(message)));
*
* string[] headers = aIn.GetArmorHeaders();
*
* Assert.NotNull(headers);
* Assert.AreEqual(1, headers.Length);
*
* //
* // read the input, making sure we ingore the last newline.
* //
* MemoryStream bOut = new MemoryStream();
* int ch;
*
* while ((ch = aIn.ReadByte()) >= 0 && aIn.IsClearText())
* {
* bOut.WriteByte((byte)ch);
* }
*
* PgpPublicKeyRingBundle pgpRings = new PgpPublicKeyRingBundle(publicKey);
*
* PgpSignature sig = new PgpSignature(aIn);
*
* // FIXME: This belongs directly to the armor reader
* byte[] clearText = bOut.ToArray();
* int clearTextLength = clearText.Length;
* if (clearTextLength > 0 && clearText[clearTextLength - 1] == '\n')
* clearTextLength--;
* if (clearTextLength > 0 && clearText[clearTextLength - 1] == '\r')
* clearTextLength--;
*
* bool verified = sig.Verify(pgpRings.GetPublicKey(sig.KeyId), new MemoryStream(clearText, 0, clearTextLength, false), ignoreTrailingWhitespace: true);
* Assert.IsTrue(verified, "signature failed to verify m_in " + type);*/
PgpPublicKeyRingBundle pgpRings = new PgpPublicKeyRingBundle(publicKey);
var reader = new ArmoredPacketReader(new MemoryStream(Encoding.ASCII.GetBytes(message)));
var signedMessage = (PgpSignedMessage)PgpMessage.ReadMessage(reader);
var literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage();
var bytes = Streams.ReadAll(literalMessage.GetStream());
Assert.IsTrue(signedMessage.Verify(pgpRings.GetPublicKey(signedMessage.KeyId)));
reader.VerifyCrc();
}
//[TestCase(PgpCompressionAlgorithm.BZip2)]
public void TestCompression(PgpCompressionAlgorithm type)
{
using MemoryStream bOut = new MemoryStream();
// Compress data
var messageGenerator = new PgpMessageGenerator(bOut);
using (var compressedGenerator = messageGenerator.CreateCompressed(type))
using (var literalStream = compressedGenerator.CreateLiteral(PgpDataFormat.Binary, "", DateTime.UtcNow))
literalStream.Write(Data);
// Read it back
bOut.Position = 0;
var compressedMessage = (PgpCompressedMessage)PgpMessage.ReadMessage(bOut);
var literalMessage = (PgpLiteralMessage)compressedMessage.ReadMessage();
byte[] bytes = Streams.ReadAll(literalMessage.GetStream());
Assert.That(bytes, Is.EqualTo(Data));
}
public static void SignAndVerifyTestMessage(PgpPrivateKey privateKey, PgpKey publicKey)
{
byte[] msg = Encoding.ASCII.GetBytes("hello world!");
var encodedStream = new MemoryStream();
var messageGenerator = new PgpMessageGenerator(encodedStream);
using (var signedGenerator = messageGenerator.CreateSigned(PgpSignatureType.BinaryDocument, privateKey, PgpHashAlgorithm.Sha256))
using (var literalStream = signedGenerator.CreateLiteral(PgpDataFormat.Binary, "", DateTime.UtcNow))
{
literalStream.Write(msg);
}
encodedStream.Position = 0;
var signedMessage = (PgpSignedMessage)PgpMessage.ReadMessage(encodedStream);
var literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage();
// Skip over literal data
literalMessage.GetStream().CopyTo(Stream.Null);
Assert.IsTrue(signedMessage.Verify(publicKey));
}
public void EncryptMessage()
{
var secretKey = FindSuitableKeyForEncryption();
var privateKey = secretKey.ExtractPrivateKey(pass);
MemoryStream cbOut = new MemoryStream();
var messageGenerator = new PgpMessageGenerator(cbOut);
using (var encryptedGenerator = messageGenerator.CreateEncrypted(PgpSymmetricKeyAlgorithm.TripleDes))
{
encryptedGenerator.AddMethod(secretKey);
using (var literalStream = encryptedGenerator.CreateLiteral(PgpDataFormat.Utf8, "", DateTime.UtcNow))
literalStream.Write(text);
}
cbOut.Position = 0;
var encryptedMessage = (PgpEncryptedMessage)PgpMessage.ReadMessage(cbOut);
var literalMessage = (PgpLiteralMessage)encryptedMessage.DecryptMessage(privateKey);
var bytes = Streams.ReadAll(literalMessage.GetStream());
Assert.AreEqual(text, bytes);
}
public void PerformTest()
{
//
// Read the public key
//
PgpPublicKeyRing pgpPub = new PgpPublicKeyRing(testPubKey);
var firstUserId = pgpPub.GetPublicKey().GetUserIds().FirstOrDefault();
Assert.NotNull(firstUserId);
Assert.AreEqual(1, firstUserId.SelfCertifications.Count);
Assert.IsTrue(firstUserId.SelfCertifications[0].Verify());
//
// write a public key
//
MemoryStream bOut = new MemoryStream();
pgpPub.Encode(bOut);
Assert.AreEqual(testPubKey, bOut.ToArray());
//
// Read the public key
//
PgpPublicKeyRing pgpPubV3 = new PgpPublicKeyRing(testPubKeyV3);
//
// write a V3 public key
//
bOut = new MemoryStream();
pgpPubV3.Encode(bOut);
//
// Read a v3 private key
//
var passP = "FIXCITY_QA";
{
PgpSecretKeyRing pgpPriv2 = new PgpSecretKeyRing(testPrivKeyV3);
PgpSecretKey pgpPrivSecretKey = pgpPriv2.GetSecretKey();
PgpPrivateKey pgpPrivKey2 = pgpPrivSecretKey.ExtractPrivateKey(passP);
//
// write a v3 private key
//
bOut = new MemoryStream();
pgpPriv2.Encode(bOut);
byte[] result = bOut.ToArray();
Assert.AreEqual(testPrivKeyV3, result);
}
//
// Read the private key
//
PgpSecretKeyRing pgpPriv = new PgpSecretKeyRing(testPrivKey);
PgpPrivateKey pgpPrivKey = pgpPriv.GetSecretKey().ExtractPrivateKey(pass);
//
// write a private key
//
bOut = new MemoryStream();
pgpPriv.Encode(bOut);
Assert.AreEqual(testPrivKey, bOut.ToArray());
//
// test encryption
//
/*var c = pubKey;
*
* // c.Init(Cipher.ENCRYPT_MODE, pubKey);
*
* byte[] inBytes = Encoding.ASCII.GetBytes("hello world");
* byte[] outBytes = c.DoFinal(inBytes);
*
* // c.Init(Cipher.DECRYPT_MODE, pgpPrivKey.GetKey());
* c.Init(false, pgpPrivKey.Key);
*
* outBytes = c.DoFinal(outBytes);
*
* if (!Arrays.AreEqual(inBytes, outBytes))
* {
* Fail("decryption failed.");
* }*/
//
// test signature message
//
var compressedMessage = (PgpCompressedMessage)PgpMessage.ReadMessage(sig1);
var signedMessage = (PgpSignedMessage)compressedMessage.ReadMessage();
var literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage();
literalMessage.GetStream().CopyTo(Stream.Null);
Assert.True(signedMessage.Verify(pgpPub.GetPublicKey(signedMessage.KeyId)));
//
// encrypted message - read subkey
//
pgpPriv = new PgpSecretKeyRing(subKey);
//
// encrypted message
//
byte[] text = Encoding.ASCII.GetBytes("hello world!\n");
var encryptedMessage = (PgpEncryptedMessage)PgpMessage.ReadMessage(enc1);
var encKeyId = encryptedMessage.KeyIds.First();
pgpPrivKey = pgpPriv.GetSecretKey(encKeyId).ExtractPrivateKey(pass);
compressedMessage = (PgpCompressedMessage)encryptedMessage.DecryptMessage(pgpPrivKey);
literalMessage = (PgpLiteralMessage)compressedMessage.ReadMessage();
Assert.AreEqual("test.txt", literalMessage.FileName);
byte[] bytes = Streams.ReadAll(literalMessage.GetStream());
Assert.AreEqual(text, bytes);
//
// encrypt - short message
//
byte[] shortText = { (byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o' };
MemoryStream cbOut = new MemoryStream();
var messageGenerator = new PgpMessageGenerator(cbOut);
using (var encryptedGenerator = messageGenerator.CreateEncrypted(PgpSymmetricKeyAlgorithm.Cast5))
{
encryptedGenerator.AddMethod(pgpPriv.GetSecretKey(encKeyId));
using (var literalStream = encryptedGenerator.CreateLiteral(PgpDataFormat.Binary, "", DateTime.UtcNow))
{
literalStream.Write(shortText);
}
}
cbOut.Position = 0;
encryptedMessage = (PgpEncryptedMessage)PgpMessage.ReadMessage(cbOut);
pgpPrivKey = pgpPriv.GetSecretKey(encryptedMessage.KeyIds.First()).ExtractPrivateKey(pass);
//Assert.AreEqual(SymmetricKeyAlgorithmTag.Cast5, ((PgpPublicKeyEncryptedData)encryptedMessage.Methods[0]).GetSymmetricAlgorithm(pgpPrivKey));
literalMessage = (PgpLiteralMessage)encryptedMessage.DecryptMessage(pgpPrivKey);
Assert.AreEqual("", literalMessage.FileName);
bytes = Streams.ReadAll(literalMessage.GetStream());
Assert.AreEqual(shortText, bytes);
//
// encrypt
//
cbOut = new MemoryStream();
messageGenerator = new PgpMessageGenerator(cbOut);
using (var encryptedGenerator = messageGenerator.CreateEncrypted(PgpSymmetricKeyAlgorithm.Cast5))
{
encryptedGenerator.AddMethod(pgpPriv.GetSecretKey(encKeyId));
using (var literalStream = encryptedGenerator.CreateLiteral(PgpDataFormat.Binary, "", DateTime.UtcNow))
{
literalStream.Write(text);
}
}
cbOut.Position = 0;
encryptedMessage = (PgpEncryptedMessage)PgpMessage.ReadMessage(cbOut);
pgpPrivKey = pgpPriv.GetSecretKey(encryptedMessage.KeyIds.First()).ExtractPrivateKey(pass);
literalMessage = (PgpLiteralMessage)encryptedMessage.DecryptMessage(pgpPrivKey);
bytes = Streams.ReadAll(literalMessage.GetStream());
Assert.AreEqual(text, bytes);
//
// read public key with sub key.
//
/*pgpF = new PgpObjectFactory(subPubKey);
* object o;
* while ((o = pgpFact.NextPgpObject()) != null)
* {
* // TODO Should something be tested here?
* // Console.WriteLine(o);
* }*/
//
// key pair generation - CAST5 encryption
//
var passPhrase = "hello";
var rsa = RSA.Create(1024);
var keyRingGenerator = new PgpKeyRingGenerator(rsa, "fred", passPhrase);
var secretKey = keyRingGenerator.GenerateSecretKeyRing().GetSecretKey();
PgpPublicKey key = new PgpPublicKey(secretKey);
firstUserId = key.GetUserIds().FirstOrDefault();
Assert.NotNull(firstUserId);
Assert.AreEqual(1, firstUserId.SelfCertifications.Count);
Assert.IsTrue(firstUserId.SelfCertifications[0].Verify());
pgpPrivKey = secretKey.ExtractPrivateKey(passPhrase);
key = PgpPublicKey.RemoveCertification(key, firstUserId, firstUserId.SelfCertifications[0]);
Assert.NotNull(key);
byte[] keyEnc = key.GetEncoded();
key = PgpPublicKey.AddCertification(key, firstUserId.UserId, firstUserId.SelfCertifications[0]);
keyEnc = key.GetEncoded();
var revocation = PgpCertification.GenerateKeyRevocation(
secretKey,
secretKey.ExtractPrivateKey(passPhrase),
key);
key = PgpPublicKey.AddCertification(key, revocation);
keyEnc = key.GetEncoded();
PgpPublicKeyRing tmpRing = new PgpPublicKeyRing(keyEnc);
key = tmpRing.GetPublicKey();
revocation = key.KeyCertifications.Where(c => c.SignatureType == PgpSignatureType.KeyRevocation).FirstOrDefault();
Assert.NotNull(revocation);
Assert.IsTrue(revocation.Verify(key));
//
// use of PgpKeyPair
//
PgpKeyPair pgpKp = new PgpKeyPair(rsa, DateTime.UtcNow);
PgpPublicKey k1 = pgpKp.PublicKey;
PgpPrivateKey k2 = pgpKp.PrivateKey;
k1.GetEncoded();
MixedTest(k2, k1);
//
// key pair generation - AES_256 encryption. -- XXX
//
//kp = kpg.GenerateKeyPair();
rsa = RSA.Create(1024);
keyRingGenerator = new PgpKeyRingGenerator(rsa, "fred", passPhrase /*, encAlgorithm: PgpSymmetricKeyAlgorithm.Aes256*/);
secretKey = keyRingGenerator.GenerateSecretKeyRing().GetSecretKey();
secretKey.ExtractPrivateKey(passPhrase);
secretKey.Encode(new MemoryStream());
//
// secret key password changing.
//
const string newPass = "******";
secretKey = PgpSecretKey.CopyWithNewPassword(secretKey, passPhrase, newPass);
secretKey.ExtractPrivateKey(newPass);
secretKey.Encode(new MemoryStream());
key = new PgpPublicKey(secretKey);
key.Encode(new MemoryStream());
firstUserId = key.GetUserIds().FirstOrDefault();
Assert.NotNull(firstUserId);
Assert.AreEqual(1, firstUserId.SelfCertifications.Count);
Assert.IsTrue(firstUserId.SelfCertifications[0].Verify());
pgpPrivKey = secretKey.ExtractPrivateKey(newPass);
//
// signature generation
//
const string data = "hello world!";
byte[] dataBytes = Encoding.ASCII.GetBytes(data);
DateTime testDateTime = new DateTime(1973, 7, 27);
bOut = new MemoryStream();
messageGenerator = new PgpMessageGenerator(bOut);
using (var compressedGenerator = messageGenerator.CreateCompressed(PgpCompressionAlgorithm.Zip))
using (var signingGenerator = compressedGenerator.CreateSigned(PgpSignatureType.BinaryDocument, pgpPrivKey, PgpHashAlgorithm.Sha1))
using (var literalStream = signingGenerator.CreateLiteral(PgpDataFormat.Binary, "_CONSOLE", testDateTime))
{
literalStream.Write(dataBytes);
}
//
// verify generated signature
//
bOut.Position = 0;
compressedMessage = (PgpCompressedMessage)PgpMessage.ReadMessage(bOut);
signedMessage = (PgpSignedMessage)compressedMessage.ReadMessage();
literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage();
Assert.AreEqual(testDateTime, literalMessage.ModificationTime);
literalMessage.GetStream().CopyTo(Stream.Null);
Assert.IsTrue(signedMessage.Verify(secretKey));
//
// signature generation - version 3
//
bOut = new MemoryStream();
messageGenerator = new PgpMessageGenerator(bOut);
using (var compressedGenerator = messageGenerator.CreateCompressed(PgpCompressionAlgorithm.Zip))
using (var signingGenerator = compressedGenerator.CreateSigned(PgpSignatureType.BinaryDocument, pgpPrivKey, PgpHashAlgorithm.Sha1, version: 3))
using (var literalStream = signingGenerator.CreateLiteral(PgpDataFormat.Binary, "_CONSOLE", testDateTime))
{
literalStream.Write(dataBytes);
}
//
// verify generated signature
//
bOut.Position = 0;
compressedMessage = (PgpCompressedMessage)PgpMessage.ReadMessage(bOut);
signedMessage = (PgpSignedMessage)compressedMessage.ReadMessage();
literalMessage = (PgpLiteralMessage)signedMessage.ReadMessage();
Assert.AreEqual(testDateTime, literalMessage.ModificationTime);
literalMessage.GetStream().CopyTo(Stream.Null);
Assert.IsTrue(signedMessage.Verify(secretKey));
//
// extract PGP 8 private key
//
pgpPriv = new PgpSecretKeyRing(pgp8Key);
secretKey = pgpPriv.GetSecretKey();
pgpPrivKey = secretKey.ExtractPrivateKey(pgp8Pass);
//
// other sig tests
//
PerformTestSig(PgpHashAlgorithm.Sha256, secretKey, pgpPrivKey);
PerformTestSig(PgpHashAlgorithm.Sha384, secretKey, pgpPrivKey);
PerformTestSig(PgpHashAlgorithm.Sha512, secretKey, pgpPrivKey);
}
/// <summary>Delegate method invoked by rcReadMessage.</summary>
protected void ExecuteReadMessage()
{
byte[] abMessageBytes;
string sErrorMessage, sMatchedKeyMessage;
PgpFile MessageFile;
PgpMessage NewMessage = null;
BytesAndTextUtility BytesAndText;
if (isExecuteReadMessage)
{
MessageFile = new PgpFile();
abMessageBytes = MessageFile.GetBytes(_sInputMessageFilePath, false);
switch (MessageFile.eStatus)
{
case PgpArmor.nStatus.CrcError: sErrorMessage = string.Format(sFileCrcError, _sInputKeyFilePath); break;
case PgpArmor.nStatus.ParseError: sErrorMessage = string.Format(sFileParseError, _sInputKeyFilePath); break;
case PgpArmor.nStatus.Undefined: sErrorMessage = string.Format(sFileError, _sInputKeyFilePath); break;
default: sErrorMessage = string.Empty; break;
}
if (string.IsNullOrEmpty(sErrorMessage))
{
NewMessage = new PgpMessage(abMessageBytes, _Cryptography);
switch (NewMessage.eStatus)
{
case PgpMessage.nStatus.ParseErrorRaw: sErrorMessage = string.Format(sFileParseError, _sInputMessageFilePath); break;
case PgpMessage.nStatus.ParseErrorSub: sErrorMessage = string.Format(sFileParseErrorSub, _sInputMessageFilePath); break;
case PgpMessage.nStatus.Undefined: sErrorMessage = string.Format(sFileError, _sInputMessageFilePath); break;
default: sErrorMessage = string.Empty; break;
}
}
if (string.IsNullOrEmpty(sErrorMessage))
{
if (NewMessage != null) // just to be sure, but this should always be true
{
NewMessage.MatchPublicKeys(_ltTokens);
BytesAndText = new BytesAndTextUtility();
foreach (PgpPublicKeyEncryptedKey WrappedKey in NewMessage.ltPublicKeyEncryptedKeys)
{
if (WrappedKey.MatchedPublicKey == null)
{
BytesAndText.abBytes = WrappedKey.abPublicKeyId;
sMatchedKeyMessage = string.Format(sPublicKeyNotMatched, BytesAndText.sHexadecimalBytes);
}
else
sMatchedKeyMessage = string.Format(sPublicKeyMatched, WrappedKey.sUserId);
_blMessages.Add(new Property(DateTime.Now, sMatchedKeyMessage));
}
}
}
else
{
_blMessages.Add(new Property(DateTime.Now, sErrorMessage));
eMenuTab = nMenuTab.Progress;
}
}
}
private void MarkerTest(byte[] message)
{
var encryptedMessage = PgpMessage.ReadMessage(message);
Assert.IsTrue(encryptedMessage is PgpEncryptedMessage);
}
