PKCS#7 CMS signing and verification

kse/src/main/java/org/kse/crypto/signing/CmsSignatureStatus.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2004 - 2013 Wayne Grant
+ *           2013 - 2024 Kai Kramer
+ *
+ * This file is part of KeyStore Explorer.
+ *
+ * KeyStore Explorer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * KeyStore Explorer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with KeyStore Explorer.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.kse.crypto.signing;
+
+import java.util.ResourceBundle;
+
+/**
+ * Enumeration of signature statuses for verifying a CMS signature.
+ */
+public enum CmsSignatureStatus {
+
+    // @formatter:off
+
+    NOT_VERIFIED,
+    INVALID,
+    VALID_NOT_TRUSTED,
+    VALID_TRUSTED;
+
+    // @formatter:on
+
+    private static ResourceBundle res = ResourceBundle.getBundle("org/kse/crypto/signing/resources");
+
+    public String getText() {
+        return res.getString("CmsSignatureStatus." + name() + ".text");
+    }
+
+    public String getToolTip() {
+        return res.getString("CmsSignatureStatus." + name() + ".tooltip");
+    }
+
+}

kse/src/main/java/org/kse/crypto/signing/CmsSigner.java

@@ -0,0 +1,202 @@
+/*
+ * Copyright 2004 - 2013 Wayne Grant
+ *           2013 - 2024 Kai Kramer
+ *
+ * This file is part of KeyStore Explorer.
+ *
+ * KeyStore Explorer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * KeyStore Explorer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with KeyStore Explorer.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.kse.crypto.signing;
+
+import java.io.File;
+import java.io.IOException;
+import java.security.PrivateKey;
+import java.security.Provider;
+import java.security.cert.CertificateEncodingException;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.ResourceBundle;
+
+import org.bouncycastle.asn1.ASN1EncodableVector;
+import org.bouncycastle.asn1.ASN1Primitive;
+import org.bouncycastle.asn1.DERSet;
+import org.bouncycastle.asn1.cms.Attribute;
+import org.bouncycastle.asn1.cms.AttributeTable;
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+import org.bouncycastle.cert.jcajce.JcaCertStore;
+import org.bouncycastle.cms.CMSException;
+import org.bouncycastle.cms.CMSProcessableFile;
+import org.bouncycastle.cms.CMSSignedData;
+import org.bouncycastle.cms.CMSSignedDataGenerator;
+import org.bouncycastle.cms.CMSTypedData;
+import org.bouncycastle.cms.SignerInformation;
+import org.bouncycastle.cms.SignerInformationStore;
+import org.bouncycastle.cms.jcajce.JcaSignerInfoGeneratorBuilder;
+import org.bouncycastle.operator.OperatorCreationException;
+import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;
+import org.bouncycastle.operator.jcajce.JcaDigestCalculatorProviderBuilder;
+import org.kse.crypto.CryptoException;
+import org.kse.crypto.digest.DigestType;
+
+/**
+ * Class provides functionality to sign files using PKCS #7 Cryptographic
+ * Message Syntax (CMS).
+ */
+public class CmsSigner {
+    private static ResourceBundle res = ResourceBundle.getBundle("org/kse/crypto/signing/resources");
+
+    private CmsSigner() {
+    }
+
+    /**
+     * Signs a file using PKCS #7 CMS.
+     *
+     * @param inputFile         The file to sign.
+     * @param privateKey        The private key to use for signing.
+     * @param certificateChain  The certificate chain for the private key.
+     * @param detachedSignature True if the signature is to be detached. False,
+     *                          encapsulate the file into the signature.
+     * @param signatureType     The signature type to use for signing.
+     * @param tsaUrl            An optional TSA URL for adding a time stamp token to
+     *                          the signature.
+     * @param provider
+     * @return The signature in a CMSSignedData object.
+     */
+    public static CMSSignedData sign(File inputFile, PrivateKey privateKey, X509Certificate[] certificateChain,
+            boolean detachedSignature, SignatureType signatureType, String tsaUrl, Provider provider)
+            throws CryptoException {
+        try {
+            CMSTypedData msg = new CMSProcessableFile(inputFile);
+
+            JcaContentSignerBuilder contentSignerBuilder = new JcaContentSignerBuilder(signatureType.jce());
+            JcaDigestCalculatorProviderBuilder digestCalculatorProviderBuilder = new JcaDigestCalculatorProviderBuilder();
+            if (provider != null) {
+                contentSignerBuilder.setProvider(provider);
+                digestCalculatorProviderBuilder.setProvider(provider);
+            }
+
+            CMSSignedDataGenerator generator = new CMSSignedDataGenerator();
+            generator.addSignerInfoGenerator(new JcaSignerInfoGeneratorBuilder(digestCalculatorProviderBuilder.build())
+                    .build(contentSignerBuilder.build(privateKey), certificateChain[0]));
+            generator.addCertificates(new JcaCertStore(Arrays.asList(certificateChain)));
+
+            CMSSignedData signedData = generator.generate(msg, !detachedSignature);
+
+            if (tsaUrl != null) {
+                SignerInformationStore signerInfos = addTimestamp(tsaUrl, signedData.getSignerInfos(),
+                        signatureType.digestType());
+                signedData = CMSSignedData.replaceSigners(signedData, signerInfos);
+            }
+
+            return signedData;
+        } catch (Exception e) {
+            throw new CryptoException(res.getString("CmsSignatureFailed.exception.message"), e);
+        }
+    }
+
+    /**
+     * Counter signs a signature using PKCS #7 CMS.
+     *
+     * @param signedData        The signature to counter sign.
+     * @param privateKey        The private key to use for signing.
+     * @param certificateChain  The certificate chain for the private key.
+     * @param detachedSignature True if the signature is to be detached. False,
+     *                          encapsulate the file into the signature.
+     * @param signatureType     The signature type to use for signing.
+     * @param tsaUrl            An optional TSA URL for adding a time stamp token to
+     *                          the signature.
+     * @param provider
+     * @return The counter signed signature in a CMSSignedData object.
+     */
+    public static CMSSignedData counterSign(CMSSignedData signedData, PrivateKey privateKey,
+            X509Certificate[] certificateChain, boolean detachedSignature, SignatureType signatureType, String tsaUrl,
+            Provider provider) throws CryptoException {
+        try {
+            JcaContentSignerBuilder contentSignerBuilder = new JcaContentSignerBuilder(signatureType.jce());
+            JcaDigestCalculatorProviderBuilder digestCalculatorProviderBuilder = new JcaDigestCalculatorProviderBuilder();
+            if (provider != null) {
+                contentSignerBuilder.setProvider(provider);
+                digestCalculatorProviderBuilder.setProvider(provider);
+            }
+
+            CMSSignedDataGenerator counterSignerGen = new CMSSignedDataGenerator();
+            counterSignerGen.addSignerInfoGenerator(
+                    new JcaSignerInfoGeneratorBuilder(digestCalculatorProviderBuilder.build())
+                            .build(contentSignerBuilder.build(privateKey), certificateChain[0]));
+
+            // Counter signs all existing signatures.
+            CMSSignedDataGenerator generator = new CMSSignedDataGenerator();
+            for (SignerInformation signer : signedData.getSignerInfos()) {
+                SignerInformationStore counterSigners = counterSignerGen.generateCounterSigners(signer);
+
+                if (tsaUrl != null) {
+                    counterSigners = addTimestamp(tsaUrl, counterSigners, signatureType.digestType());
+                }
+
+                // addCounterSigners does not replace existing counter signers. It creates a new
+                // counter signer vector if it does not already exist, and then it adds the counter signer.
+                signer = SignerInformation.addCounterSigners(signer, counterSigners);
+
+                generator.addCertificates(new JcaCertStore(Arrays.asList(certificateChain)));
+                generator.addSigners(new SignerInformationStore(signer));
+            }
+            generator.addCertificates(signedData.getCertificates());
+
+            CMSSignedData counterSignedData = generator.generate(signedData.getSignedContent(), !detachedSignature);
+
+            return counterSignedData;
+        } catch (CertificateEncodingException | OperatorCreationException | CMSException | IOException e) {
+            throw new CryptoException(res.getString("CmsCounterSignatureFailed.exception.message"), e);
+        }
+    }
+
+    /**
+     * Adds a timestamp to a PKCS #7 signature.
+     *
+     * @param tsaUrl      The URL of the time stamp authority.
+     * @param signerInfos The signer information to time stamp.
+     * @param digestType  The digest type to use for the time stamp.
+     * @return <b>SignerInformation</b> with time stamp token.
+     */
+    public static SignerInformationStore addTimestamp(String tsaUrl, SignerInformationStore signerInfos,
+            DigestType digestType) throws IOException {
+
+        Collection<SignerInformation> newSignerInfos = new ArrayList<>();
+
+        for (SignerInformation si : signerInfos.getSigners()) {
+            byte[] signature = si.getSignature();
+
+            // Ed448 uses digest type of SHAKE256-512, which is not currently supported by the TSAs.
+            if (DigestType.SHAKE256 == digestType) {
+                digestType = DigestType.SHA512;
+            }
+
+            // send request to TSA
+            byte[] token = TimeStampingClient.getTimeStampToken(tsaUrl, signature, digestType);
+
+            // create new SignerInformation with TS attribute
+            Attribute tokenAttr = new Attribute(PKCSObjectIdentifiers.id_aa_signatureTimeStampToken,
+                                                new DERSet(ASN1Primitive.fromByteArray(token)));
+            ASN1EncodableVector timestampVector = new ASN1EncodableVector();
+            timestampVector.add(tokenAttr);
+            AttributeTable at = new AttributeTable(timestampVector);
+
+            newSignerInfos.add(SignerInformation.replaceUnsignedAttributes(si, at));
+        }
+
+        return new SignerInformationStore(newSignerInfos);
+    }
+}

