private void doTestTextSig(
PgpHashAlgorithm hashAlgorithm,
PgpKey pubKey,
PgpPrivateKey privKey,
byte[] data,
byte[] canonicalData,
int version = 4)
{
MemoryStream bOut = new MemoryStream();
var messageGenerator = new PgpMessageGenerator(bOut);
using (var signingGenerator = messageGenerator.CreateSigned(PgpSignatureType.CanonicalTextDocument, privKey, PgpHashAlgorithm.Sha1, version))
using (var literalStream = signingGenerator.CreateLiteral(PgpDataFormat.Text, "_CONSOLE", DateTime.UtcNow))
{
literalStream.Write(data);
literalStream.Write(canonicalData);
}
/*if (sig.CreationTime == DateTimeOffset.FromUnixTimeSeconds(0).DateTime)
* {
* Fail("creation time not set in v4 signature");
* }*/
verifySignature(bOut.ToArray(), hashAlgorithm, pubKey, canonicalData);
}
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));
}
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));
}
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 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");
}
}
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);
}
//[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 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 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));
}
private byte[] EncryptMessage(byte[] msg, bool withIntegrityPacket)
{
MemoryStream bOut = new MemoryStream();
using (var messageGenerator = new PgpMessageGenerator(bOut))
using (var encryptedGenerator = messageGenerator.CreateEncrypted(PgpSymmetricKeyAlgorithm.Cast5, withIntegrityPacket))
{
encryptedGenerator.AddMethod(pass, PgpHashAlgorithm.Sha1);
using (var compressedGenerator = encryptedGenerator.CreateCompressed(PgpCompressionAlgorithm.Zip))
using (var literalStream = compressedGenerator.CreateLiteral(PgpDataFormat.Binary, "_CONSOLE", TestDateTime))
literalStream.Write(msg);
}
return(bOut.ToArray());
}
public void GenerateTest(string type, string message)
{
PgpSecretKey pgpSecKey = ReadSecretKey(new MemoryStream(secretKey));
PgpPrivateKey pgpPrivKey = pgpSecKey.ExtractPrivateKey("");
MemoryStream bOut = new MemoryStream();
using (var messageGenerator = new PgpMessageGenerator(new ArmoredPacketWriter(bOut)))
using (var signedGenerator = messageGenerator.CreateSigned(PgpSignatureType.CanonicalTextDocument, pgpPrivKey, PgpHashAlgorithm.Sha256))
{
signedGenerator.HashedAttributes.SetSignerUserId(false, pgpSecKey.GetUserIds().First().UserId);
using (var literalStream = signedGenerator.CreateLiteral(PgpDataFormat.Text, "", DateTime.MinValue))
{
literalStream.Write(Encoding.UTF8.GetBytes(message));
}
}
byte[] bs = bOut.ToArray();
MessageTest(type, Encoding.ASCII.GetString(bs, 0, bs.Length));
}
//[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));
}
private void doTestSig(
PgpHashAlgorithm hashAlgorithm,
PgpKey pubKey,
PgpPrivateKey privKey,
int version = 4)
{
MemoryStream bOut = new MemoryStream();
var messageGenerator = new PgpMessageGenerator(bOut);
using (var signingGenerator = messageGenerator.CreateSigned(PgpSignatureType.BinaryDocument, privKey, hashAlgorithm, version))
using (var literalStream = signingGenerator.CreateLiteral(PgpDataFormat.Binary, "_CONSOLE", DateTime.UtcNow))
{
literalStream.Write(TEST_DATA);
literalStream.Write(TEST_DATA);
}
verifySignature(bOut.ToArray(), hashAlgorithm, pubKey, TEST_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);
}
