Improve tests and add signatures to result

pgpainless-core/src/main/java/org/pgpainless/decryption_verification/DecryptionBuilder.java

@@ -21,6 +21,7 @@ import java.io.InputStream;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;
+import java.util.function.Predicate;
 
 import org.bouncycastle.openpgp.PGPException;
 import org.bouncycastle.openpgp.PGPPublicKeyRing;
@@ -74,15 +75,17 @@ public class DecryptionBuilder implements DecryptionBuilderInterface {
         @Override
         public HandleMissingPublicKeys verifyWith(@Nonnull Set<OpenPgpV4Fingerprint> trustedKeyIds,
                                                   @Nonnull PGPPublicKeyRingCollection publicKeyRingCollection) {
+            Set<PGPPublicKeyRing> publicKeyRings = keyRingCollectionToSet(publicKeyRingCollection);
+            publicKeyRings.removeIf(p -> !trustedKeyIds.contains(new OpenPgpV4Fingerprint(p)));
+            return verifyWith(publicKeyRings);
+        }
+
+        private Set<PGPPublicKeyRing> keyRingCollectionToSet(PGPPublicKeyRingCollection publicKeyRingCollection) {
             Set<PGPPublicKeyRing> publicKeyRings = new HashSet<>();
             for (Iterator<PGPPublicKeyRing> i = publicKeyRingCollection.getKeyRings(); i.hasNext(); ) {
-                PGPPublicKeyRing p = i.next();
+                publicKeyRings.add(i.next());
-                OpenPgpV4Fingerprint fingerprint = new OpenPgpV4Fingerprint(p);
-                if (trustedKeyIds.contains(fingerprint)) {
-                    publicKeyRings.add(p);
-                }
             }
-            return verifyWith(publicKeyRings);
+            return publicKeyRings;
         }
 
         @Override

pgpainless-core/src/main/java/org/pgpainless/decryption_verification/DecryptionStreamFactory.java

@@ -198,8 +198,12 @@ public final class DecryptionStreamFactory {
             throw new PGPException("Verification failed - No OnePassSignatures found");
         }
 
-        while (iterator.hasNext()) {
+        processOnePassSignatures(iterator);
-            PGPOnePassSignature signature = iterator.next();
+    }
+
+    private void processOnePassSignatures(Iterator<PGPOnePassSignature> signatures) throws PGPException {
+        while (signatures.hasNext()) {
+            PGPOnePassSignature signature = signatures.next();
             final long keyId = signature.getKeyID();
             resultBuilder.addUnverifiedSignatureKeyId(keyId);
 

pgpainless-core/src/main/java/org/pgpainless/decryption_verification/OpenPgpMetadata.java

@@ -17,10 +17,13 @@ package org.pgpainless.decryption_verification;
 
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 import org.bouncycastle.openpgp.PGPPublicKey;
 import org.bouncycastle.openpgp.PGPPublicKeyRing;
+import org.bouncycastle.openpgp.PGPSignature;
 import org.pgpainless.algorithm.CompressionAlgorithm;
 import org.pgpainless.algorithm.SymmetricKeyAlgorithm;
 import org.pgpainless.key.OpenPgpV4Fingerprint;
@@ -29,7 +32,9 @@ public class OpenPgpMetadata {
 
     private final Set<Long> recipientKeyIds;
     private final OpenPgpV4Fingerprint decryptionFingerprint;
-    private final Set<Long> unverifiedSignatureKeyIds;
+    private final Set<PGPSignature> signatures;
+    private final Set<Long> signatureKeyIds;
+    private final Map<OpenPgpV4Fingerprint, PGPSignature> verifiedSignatures;
     private final Set<OpenPgpV4Fingerprint> verifiedSignaturesFingerprints;
 
     private final SymmetricKeyAlgorithm symmetricKeyAlgorithm;
@@ -41,7 +46,9 @@ public class OpenPgpMetadata {
                            SymmetricKeyAlgorithm symmetricKeyAlgorithm,
                            CompressionAlgorithm algorithm,
                            boolean integrityProtected,
-                           Set<Long> unverifiedSignatureKeyIds,
+                           Set<PGPSignature> signatures,
+                           Set<Long> signatureKeyIds,
+                           Map<OpenPgpV4Fingerprint, PGPSignature> verifiedSignatures,
                            Set<OpenPgpV4Fingerprint> verifiedSignaturesFingerprints) {
 
         this.recipientKeyIds = Collections.unmodifiableSet(recipientKeyIds);
@@ -49,7 +56,9 @@ public class OpenPgpMetadata {
         this.symmetricKeyAlgorithm = symmetricKeyAlgorithm;
         this.compressionAlgorithm = algorithm;
         this.integrityProtected = integrityProtected;
-        this.unverifiedSignatureKeyIds = Collections.unmodifiableSet(unverifiedSignatureKeyIds);
+        this.signatures = Collections.unmodifiableSet(signatures);
+        this.signatureKeyIds = Collections.unmodifiableSet(signatureKeyIds);
+        this.verifiedSignatures = Collections.unmodifiableMap(verifiedSignatures);
         this.verifiedSignaturesFingerprints = Collections.unmodifiableSet(verifiedSignaturesFingerprints);
     }
 
@@ -77,15 +86,23 @@ public class OpenPgpMetadata {
         return integrityProtected;
     }
 
-    public Set<Long> getAllSignatureKeyFingerprints() {
+    public Set<PGPSignature> getSignatures() {
-        return unverifiedSignatureKeyIds;
+        return signatures;
+    }
+
+    public Set<Long> getSignatureKeyIDs() {
+        return signatureKeyIds;
     }
 
     public boolean isSigned() {
-        return !unverifiedSignatureKeyIds.isEmpty();
+        return !signatureKeyIds.isEmpty();
     }
 
-    public Set<OpenPgpV4Fingerprint> getVerifiedSignaturesFingerprints() {
+    public Map<OpenPgpV4Fingerprint, PGPSignature> getVerifiedSignatures() {
+        return verifiedSignatures;
+    }
+
+    public Set<OpenPgpV4Fingerprint> getVerifiedSignatureKeyFingerprints() {
         return verifiedSignaturesFingerprints;
     }
 
@@ -107,16 +124,18 @@ public class OpenPgpMetadata {
         return verifiedSignaturesFingerprints.contains(fingerprint);
     }
 
-    static Builder getBuilder() {
+    public static Builder getBuilder() {
         return new Builder();
     }
 
-    static class Builder {
+    public static class Builder {
 
         private final Set<Long> recipientFingerprints = new HashSet<>();
         private OpenPgpV4Fingerprint decryptionFingerprint;
-        private final Set<Long> unverifiedSignatureKeyIds = new HashSet<>();
+        private final Set<PGPSignature> signatures = new HashSet<>();
-        private final Set<OpenPgpV4Fingerprint> verifiedSignatureFingerprints = new HashSet<>();
+        private final Set<Long> signatureKeyIds = new HashSet<>();
+        private final Map<OpenPgpV4Fingerprint, PGPSignature> verifiedSignatures = new ConcurrentHashMap<>();
+        private final Set<OpenPgpV4Fingerprint> verifiedSignatureKeyFingerprints = new HashSet<>();
         private SymmetricKeyAlgorithm symmetricKeyAlgorithm = SymmetricKeyAlgorithm.NULL;
         private CompressionAlgorithm compressionAlgorithm = CompressionAlgorithm.UNCOMPRESSED;
         private boolean integrityProtected = false;
@@ -136,13 +155,23 @@ public class OpenPgpMetadata {
             return this;
         }
 
+        public Builder addSignature(PGPSignature signature) {
+            signatures.add(signature);
+            return this;
+        }
+
         public Builder addUnverifiedSignatureKeyId(Long keyId) {
-            this.unverifiedSignatureKeyIds.add(keyId);
+            this.signatureKeyIds.add(keyId);
+            return this;
+        }
+
+        public Builder putVerifiedSignature(OpenPgpV4Fingerprint fingerprint, PGPSignature verifiedSignature) {
+            verifiedSignatures.put(fingerprint, verifiedSignature);
             return this;
         }
 
         public Builder addVerifiedSignatureFingerprint(OpenPgpV4Fingerprint fingerprint) {
-            this.verifiedSignatureFingerprints.add(fingerprint);
+            this.verifiedSignatureKeyFingerprints.add(fingerprint);
             return this;
         }
 
@@ -157,7 +186,10 @@ public class OpenPgpMetadata {
         }
 
         public OpenPgpMetadata build() {
-            return new OpenPgpMetadata(recipientFingerprints, decryptionFingerprint, symmetricKeyAlgorithm, compressionAlgorithm, integrityProtected, unverifiedSignatureKeyIds, verifiedSignatureFingerprints);
+            return new OpenPgpMetadata(recipientFingerprints, decryptionFingerprint,
+                    symmetricKeyAlgorithm, compressionAlgorithm, integrityProtected,
+                    signatures, signatureKeyIds,
+                    verifiedSignatures, verifiedSignatureKeyFingerprints);
         }
     }
 }

pgpainless-core/src/main/java/org/pgpainless/decryption_verification/SignatureVerifyingInputStream.java

@@ -96,6 +96,7 @@ public class SignatureVerifyingInputStream extends FilterInputStream {
             }
 
             for (PGPSignature signature : signatureList) {
+                resultBuilder.addSignature(signature);
                 OpenPgpV4Fingerprint fingerprint = null;
                 for (OpenPgpV4Fingerprint f : onePassSignatures.keySet()) {
                     if (f.getKeyId() == signature.getKeyID()) {
@@ -114,6 +115,7 @@ public class SignatureVerifyingInputStream extends FilterInputStream {
                     throw new SignatureException("Bad Signature of key " + signature.getKeyID());
                 } else {
                     LOGGER.log(LEVEL, "Verified signature of key " + Long.toHexString(signature.getKeyID()));
+                    resultBuilder.putVerifiedSignature(fingerprint, signature);
                     resultBuilder.addVerifiedSignatureFingerprint(fingerprint);
                 }
             }

pgpainless-core/src/main/java/org/pgpainless/encryption_signing/EncryptionStream.java

@@ -57,7 +57,7 @@ public final class EncryptionStream extends OutputStream {
 
     private static final int BUFFER_SIZE = 1 << 8;
 
-    private final OpenPgpMetadata result;
+    private final OpenPgpMetadata.Builder resultBuilder = OpenPgpMetadata.getBuilder();
 
     private List<PGPSignatureGenerator> signatureGenerators = new ArrayList<>();
     private boolean closed = false;
@@ -147,21 +147,11 @@ public final class EncryptionStream extends OutputStream {
                 PGPLiteralData.BINARY, PGPLiteralData.CONSOLE, new Date(), new byte[BUFFER_SIZE]);
 
         // Prepare result
-        Set<Long> recipientKeyIds = new HashSet<>();
         for (PGPPublicKey recipient : encryptionKeys) {
-            recipientKeyIds.add(recipient.getKeyID());
+            resultBuilder.addRecipientKeyId(recipient.getKeyID());
         }
-
+        resultBuilder.setSymmetricKeyAlgorithm(symmetricKeyAlgorithm);
-        Set<Long> signingKeyIds = new HashSet<>();
+        resultBuilder.setCompressionAlgorithm(compressionAlgorithm);
-        for (PGPPrivateKey signer : signingKeys) {
-            signingKeyIds.add(signer.getKeyID());
-        }
-
-
-        this.result = new OpenPgpMetadata(recipientKeyIds,
-                null, symmetricKeyAlgorithm,
-                compressionAlgorithm, true,
-                signingKeyIds, Collections.emptySet());
     }
 
     @Override
@@ -205,7 +195,10 @@ public final class EncryptionStream extends OutputStream {
             // Signing
             for (PGPSignatureGenerator signatureGenerator : signatureGenerators) {
                 try {
-                    signatureGenerator.generate().encode(basicCompressionStream);
+                    PGPSignature signature = signatureGenerator.generate();
+                    signature.encode(basicCompressionStream);
+                    resultBuilder.addSignature(signature);
+                    resultBuilder.addUnverifiedSignatureKeyId(signature.getKeyID());
                 } catch (PGPException e) {
                     throw new IOException(e);
                 }
@@ -230,6 +223,9 @@ public final class EncryptionStream extends OutputStream {
     }
 
     public OpenPgpMetadata getResult() {
-        return result;
+        if (!closed) {
+            throw new IllegalStateException("EncryptionStream must be closed before accessing the Result.");
+        }
+        return resultBuilder.build();
     }
 }

pgpainless-core/src/test/java/org/pgpainless/EncryptDecryptTest.java

@@ -142,10 +142,18 @@ public class EncryptDecryptTest extends AbstractPGPainlessTest {
                 .signWith(keyDecryptor, senderSec)
                 .noArmor();
 
+        Streams.pipeAll(new ByteArrayInputStream(secretMessage), encryptor);
+        encryptor.close();
+        byte[] encryptedSecretMessage = envelope.toByteArray();
+
+        LOGGER.log(Level.INFO, "Sender: " + PublicKeyAlgorithm.fromId(senderPub.getPublicKey().getAlgorithm()) +
+        " Receiver: " + PublicKeyAlgorithm.fromId(recipientPub.getPublicKey().getAlgorithm()) +
+        " Encrypted Length: " + encryptedSecretMessage.length);
+
         OpenPgpMetadata encryptionResult = encryptor.getResult();
 
-        assertFalse(encryptionResult.getAllSignatureKeyFingerprints().isEmpty());
+        assertFalse(encryptionResult.getSignatureKeyIDs().isEmpty());
-        for (long keyId : encryptionResult.getAllSignatureKeyFingerprints()) {
+        for (long keyId : encryptionResult.getSignatureKeyIDs()) {
             assertTrue(BCUtil.keyRingContainsKeyWithId(senderPub, keyId));
         }
 
@@ -156,14 +164,6 @@ public class EncryptDecryptTest extends AbstractPGPainlessTest {
 
         assertEquals(SymmetricKeyAlgorithm.AES_256, encryptionResult.getSymmetricKeyAlgorithm());
 
-        Streams.pipeAll(new ByteArrayInputStream(secretMessage), encryptor);
-        encryptor.close();
-        byte[] encryptedSecretMessage = envelope.toByteArray();
-
-        LOGGER.log(Level.INFO, "Sender: " + PublicKeyAlgorithm.fromId(senderPub.getPublicKey().getAlgorithm()) +
-        " Receiver: " + PublicKeyAlgorithm.fromId(recipientPub.getPublicKey().getAlgorithm()) +
-        " Encrypted Length: " + encryptedSecretMessage.length);
-
         // Juliet trieth to comprehend Romeos words
 
         ByteArrayInputStream envelopeIn = new ByteArrayInputStream(encryptedSecretMessage);

pgpainless-core/src/test/java/org/pgpainless/TestKeys.java

@@ -26,6 +26,7 @@ import org.bouncycastle.openpgp.PGPSecretKeyRingCollection;
 import org.bouncycastle.openpgp.PGPUtil;
 import org.bouncycastle.openpgp.operator.KeyFingerPrintCalculator;
 import org.bouncycastle.openpgp.operator.bc.BcKeyFingerprintCalculator;
+import org.pgpainless.key.OpenPgpV4Fingerprint;
 
 public class TestKeys extends AbstractPGPainlessTest {
 
@@ -42,6 +43,8 @@ public class TestKeys extends AbstractPGPainlessTest {
 
     public static final String JULIET_UID = "xmpp:juliet@capulet.lit";
     public static final long JULIET_KEY_ID = -5425419407118114754L;
+    public static final String JULIET_FINGERPRINT_STRING = "1D018C772DF8C5EF86A1DCC9B4B509CB5936E03E";
+    public static final OpenPgpV4Fingerprint JULIET_FINGERPRINT = new OpenPgpV4Fingerprint(JULIET_FINGERPRINT_STRING);
 
     /**
      * Public key of xmpp:juliet@capulet.lit.
@@ -104,6 +107,8 @@ public class TestKeys extends AbstractPGPainlessTest {
 
     public static final String ROMEO_UID = "xmpp:romeo@montague.lit";
     public static final long ROMEO_KEY_ID = 334147643349279223L;
+    public static final String ROMEO_FINGERPRINT_STRING = "35D299D08A2F7D80230B095D04A32182E05E21F7";
+    public static final OpenPgpV4Fingerprint ROMEO_FINGERPRINT = new OpenPgpV4Fingerprint(ROMEO_FINGERPRINT_STRING);
 
     /**
      * Public key of xmpp:romeo@montague.lit.
@@ -233,35 +238,24 @@ public class TestKeys extends AbstractPGPainlessTest {
     /**
      * Test Message signed with {@link #JULIET_SEC} and encrypted for {@link #JULIET_PUB}.
      */
-    public static final String TEST_MESSAGE_01 = "-----BEGIN PGP MESSAGE-----\n" +
+    public static final String MSG_SIGN_CRYPT_JULIET_JULIET =
+            "-----BEGIN PGP MESSAGE-----\n" +
             "\n" +
-            "hQGMAwAAAAAAAAAAAQwAoJtfpcBPCwhUzzHuVIcBzBLyfIWT/EJ527neb46lN56S\n" +
+            "hQEMA7S1CctZNuA+AQf/SMX7NTOaAynogTVKE9BMWSj5fgK+7sFrCKiLYbungJEu\n" +
-            "B05BTIRudIeCsPYz81jwiFi/k0MBecRfozZ1xCPByo8ohSvRgzEHEkCNgObQ1bz0\n" +
+            "RA/fYqaJNfZN3GARqsHcGaGihQDXr0thnx71+37NhV2cHVeFkeMsHmJf/74lRrHk\n" +
-            "iB+Xb76OEzFOCPUebTaVscLNf8ak/GSzaW7jDc+5vnvDf7cV0x26pe4odpS/U5Tr\n" +
+            "QBXDv2ez0LxUwhkE15/d/NTlT/fm8Vzce6rsm7/ZvzQIaWYyDCnpHXyftJplKd+Y\n" +
-            "cO3wb/47K+sJ1cxJmPtcD41O02xu3QisQKPrimM0Kue6ziGeKyw1RkSowv9U47TK\n" +
+            "PW0PaoFRq1wlZKcNUp/1a3xxpbSpvsYkiAxpdGIwvgUIb85KpFN0EWD3aH8C65it\n" +
-            "wppPCHOTli2Nf+gZizF1oyQZzPGst4fjujygcIoajplfW9nZvxsbmYRSLSdmV9m6\n" +
+            "Iphuv8CEaKqcO0hchQr7kYclEM0qcmm1ukw8+niTV8TFqAzNZh7DF/IWaMeamgfA\n" +
-            "k1jQbPDUhVs0gstH92C6hPpoBWxoxkHcwz8gy36nCyB6cYGyq3oN1UnGU4afPyD5\n" +
+            "P6pAB1oy7YoWUPQgy7mczD76WzPgJjy8y0hxFd9/f9LA2gEZZ/ClAiX0gHglc4oa\n" +
-            "SmmEjELBd2i2Ll/DYk2x06SnKZMQuWrSCZzWgl/9HsPo5ydVb97OjuEpWtW9xDMA\n" +
+            "j5iKIICvtTQzKYL29mW66BUistqMavz6eqHRggoADCBzfgOwuoAQxZMyj33bmrWm\n" +
-            "KlYPNWEq+b+akOEstNraC3pfVKvypz6ZzaMAS1gWWNYg8dlwBJOUVMSo7iLaUQkK\n" +
+            "831LMu+4sZyx6ihLvZ0YcDKMd7C7pQJ3Ucxt+DJUlTmo6KxzGdwGhq7cUcXwCuer\n" +
-            "yp4uH1DlsyVu1atCUc8thQIMAwAAAAAAAAAAAQ/5AdiZ/sG859Y/rGR7U/8MzGg0\n" +
+            "3MoPIV5YQwXBMbYN9fXV+yQagquz0z7r5igE7AQ1d9SyLJoQ3IHXnsa0xcUVZrIs\n" +
-            "j3f2vrgDF/0NRRk5aqd1lb4CaZvrztcYqW3cEK7iF9rKwImZZiWIptjJ9Mz6f1Zl\n" +
+            "A59LdIXEeRk/Ctjqp34UdTsuUPzervPexY+kNQVSQ2VODhwM5IowzPZFGviPNJYa\n" +
-            "FbODObSVRZAcZqYGswEEfsQvpQFlwG6Qx48OaQaDPr147raFI3C3kEU9Nb2VBg8+\n" +
+            "nGt27c4rsQ3sSC/WkdUxdaVY2+m7JktfnklUyVyC5wE1Nw+bO3sni6FeoP/fVSVi\n" +
-            "MevJaXJft5PXwUTG2Qvfxqr/3hfGAwB4/zHwA8vFd1np3spryfrC9Dq8UXUoRXIS\n" +
+            "HmPy7vMj23cQcvcAnuUEd4Qua0lwVrN1MTUggfZOzcH4+9rgMn/uYRAwPH9hdLWQ\n" +
-            "xaFPiLEYt8rLef8f11OypEpmknIibu9jjJtuVZo+SjP6jgLHDwM7rqCZFITM2Qra\n" +
+            "vziQMH5qtJMyWy08m9hIxleoI3+zIGSbra15R+hdWwEaD9+Pak//0Q0thFMeNww7\n" +
-            "2iBCt8YVcIiTK137t+EfsdVN/KHiRbc++e9zUbGMEextbtNbdoFOU4dnKBm6Su8l\n" +
+            "Y8gK8CSbUHbUjefUIx0s+JjrDGtXG8xfl63MLBbU7yLLB4Vcx77Sxxi3yt5DTi0n\n" +
-            "Z5UerNbR8D7+xJKfAEabdi0qI7QFmhTZ/4H/22yrvoD9jMFSBXUTE9ENIX9Hfqom\n" +
+            "GmPGRU4LsOYbpPFy\n" +
-            "UdsHfuE+5PC0JjkZkhchDO1M7XBX++lBCFsq2abfdpmaX+roVX0iTGboxr5Ag1Cf\n" +
+            "=caif\n" +
-            "T2zWyRX/XKnvmdeGICV5qjy/ThuSWvAclazyFxWLamMztJq5BRpfAzKNQRDqlmKw\n" +
-            "eePtKW2EWUIjFQ5/UAM6Edu/K34ksFxb0w6YGLzQSskGr7gGAipLmpek6vcUSUA1\n" +
-            "oc9XJGdpx93GDRcqDjKDt/ej06VxG33/pW65ntf5QM/+LScGqaLhAHyEOsBzVIXY\n" +
-            "BONcadSgzkTrlbSMGAmFAQwDtLUJy1k24D4BB/0brqR0UN1LtO+Lc/vN6X/Um2CZ\n" +
-            "CM6MRhPnXP63Q9HHkGJ2S8zGWvQLwWL9Y14CFCgm6rACLBSIyPbihhC2OC8afhSy\n" +
-            "apGkdHtdghS2egs2U8qlJ2Y32IAG9CcUtNkRjxp+/RWSrmZeuL4l7DXCyH5lUadx\n" +
-            "5bPZhAHqW9408q2rQd9dBg2o7ciGXTJSKVahjuiB/O0gchOnbqnlYJbKbCkntXUo\n" +
-            "c7h4w1e8MutisSJorh7kbxgxUJSboZzEkiUfnoacPTz6bL+re9tmnpvlee70sIyM\n" +
-            "BiYRCyPw7Ice4R3XyWtsMTjT/wjZ//whMpWdy2drcJSyhh+GQMbekTVsNWod0lQB\n" +
-            "JTPUfti2VU7PMB3LjJA+l/T9iWPPx8lirnLhXOOerWKH9I5Wo4Kqv/47aJhfMO6+\n" +
-            "jmLekAOylq+9DizrslW/EUgQyjIbcWfmyMiV6E2RwbI93tE=\n" +
-            "=GAhR\n" +
             "-----END PGP MESSAGE-----";
 }

pgpainless-core/src/test/java/org/pgpainless/TestKeysTest.java

@@ -15,23 +15,27 @@
  */
 package org.pgpainless;
 
+import static junit.framework.TestCase.assertEquals;
 import static junit.framework.TestCase.assertTrue;
+import static org.junit.Assert.assertArrayEquals;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
-import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
 import java.util.Collections;
 
-import junit.framework.TestCase;
 import org.bouncycastle.openpgp.PGPException;
 import org.bouncycastle.openpgp.PGPPublicKeyRing;
 import org.bouncycastle.openpgp.PGPSecretKeyRing;
 import org.bouncycastle.openpgp.PGPSecretKeyRingCollection;
 import org.bouncycastle.util.io.Streams;
 import org.junit.Test;
+import org.pgpainless.algorithm.CompressionAlgorithm;
+import org.pgpainless.algorithm.SymmetricKeyAlgorithm;
 import org.pgpainless.decryption_verification.DecryptionStream;
+import org.pgpainless.decryption_verification.OpenPgpMetadata;
+import org.pgpainless.key.OpenPgpV4Fingerprint;
 import org.pgpainless.key.protection.UnprotectedKeysProtector;
 
 public class TestKeysTest extends AbstractPGPainlessTest {
@@ -45,14 +49,26 @@ public class TestKeysTest extends AbstractPGPainlessTest {
     }
 
     @Test
-    public void keyIdTest() {
+    public void julietKeyTest() {
-        TestCase.assertEquals(TestKeys.JULIET_KEY_ID, juliet.getSecretKey().getKeyID());
+        assertEquals(TestKeys.JULIET_KEY_ID, juliet.getSecretKey().getKeyID());
-        TestCase.assertEquals(TestKeys.ROMEO_KEY_ID, romeo.getSecretKey().getKeyID());
+        assertEquals(TestKeys.JULIET_FINGERPRINT, new OpenPgpV4Fingerprint(juliet));
+        assertEquals(TestKeys.JULIET_FINGERPRINT, new OpenPgpV4Fingerprint(juliet.getPublicKey()));
+        assertEquals(TestKeys.JULIET_FINGERPRINT, new OpenPgpV4Fingerprint(juliet.getSecretKey()));
+        assertEquals(TestKeys.JULIET_KEY_ID, TestKeys.JULIET_FINGERPRINT.getKeyId());
+    }
+
+    @Test
+    public void romeoKeyTest() {
+        assertEquals(TestKeys.ROMEO_KEY_ID, romeo.getSecretKey().getKeyID());
+        assertEquals(TestKeys.ROMEO_FINGERPRINT, new OpenPgpV4Fingerprint(romeo));
+        assertEquals(TestKeys.ROMEO_FINGERPRINT, new OpenPgpV4Fingerprint(romeo.getPublicKey()));
+        assertEquals(TestKeys.ROMEO_FINGERPRINT, new OpenPgpV4Fingerprint(romeo.getSecretKey()));
+        assertEquals(TestKeys.ROMEO_KEY_ID, TestKeys.ROMEO_FINGERPRINT.getKeyId());
     }
 
     @Test
     public void decryptVerifyTest() throws Exception {
-        String encryptedMessage = TestKeys.TEST_MESSAGE_01;
+        String encryptedMessage = TestKeys.MSG_SIGN_CRYPT_JULIET_JULIET;
 
         DecryptionStream decryptor = PGPainless.createDecryptor()
                 .onInputStream(new ByteArrayInputStream(encryptedMessage.getBytes()))
@@ -65,10 +81,23 @@ public class TestKeysTest extends AbstractPGPainlessTest {
         Streams.pipeAll(decryptor, toPlain);
         decryptor.close();
         toPlain.close();
+        OpenPgpMetadata metadata = decryptor.getResult();
 
-        byte[] expected = TestKeys.TEST_MESSAGE_01_PLAIN.getBytes(Charset.forName("UTF-8"));
+        byte[] expected = TestKeys.TEST_MESSAGE_01_PLAIN.getBytes(StandardCharsets.UTF_8);
         byte[] actual = toPlain.toByteArray();
 
-        assertTrue(Arrays.equals(expected, actual));
+        assertArrayEquals(expected, actual);
+
+        assertTrue(metadata.isIntegrityProtected());
+        assertTrue(metadata.isEncrypted());
+        assertTrue(metadata.isSigned());
+        assertTrue(metadata.isVerified());
+        assertEquals(CompressionAlgorithm.ZLIB, metadata.getCompressionAlgorithm());
+        assertEquals(SymmetricKeyAlgorithm.AES_256, metadata.getSymmetricKeyAlgorithm());
+        assertEquals(1, metadata.getSignatureKeyIDs().size());
+        assertEquals(1, metadata.getVerifiedSignatureKeyFingerprints().size());
+        assertTrue(metadata.containsVerifiedSignatureFrom(TestKeys.JULIET_FINGERPRINT));
+        assertEquals(TestKeys.JULIET_FINGERPRINT, metadata.getDecryptionFingerprint());
+
     }
 }