kse/src/main/java/org/kse/crypto/signing/CmsUtil.java

@@ -0,0 +1,143 @@
+/*
+ * Copyright 2004 - 2013 Wayne Grant
+ *           2013 - 2024 Kai Kramer
+ *
+ * This file is part of KeyStore Explorer.
+ *
+ * KeyStore Explorer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * KeyStore Explorer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with KeyStore Explorer.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.kse.crypto.signing;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Collection;
+import java.util.List;
+import java.util.ResourceBundle;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+import org.bouncycastle.cert.X509CertificateHolder;
+import org.bouncycastle.cms.CMSException;
+import org.bouncycastle.cms.CMSProcessableFile;
+import org.bouncycastle.cms.CMSSignedData;
+import org.bouncycastle.cms.SignerInformation;
+import org.bouncycastle.util.Store;
+import org.kse.crypto.CryptoException;
+import org.kse.utilities.pem.PemInfo;
+import org.kse.utilities.pem.PemUtil;
+
+/**
+ * Provides utility methods relating to Cryptographic Message Syntax (CMS).
+ */
+public class CmsUtil {
+    private static ResourceBundle res = ResourceBundle.getBundle("org/kse/crypto/signing/resources");
+
+    private static final String CMS_PEM_TYPE = "CMS";
+    private static final String PKCS7_PEM_TYPE = "PKCS7";
+
+    private CmsUtil() {
+    }
+
+    /**
+     * Loads a signature. If it is a detached signature, attempts to find and load the content.
+     * Verification and counter signing require the content.
+     *
+     * @param signatureFile The signature file.
+     * @param chooser       The file chooser to use for choosing the content file.
+     * @return
+     * @throws CryptoException
+     */
+    public static CMSSignedData loadSignature(File signatureFile, Supplier<File> chooser)
+            throws CryptoException {
+
+        try {
+            byte[] signature = Files.readAllBytes(signatureFile.toPath());
+
+            if (PemUtil.isPemFormat(signature)) {
+                PemInfo signaturePem = PemUtil.decode(signature);
+                if (signaturePem != null) {
+                    signature = signaturePem.getContent();
+                }
+            }
+
+            CMSSignedData signedData = new CMSSignedData(signature);
+
+            if (signedData.isDetachedSignature()) {
+                CMSProcessableFile content = loadDetachedContent(signatureFile, chooser);
+                if (content != null) {
+                    signedData = new CMSSignedData(content, signature);
+                }
+            }
+
+            return signedData;
+        } catch (IOException | CMSException e) {
+            throw new CryptoException(res.getString("NoReadCms.exception.message"), e);
+        }
+    }
+
+    private static CMSProcessableFile loadDetachedContent(File signatureFile, Supplier<File> chooser) {
+
+        // Look for the content file. if not present, prompt for it.
+        File contentFile = null;
+
+        // First try file name with signature extension stripped.
+        int extensionIndex = signatureFile.getAbsolutePath().lastIndexOf('.');
+        if (extensionIndex > 0) {
+            // Turn file_name.txt.p7s into file_name.txt
+            String contentFileName = signatureFile.getAbsolutePath().substring(0, extensionIndex);
+            if (Files.exists(Paths.get(contentFileName))) {
+                contentFile = new File(contentFileName);
+            }
+        }
+
+        // No file - ask for one (if chooser is available)
+        if (contentFile == null && chooser != null) {
+            contentFile = chooser.get();
+            if (contentFile == null) {
+                return null;
+            }
+        }
+
+        return new CMSProcessableFile(contentFile);
+    }
+
+    public static boolean isCmsPemType(PemInfo pemInfo) {
+        return pemInfo != null && (PKCS7_PEM_TYPE.equals(pemInfo.getType()) || CMS_PEM_TYPE.equals(pemInfo.getType()));
+    }
+
+    /**
+     * PEM encode a CMS signature.
+     *
+     * @param cms The CMS signature
+     * @return The PEM'd encoding
+     */
+    public static String getPem(CMSSignedData cms) throws CryptoException {
+        try {
+            // Use PKCS7 PEM header since it can be verified using GnuTLS certtool and OpenSSL.
+            // GnuTLS certtool will not verify signatures with the CMS PEM header.
+            PemInfo pemInfo = new PemInfo(PKCS7_PEM_TYPE, null, cms.getEncoded());
+            return PemUtil.encode(pemInfo);
+        } catch (IOException e) {
+            throw new CryptoException(res.getString("CmsGetPemFailed.exception.message"), e);
+        }
+    }
+
+    public static List<KseSignerInformation> convertSignerInformations(Collection<SignerInformation> signerInfos,
+            Store<X509CertificateHolder> trustedCerts, Store<X509CertificateHolder> signatureCerts) {
+        return signerInfos.stream().map(s -> new KseSignerInformation(s, trustedCerts, signatureCerts))
+                .collect(Collectors.toList());
+    }
+}