/*

 * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package jdk.security.jarsigner;

import com.sun.jarsigner.ContentSigner;

import com.sun.jarsigner.ContentSignerParameters;

import sun.security.tools.PathList;

import sun.security.tools.jarsigner.TimestampedSigner;

import sun.security.util.ManifestDigester;

import sun.security.util.SignatureFileVerifier;

import sun.security.x509.AlgorithmId;

import java.io.*;

import java.net.SocketTimeoutException;

import java.net.URI;

import java.net.URL;

import java.net.URLClassLoader;

import java.security.*;

import java.security.cert.CertPath;

import java.security.cert.Certificate;

import java.security.cert.CertificateException;

import java.security.cert.X509Certificate;

import java.util.*;

import java.util.function.BiConsumer;

import java.util.jar.Attributes;

import java.util.jar.JarEntry;

import java.util.jar.JarFile;

import java.util.jar.Manifest;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;

import java.util.zip.ZipOutputStream;

/**

 * An immutable utility class to sign a jar file.

 * <p>

 * A caller creates a {@code JarSigner.Builder} object, (optionally) sets

 * some parameters, and calls {@link JarSigner.Builder#build build} to create

 * a {@code JarSigner} object. This {@code JarSigner} object can then

 * be used to sign a jar file.

 * <p>

 * Unless otherwise stated, calling a method of {@code JarSigner} or

 * {@code JarSigner.Builder} with a null argument will throw

 * a {@link NullPointerException}.

 * <p>

 * Example:

 * <pre>

 * JarSigner signer = new JarSigner.Builder(key, certPath)

 *         .digestAlgorithm("SHA-1")

 *         .signatureAlgorithm("SHA1withDSA")

 *         .build();

 * try (ZipFile in = new ZipFile(inputFile);

 *         FileOutputStream out = new FileOutputStream(outputFile)) {

 *     signer.sign(in, out);

 * }

 * </pre>

 *

 * @since 9

 */

public final class JarSigner {

    /**

     * A mutable builder class that can create an immutable {@code JarSigner}

     * from various signing-related parameters.

     *

     * @since 9

     */

    public static class Builder {

        // Signer materials:

        final PrivateKey privateKey;

        final X509Certificate[] certChain;

        // JarSigner options:

        // Support multiple digestalg internally. Can be null, but not empty

        String[] digestalg;

        String sigalg;

        // Precisely should be one provider for each digestalg, maybe later

        Provider digestProvider;

        Provider sigProvider;

        URI tsaUrl;

        String signerName;

        BiConsumer<String,String> handler;

        // Implementation-specific properties:

        String tSAPolicyID;

        String tSADigestAlg;

        boolean signManifest = true;

        boolean externalSF = true;

        String altSignerPath;

        String altSigner;

        /**

         * Creates a {@code JarSigner.Builder} object with

         * a {@link KeyStore.PrivateKeyEntry} object.

         *

         * @param entry the {@link KeyStore.PrivateKeyEntry} of the signer.

         */

        public Builder(KeyStore.PrivateKeyEntry entry) {

            this.privateKey = entry.getPrivateKey();

            try {

                // called internally, no need to clone

                Certificate[] certs = entry.getCertificateChain();

                this.certChain = Arrays.copyOf(certs, certs.length,

                        X509Certificate[].class);

            } catch (ArrayStoreException ase) {

                // Wrong type, not X509Certificate. Won't document.

                throw new IllegalArgumentException(

                        "Entry does not contain X509Certificate");

            }

        }

        /**

         * Creates a {@code JarSigner.Builder} object with a private key and

         * a certification path.

         *

         * @param privateKey the private key of the signer.

         * @param certPath the certification path of the signer.

         * @throws IllegalArgumentException if {@code certPath} is empty, or

         *      the {@code privateKey} algorithm does not match the algorithm

         *      of the {@code PublicKey} in the end entity certificate

         *      (the first certificate in {@code certPath}).

         */

        public Builder(PrivateKey privateKey, CertPath certPath) {

            List<? extends Certificate> certs = certPath.getCertificates();

            if (certs.isEmpty()) {

                throw new IllegalArgumentException("certPath cannot be empty");

            }

            if (!privateKey.getAlgorithm().equals

                    (certs.get(0).getPublicKey().getAlgorithm())) {

                throw new IllegalArgumentException

                        ("private key algorithm does not match " +

                                "algorithm of public key in end entity " +

                                "certificate (the 1st in certPath)");

            }

            this.privateKey = privateKey;

            try {

                this.certChain = certs.toArray(new X509Certificate[certs.size()]);

            } catch (ArrayStoreException ase) {

                // Wrong type, not X509Certificate.

                throw new IllegalArgumentException(

                        "Entry does not contain X509Certificate");

            }

        }

