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); }