Merge branch 'main' of gitlab.cryptoworkshop.com:root/bc-java

Author: dghgit

pg/src/main/java/org/bouncycastle/bcpg/ArmoredOutputStream.java

@@ -612,6 +612,41 @@ public Builder addComment(String comment)
             return addHeader(COMMENT_HDR, comment);
         }
 
+        public Builder addEllipsizedComment(String comment)
+        {
+            int availableCommentCharsPerLine = 64 - (COMMENT_HDR.length() + 2); // ASCII armor width - header len
+            comment = comment.trim();
+
+            if (comment.length() > availableCommentCharsPerLine)
+            {
+                comment = comment.substring(0, availableCommentCharsPerLine - 1) + '…';
+            }
+            addComment(comment);
+            return this;
+        }
+
+        public Builder addSplitMultilineComment(String comment)
+        {
+            int availableCommentCharsPerLine = 64 - (COMMENT_HDR.length() + 2); // ASCII armor width - header len
+
+            comment = comment.trim();
+            for (String line : comment.split("\n"))
+            {
+                while (line.length() > availableCommentCharsPerLine)
+                {
+                        // split comment into multiple lines
+                    addComment(comment.substring(0, availableCommentCharsPerLine));
+                    line = line.substring(availableCommentCharsPerLine).trim();
+                }
+
+                if (!line.isEmpty())
+                {
+                    addComment(line);
+                }
+            }
+            return this;
+        }
+
         /**
          * Set and replace the given header value with a single-line header.
          * If the value is <pre>null</pre>, this method will remove the header entirely.

pg/src/main/java/org/bouncycastle/bcpg/PublicKeyUtils.java

@@ -32,7 +32,6 @@ public static boolean isSigningAlgorithm(int publicKeyAlgorithm)
 
 //    /**
 //     * Return true, if the public key algorithm that corresponds to the given ID is capable of encryption.
-//     *
 //     * @param publicKeyAlgorithm public key algorithm id
 //     * @return true if algorithm can encrypt
 //     */

pg/src/main/java/org/bouncycastle/bcpg/sig/PreferredAEADCiphersuites.java

@@ -30,6 +30,11 @@ public class PreferredAEADCiphersuites
      */
     private static final Combination AES_128_OCB = new Combination(SymmetricKeyAlgorithmTags.AES_128, AEADAlgorithmTags.OCB);
 
+    public static PreferredAEADCiphersuites DEFAULT()
+    {
+        return new PreferredAEADCiphersuites(false, new Combination[]{AES_128_OCB});
+    }
+
     /**
      * Create a new PreferredAEADAlgorithms signature subpacket from raw data.
      *

pg/src/main/java/org/bouncycastle/openpgp/IntegrityProtectedInputStream.java

@@ -0,0 +1,84 @@
+package org.bouncycastle.openpgp;
+
+import org.bouncycastle.bcpg.SymmetricEncIntegrityPacket;
+
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * {@link InputStream} that performs verification of integrity protection upon {@link #close()}.
+ */
+public class IntegrityProtectedInputStream
+        extends FilterInputStream
+{
+
+    private final PGPEncryptedData esk;
+
+    public IntegrityProtectedInputStream(InputStream in, PGPEncryptedData dataPacket)
+    {
+        super(in);
+        this.esk = dataPacket;
+    }
+
+    @Override
+    public int read()
+            throws IOException
+    {
+        int i = in.read();
+        if (i == -1)
+        {
+            close();
+        }
+        return i;
+    }
+
+    @Override
+    public int read(byte[] b)
+            throws IOException
+    {
+        int r = in.read(b);
+        if (r == -1)
+        {
+            close();
+        }
+        return r;
+    }
+
+    @Override
+    public int read(byte[] b, int off, int len)
+            throws IOException
+    {
+        int r = in.read(b, off, len);
+        if (r == -1)
+        {
+            close();
+        }
+        return r;
+    }
+
+    @Override
+    public void close()
+            throws IOException
+    {
+        super.close();
+        if (esk.getEncData() instanceof SymmetricEncIntegrityPacket)
+        {
+            SymmetricEncIntegrityPacket seipd = (SymmetricEncIntegrityPacket) esk.getEncData();
+            if (seipd.getVersion() == SymmetricEncIntegrityPacket.VERSION_1)
+            {
+                try
+                {
+                    if (!esk.verify())
+                    {
+                        throw new PGPException("Malformed integrity protected data.");
+                    }
+                }
+                catch (PGPException e)
+                {
+                    throw new IOException(e);
+                }
+            }
+        }
+    }
+}

pg/src/main/java/org/bouncycastle/openpgp/PGPEncryptedData.java

@@ -175,6 +175,11 @@ public boolean isIntegrityProtected()
         return (encData instanceof SymmetricEncIntegrityPacket);
     }
 