        /**

         * Sets the digest algorithm. If no digest algorithm is specified,

         * the default algorithm returned by {@link #getDefaultDigestAlgorithm}

         * will be used.

         *

         * @param algorithm the standard name of the algorithm. See

         *      the {@code MessageDigest} section in the <a href=

         *      "{@docRoot}/../specs/security/standard-names.html#messagedigest-algorithms">

         *      Java Cryptography Architecture Standard Algorithm Name

         *      Documentation</a> for information about standard algorithm names.

         * @return the {@code JarSigner.Builder} itself.

         * @throws NoSuchAlgorithmException if {@code algorithm} is not available.

         */

        public Builder digestAlgorithm(String algorithm) throws NoSuchAlgorithmException {

            MessageDigest.getInstance(Objects.requireNonNull(algorithm));

            this.digestalg = new String[]{algorithm};

            this.digestProvider = null;

            return this;

        }

        /**

         * Sets the digest algorithm from the specified provider.

         * If no digest algorithm is specified, the default algorithm

         * returned by {@link #getDefaultDigestAlgorithm} will be used.

         *

         * @param algorithm the standard name of the algorithm. See

         *      the {@code MessageDigest} section in the <a href=

         *      "{@docRoot}/../specs/security/standard-names.html#messagedigest-algorithms">

         *      Java Cryptography Architecture Standard Algorithm Name

         *      Documentation</a> for information about standard algorithm names.

         * @param provider the provider.

         * @return the {@code JarSigner.Builder} itself.

         * @throws NoSuchAlgorithmException if {@code algorithm} is not

         *      available in the specified provider.

         */

        public Builder digestAlgorithm(String algorithm, Provider provider)

                throws NoSuchAlgorithmException {

            MessageDigest.getInstance(

                    Objects.requireNonNull(algorithm),

                    Objects.requireNonNull(provider));

            this.digestalg = new String[]{algorithm};

            this.digestProvider = provider;

            return this;

        }

        /**

         * Sets the signature algorithm. If no signature algorithm

         * is specified, the default signature algorithm returned by

         * {@link #getDefaultSignatureAlgorithm} for the private key

         * will be used.

         *

         * @param algorithm the standard name of the algorithm. See

         *      the {@code Signature} section in the <a href=

         *      "{@docRoot}/../specs/security/standard-names.html#signature-algorithms">

         *      Java Cryptography Architecture Standard Algorithm Name

         *      Documentation</a> for information about standard algorithm names.

         * @return the {@code JarSigner.Builder} itself.

         * @throws NoSuchAlgorithmException if {@code algorithm} is not available.

         * @throws IllegalArgumentException if {@code algorithm} is not

         *      compatible with the algorithm of the signer's private key.

         */

        public Builder signatureAlgorithm(String algorithm)

                throws NoSuchAlgorithmException {

            // Check availability

            Signature.getInstance(Objects.requireNonNull(algorithm));

            AlgorithmId.checkKeyAndSigAlgMatch(

                    privateKey.getAlgorithm(), algorithm);

            this.sigalg = algorithm;

            this.sigProvider = null;

            return this;

        }

        /**

         * Sets the signature algorithm from the specified provider. If no

         * signature algorithm is specified, the default signature algorithm

         * returned by {@link #getDefaultSignatureAlgorithm} for the private

         * key will be used.

         *

         * @param algorithm the standard name of the algorithm. See

         *      the {@code Signature} section in the <a href=

         *      "{@docRoot}/../specs/security/standard-names.html#signature-algorithms">

         *      Java Cryptography Architecture Standard Algorithm Name

         *      Documentation</a> for information about standard algorithm names.

         * @param provider  the provider.

         * @return the {@code JarSigner.Builder} itself.

         * @throws NoSuchAlgorithmException if {@code algorithm} is not

         *      available in the specified provider.

         * @throws IllegalArgumentException if {@code algorithm} is not

         *      compatible with the algorithm of the signer's private key.

         */

        public Builder signatureAlgorithm(String algorithm, Provider provider)

