public void EmbeddedJpegTest()
{
PgpPublicKeyRing pgpPub = new PgpPublicKeyRing(testPubKey);
PgpSecretKeyRing pgpSec = new PgpSecretKeyRing(testPrivKey);
PgpPublicKey pubKey = pgpPub.GetPublicKey();
PgpUserAttributes vGen = new PgpUserAttributes();
vGen.JpegImageAttribute = jpegImage;
var certification = PgpCertification.GenerateUserCertification(
PgpSignatureType.PositiveCertification,
pubKey,
pgpSec.GetSecretKey().ExtractPrivateKey(pass),
vGen,
pubKey);
PgpPublicKey nKey = PgpPublicKey.AddCertification(pubKey, vGen, certification);
int count = 0;
foreach (PgpUser user in nKey.GetUserAttributes())
{
Assert.AreEqual(1, user.SelfCertifications.Count);
Assert.IsTrue(user.SelfCertifications[0].Verify());
count++;
}
Assert.AreEqual(1, count);
nKey = PgpPublicKey.RemoveCertification(nKey, vGen);
Assert.IsFalse(nKey.GetUserAttributes().Any());
}
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);
}
public void PerformTest()
{
//
// RSA tests
//
PgpSecretKeyRing pgpPriv = new PgpSecretKeyRing(rsaKeyRing);
PgpSecretKey secretKey = pgpPriv.GetSecretKey();
PgpPrivateKey pgpPrivKey = secretKey.ExtractPrivateKey(rsaPass);
//
// certifications
//
var revocation = PgpCertification.GenerateKeyRevocation(secretKey, pgpPrivKey, secretKey);
Assert.IsTrue(revocation.Verify(secretKey));
Assert.IsTrue(revocation.Verify());
PgpSecretKeyRing pgpDSAPriv = new PgpSecretKeyRing(dsaKeyRing);
PgpSecretKey secretDSAKey = pgpDSAPriv.GetSecretKey();
PgpPrivateKey pgpPrivDSAKey = secretDSAKey.ExtractPrivateKey(dsaPass);
var hashedAttributes = new PgpSignatureAttributes();
hashedAttributes.SetSignatureExpirationTime(false, TEST_EXPIRATION_TIME);
hashedAttributes.SetSignerUserId(true, TEST_USER_ID);
hashedAttributes.SetPreferredCompressionAlgorithms(false, PREFERRED_COMPRESSION_ALGORITHMS);
hashedAttributes.SetPreferredHashAlgorithms(false, PREFERRED_HASH_ALGORITHMS);
hashedAttributes.SetPreferredSymmetricAlgorithms(false, PREFERRED_SYMMETRIC_ALGORITHMS);
var subkeyBinding = PgpCertification.GenerateSubkeyBinding(
secretDSAKey,
pgpPrivDSAKey,
secretKey,
hashedAttributes);
Assert.IsTrue(subkeyBinding.Verify(secretDSAKey));
PgpSignatureAttributes hashedPcks = subkeyBinding.HashedAttributes;
PgpSignatureAttributes unhashedPcks = subkeyBinding.UnhashedAttributes;
Assert.AreEqual(TEST_USER_ID, hashedPcks.SignerUserId);
Assert.AreEqual(TEST_EXPIRATION_TIME, hashedPcks.SignatureExpirationTime);
Assert.AreEqual(secretDSAKey.KeyId, unhashedPcks.IssuerKeyId);
preferredAlgorithmCheck("compression", PREFERRED_COMPRESSION_ALGORITHMS, hashedPcks.PreferredCompressionAlgorithms);
preferredAlgorithmCheck("hash", PREFERRED_HASH_ALGORITHMS, hashedPcks.PreferredHashAlgorithms);
preferredAlgorithmCheck("symmetric", PREFERRED_SYMMETRIC_ALGORITHMS, hashedPcks.PreferredSymmetricAlgorithms);
/*SignatureSubpacketTag[] criticalHashed = hashedPcks.GetCriticalTags();
*
* if (criticalHashed.Length != 1)
* {
* Fail("wrong number of critical packets found.");
* }
*
* if (criticalHashed[0] != SignatureSubpacketTag.SignerUserId)
* {
* Fail("wrong critical packet found in tag list.");
* }*/
//
// no packets passed
//
subkeyBinding = PgpCertification.GenerateSubkeyBinding(
secretDSAKey,
pgpPrivDSAKey,
secretKey);
Assert.IsTrue(subkeyBinding.Verify(secretDSAKey));
hashedPcks = subkeyBinding.HashedAttributes;
Assert.IsTrue(hashedPcks.SignatureCreationTime.HasValue);
unhashedPcks = subkeyBinding.UnhashedAttributes;
Assert.IsTrue(unhashedPcks.IssuerKeyId.HasValue);
/*try
* {
* sig.VerifyRevocation(secretKey.PublicKey);
*
* Fail("failed to detect non-key signature.");
* }
* catch (InvalidOperationException)
* {
* // expected
* }*/
//
// override hash packets
//
DateTime creationTime = new DateTime(1973, 7, 27);
hashedAttributes = new PgpSignatureAttributes();
hashedAttributes.SetSignatureCreationTime(false, creationTime);
subkeyBinding = PgpCertification.GenerateSubkeyBinding(
secretDSAKey,
pgpPrivDSAKey,
secretKey,
hashedAttributes);
Assert.IsTrue(subkeyBinding.Verify(secretDSAKey));
hashedPcks = subkeyBinding.HashedAttributes;
Assert.IsTrue(hashedPcks.SignatureCreationTime.HasValue);
Assert.AreEqual(creationTime, hashedPcks.SignatureCreationTime);
preferredAlgorithmCheck("compression", null, hashedPcks.PreferredCompressionAlgorithms);
preferredAlgorithmCheck("hash", null, hashedPcks.PreferredHashAlgorithms);
preferredAlgorithmCheck("symmetric", null, hashedPcks.PreferredSymmetricAlgorithms);
Assert.AreEqual(null, hashedPcks.KeyExpirationTime);
Assert.AreEqual(null, hashedPcks.SignatureExpirationTime);
Assert.AreEqual(null, hashedPcks.SignerUserId);
unhashedPcks = subkeyBinding.UnhashedAttributes;
Assert.IsTrue(unhashedPcks.IssuerKeyId.HasValue);
//
// general signatures
//
doTestSig(PgpHashAlgorithm.Sha256, secretKey, pgpPrivKey);
doTestSig(PgpHashAlgorithm.Sha384, secretKey, pgpPrivKey);
doTestSig(PgpHashAlgorithm.Sha512, secretKey, pgpPrivKey);
doTestSig(PgpHashAlgorithm.Sha1, secretKey, pgpPrivKey, version: 3);
doTestTextSig(PgpHashAlgorithm.Sha1, secretKey, pgpPrivKey, TEST_DATA_WITH_CRLF, TEST_DATA_WITH_CRLF);
doTestTextSig(PgpHashAlgorithm.Sha1, secretKey, pgpPrivKey, TEST_DATA, TEST_DATA_WITH_CRLF);
doTestTextSig(PgpHashAlgorithm.Sha1, secretKey, pgpPrivKey, TEST_DATA_WITH_CRLF, TEST_DATA_WITH_CRLF, version: 3);
doTestTextSig(PgpHashAlgorithm.Sha1, secretKey, pgpPrivKey, TEST_DATA, TEST_DATA_WITH_CRLF, version: 3);
//
// DSA Tests
//
pgpPriv = new PgpSecretKeyRing(dsaKeyRing);
secretKey = pgpPriv.GetSecretKey();
pgpPrivKey = secretKey.ExtractPrivateKey(dsaPass);
doTestSig(PgpHashAlgorithm.Sha1, secretKey, pgpPrivKey);
doTestSig(PgpHashAlgorithm.Sha1, secretKey, pgpPrivKey, version: 3);
doTestTextSig(PgpHashAlgorithm.Sha1, secretKey, pgpPrivKey, TEST_DATA_WITH_CRLF, TEST_DATA_WITH_CRLF);
doTestTextSig(PgpHashAlgorithm.Sha1, secretKey, pgpPrivKey, TEST_DATA, TEST_DATA_WITH_CRLF);
doTestTextSig(PgpHashAlgorithm.Sha1, secretKey, pgpPrivKey, TEST_DATA_WITH_CRLF, TEST_DATA_WITH_CRLF, version: 3);
doTestTextSig(PgpHashAlgorithm.Sha1, secretKey, pgpPrivKey, TEST_DATA, TEST_DATA_WITH_CRLF, version: 3);
// special cases
//
doTestMissingSubpackets(nullPacketsSubKeyBinding);
//doTestMissingSubpackets(generateV3BinarySig(pgpPrivKey, HashAlgorithmTag.Sha1));
// keyflags
//doTestKeyFlagsValues();
// TODO Seems to depend on some other functionality that's yet to be ported
//doTestUserAttributeEncoding();
}