+    public InputStreamPacket getEncData()
+    {
+        return encData;
+    }
+
     /**
      * Checks whether the packet is protected using an AEAD algorithm.
      *

pg/src/main/java/org/bouncycastle/openpgp/PGPEncryptedDataGenerator.java

@@ -88,6 +88,7 @@ public class PGPEncryptedDataGenerator
     // If true, force generation of a session key, even if we only have a single password-based encryption method
     //  and could therefore use the S2K output as session key directly.
     private boolean forceSessionKey = true;
+    private SessionKeyExtractionCallback sessionKeyExtractionCallback = null;
 
     /**
      * Base constructor.
@@ -140,6 +141,10 @@ public void addMethod(PGPKeyEncryptionMethodGenerator method)
         methods.add(method);
     }
 
+    public void setSessionKeyExtractionCallback(SessionKeyExtractionCallback callback)
+    {
+        this.sessionKeyExtractionCallback = callback;
+    }
 
     /**
      * Create an OutputStream based on the configured methods.
@@ -213,6 +218,11 @@ else if (directS2K)
             messageKey = sessionKey;
         }
 
+        if (sessionKeyExtractionCallback != null)
+        {
+            sessionKeyExtractionCallback.extractSessionKey(new PGPSessionKey(defAlgorithm, sessionKey));
+        }
+
         PGPDataEncryptor dataEncryptor = dataEncryptorBuilder.build(messageKey);
         digestCalc = dataEncryptor.getIntegrityCalculator();
         BCPGHeaderObject encOut;
@@ -441,4 +451,9 @@ public void close()
             this.finish();
         }
     }
+
+    public interface SessionKeyExtractionCallback
+    {
+        void extractSessionKey(PGPSessionKey sessionKey);
+    }
 }

pg/src/main/java/org/bouncycastle/openpgp/PGPSignature.java

@@ -5,6 +5,7 @@
 import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.Date;
+import java.util.Iterator;
 import java.util.List;
 
 import org.bouncycastle.asn1.ASN1EncodableVector;
@@ -23,6 +24,8 @@
 import org.bouncycastle.bcpg.TrustPacket;
 import org.bouncycastle.bcpg.sig.IssuerFingerprint;
 import org.bouncycastle.bcpg.sig.IssuerKeyID;
+import org.bouncycastle.bcpg.sig.RevocationReason;
+import org.bouncycastle.bcpg.sig.RevocationReasonTags;
 import org.bouncycastle.math.ec.rfc8032.Ed25519;
 import org.bouncycastle.math.ec.rfc8032.Ed448;
 import org.bouncycastle.openpgp.operator.PGPContentVerifier;
@@ -635,11 +638,30 @@ public long getKeyID()
     public List<KeyIdentifier> getKeyIdentifiers()
     {
         List<KeyIdentifier> identifiers = new ArrayList<KeyIdentifier>();
-        identifiers.addAll(getHashedKeyIdentifiers());
-        identifiers.addAll(getUnhashedKeyIdentifiers());
+        if (getVersion() <= SignaturePacket.VERSION_3)
+        {
+            identifiers.add(new KeyIdentifier(getKeyID()));
+        }
+        else
+        {
+            identifiers.addAll(getHashedKeyIdentifiers());
+            identifiers.addAll(getUnhashedKeyIdentifiers());
+        }
         return identifiers;
     }
 
+    public boolean hasKeyIdentifier(KeyIdentifier identifier)
+    {
+        for (Iterator it = getKeyIdentifiers().iterator(); it.hasNext(); )
+        {
+            if (((KeyIdentifier)it.next()).matches(identifier))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
     /**
      * Return a list of all {@link KeyIdentifier KeyIdentifiers} that could be derived from
      * any {@link IssuerFingerprint} or {@link IssuerKeyID} subpackets of the hashed signature
@@ -905,6 +927,46 @@ public static boolean isCertification(int signatureType)
             || PGPSignature.POSITIVE_CERTIFICATION == signatureType;
     }
 
+    public static boolean isRevocation(int signatureType)
+    {
+        return PGPSignature.KEY_REVOCATION == signatureType
+            || PGPSignature.CERTIFICATION_REVOCATION == signatureType
+            || PGPSignature.SUBKEY_REVOCATION == signatureType;
+    }
+
+    public boolean isHardRevocation()
+    {
+        if (!isRevocation(getSignatureType()))
+        {
+            return false; // no revocation
+        }
+
+        if (!hasSubpackets())
+        {
+            return true; // consider missing subpackets (and therefore missing reason) as hard revocation
+        }
+
+        // only consider reasons from the hashed packet area
+        RevocationReason reason = getHashedSubPackets() != null ?
+            getHashedSubPackets().getRevocationReason() : null;
+        if (reason == null)
+        {
+            return true; // missing reason packet is hard
+        }
+
+        byte code = reason.getRevocationReason();
+        if (code >= 100 && code <= 110)
+        {
+            // private / experimental reasons are considered hard
+            return true;
+        }
+
+        // Reason is not from the set of known soft reasons
+        return code != RevocationReasonTags.KEY_SUPERSEDED &&
+            code != RevocationReasonTags.KEY_RETIRED &&
+            code != RevocationReasonTags.USER_NO_LONGER_VALID;
+    }
+
     /**
      * Return true, if the cryptographic signature encoding of the two signatures match.
      *

pg/src/main/java/org/bouncycastle/openpgp/PGPSignatureException.java

@@ -0,0 +1,15 @@
+package org.bouncycastle.openpgp;
+
+public class PGPSignatureException
+        extends PGPException
+{
+    public PGPSignatureException(String message)
+    {
+        super(message);
+    }
+
+    public PGPSignatureException(String message, Exception cause)
+    {
+        super(message, cause);
+    }
+}