                throws NoSuchAlgorithmException {

            // Check availability

            Signature.getInstance(

                    Objects.requireNonNull(algorithm),

                    Objects.requireNonNull(provider));

            AlgorithmId.checkKeyAndSigAlgMatch(

                    privateKey.getAlgorithm(), algorithm);

            this.sigalg = algorithm;

            this.sigProvider = provider;

            return this;

        }

        /**

         * Sets the URI of the Time Stamping Authority (TSA).

         *

         * @param uri the URI.

         * @return the {@code JarSigner.Builder} itself.

         */

        public Builder tsa(URI uri) {

            this.tsaUrl = Objects.requireNonNull(uri);

            return this;

        }

        /**

         * Sets the signer name. The name will be used as the base name for

         * the signature files. All lowercase characters will be converted to

         * uppercase for signature file names. If a signer name is not

         * specified, the string "SIGNER" will be used.

         *

         * @param name the signer name.

         * @return the {@code JarSigner.Builder} itself.

         * @throws IllegalArgumentException if {@code name} is empty or has

         *      a size bigger than 8, or it contains characters not from the

         *      set "a-zA-Z0-9_-".

         */

        public Builder signerName(String name) {

            if (name.isEmpty() || name.length() > 8) {

                throw new IllegalArgumentException("Name too long");

            }

            name = name.toUpperCase(Locale.ENGLISH);

            for (int j = 0; j < name.length(); j++) {

                char c = name.charAt(j);

                if (!

                        ((c >= 'A' && c <= 'Z') ||

                                (c >= '0' && c <= '9') ||

                                (c == '-') ||

                                (c == '_'))) {

                    throw new IllegalArgumentException(

                            "Invalid characters in name");

                }

            }

            this.signerName = name;

            return this;

        }

        /**

         * Sets en event handler that will be triggered when a {@link JarEntry}

         * is to be added, signed, or updated during the signing process.

         * <p>

         * The handler can be used to display signing progress. The first

         * argument of the handler can be "adding", "signing", or "updating",

         * and the second argument is the name of the {@link JarEntry}

         * being processed.

         *

         * @param handler the event handler.

         * @return the {@code JarSigner.Builder} itself.

         */

        public Builder eventHandler(BiConsumer<String,String> handler) {

            this.handler = Objects.requireNonNull(handler);

            return this;

        }

        /**

         * Sets an additional implementation-specific property indicated by

         * the specified key.

         *

         * @implNote This implementation supports the following properties:

         * <ul>

         * <li>"tsaDigestAlg": algorithm of digest data in the timestamping

         * request. The default value is the same as the result of

         * {@link #getDefaultDigestAlgorithm}.

         * <li>"tsaPolicyId": TSAPolicyID for Timestamping Authority.

         * No default value.

         * <li>"internalsf": "true" if the .SF file is included inside the

         * signature block, "false" otherwise. Default "false".

         * <li>"sectionsonly": "true" if the .SF file only contains the hash

         * value for each section of the manifest and not for the whole

         * manifest, "false" otherwise. Default "false".

         * </ul>

         * All property names are case-insensitive.

         *

         * @param key the name of the property.

         * @param value the value of the property.

         * @return the {@code JarSigner.Builder} itself.

         * @throws UnsupportedOperationException if the key is not supported

         *      by this implementation.

         * @throws IllegalArgumentException if the value is not accepted as

         *      a legal value for this key.

         */

        public Builder setProperty(String key, String value) {

            Objects.requireNonNull(key);

            Objects.requireNonNull(value);

            switch (key.toLowerCase(Locale.US)) {

                case "tsadigestalg":

                    try {

                        MessageDigest.getInstance(value);

                    } catch (NoSuchAlgorithmException nsae) {

                        throw new IllegalArgumentException(

                                "Invalid tsadigestalg", nsae);

                    }

                    this.tSADigestAlg = value;

                    break;

                case "tsapolicyid":

                    this.tSAPolicyID = value;

                    break;

                case "internalsf":

                    switch (value) {

                        case "true":

                            externalSF = false;

                            break;

                        case "false":

                            externalSF = true;

                            break;

                        default:

                            throw new IllegalArgumentException(

                                "Invalid internalsf value");

                    }

                    break;

                case "sectionsonly":

                    switch (value) {

                        case "true":

                            signManifest = false;

                            break;

                        case "false":

                            signManifest = true;

                            break;

                        default:

                            throw new IllegalArgumentException(

                                "Invalid signManifest value");

                    }

                    break;

                case "altsignerpath":

                    altSignerPath = value;

                    break;

                case "altsigner":

                    altSigner = value;

                    break;

                default:

                    throw new UnsupportedOperationException(

                            "Unsupported key " + key);

            }

            return this;

        }

        /**

         * Gets the default digest algorithm.

         *

         * @implNote This implementation returns "SHA-256". The value may

         * change in the future.

         *

         * @return the default digest algorithm.

         */

        public static String getDefaultDigestAlgorithm() {

            return "SHA-256";

        }

        /**

         * Gets the default signature algorithm for a private key.

         * For example, SHA256withRSA for a 2048-bit RSA key, and

         * SHA384withECDSA for a 384-bit EC key.

         *

         * @implNote This implementation makes use of comparable strengths

         * as defined in Tables 2 and 3 of NIST SP 800-57 Part 1-Rev.4.

         * Specifically, if a DSA or RSA key with a key size greater than 7680

         * bits, or an EC key with a key size greater than or equal to 512 bits,

         * SHA-512 will be used as the hash function for the signature.

         * If a DSA or RSA key has a key size greater than 3072 bits, or an

         * EC key has a key size greater than or equal to 384 bits, SHA-384 will

         * be used. Otherwise, SHA-256 will be used. The value may

         * change in the future.

         *

         * @param key the private key.

         * @return the default signature algorithm. Returns null if a default

         *      signature algorithm cannot be found. In this case,

         *      {@link #signatureAlgorithm} must be called to specify a

         *      signature algorithm. Otherwise, the {@link #build} method

         *      will throw an {@link IllegalArgumentException}.

         */

        public static String getDefaultSignatureAlgorithm(PrivateKey key) {

            return AlgorithmId.getDefaultSigAlgForKey(Objects.requireNonNull(key));

        }

        /**

         * Builds a {@code JarSigner} object from the parameters set by the

         * setter methods.

         * <p>

         * This method does not modify internal state of this {@code Builder}

         * object and can be called multiple times to generate multiple

         * {@code JarSigner} objects. After this method is called, calling

         * any method on this {@code Builder} will have no effect on

         * the newly built {@code JarSigner} object.

         *

         * @return the {@code JarSigner} object.

         * @throws IllegalArgumentException if a signature algorithm is not

         *      set and cannot be derived from the private key using the

         *      {@link #getDefaultSignatureAlgorithm} method.

         */

        public JarSigner build() {

            return new JarSigner(this);

        }

    }

    private static final String META_INF = "META-INF/";

    // All fields in Builder are duplicated here as final. Those not

    // provided but has a default value will be filled with default value.

    // Precisely, a final array field can still be modified if only

    // reference is copied, no clone is done because we are concerned about

    // casual change instead of malicious attack.

    // Signer materials:

    private final PrivateKey privateKey;

    private final X509Certificate[] certChain;

    // JarSigner options:

    private final String[] digestalg;

    private final String sigalg;

    private final Provider digestProvider;

    private final Provider sigProvider;

    private final URI tsaUrl;

    private final String signerName;

    private final BiConsumer<String,String> handler;

    // Implementation-specific properties:

    private final String tSAPolicyID;

    private final String tSADigestAlg;

    private final boolean signManifest; // "sign" the whole manifest

    private final boolean externalSF; // leave the .SF out of the PKCS7 block

    private final String altSignerPath;

    private final String altSigner;

    private JarSigner(JarSigner.Builder builder) {

        this.privateKey = builder.privateKey;

        this.certChain = builder.certChain;

        if (builder.digestalg != null) {

            // No need to clone because builder only accepts one alg now

            this.digestalg = builder.digestalg;

        } else {

            this.digestalg = new String[] {

                    Builder.getDefaultDigestAlgorithm() };

        }

        this.digestProvider = builder.digestProvider;

        if (builder.sigalg != null) {

            this.sigalg = builder.sigalg;

        } else {

            this.sigalg = JarSigner.Builder

                    .getDefaultSignatureAlgorithm(privateKey);

            if (this.sigalg == null) {

                throw new IllegalArgumentException(

                        "No signature alg for " + privateKey.getAlgorithm());

            }

        }

        this.sigProvider = builder.sigProvider;

        this.tsaUrl = builder.tsaUrl;