/*

 * 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 sun.security.util;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.security.CodeSigner;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.security.SignatureException;

import java.security.cert.CertPath;

import java.security.cert.X509Certificate;

import java.security.cert.CertificateException;

import java.security.cert.CertificateFactory;

import java.util.ArrayList;

import java.util.Base64;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.jar.Attributes;

import java.util.jar.JarException;

import java.util.jar.JarFile;

import java.util.jar.Manifest;

import sun.security.jca.Providers;

import sun.security.pkcs.PKCS7;

import sun.security.pkcs.SignerInfo;

public class SignatureFileVerifier {

    /* Are we debugging ? */

    private static final Debug debug = Debug.getInstance("jar");

    private static final DisabledAlgorithmConstraints JAR_DISABLED_CHECK =

            new DisabledAlgorithmConstraints(

                    DisabledAlgorithmConstraints.PROPERTY_JAR_DISABLED_ALGS);

    private ArrayList<CodeSigner[]> signerCache;

    private static final String ATTR_DIGEST =

        ("-DIGEST-" + ManifestDigester.MF_MAIN_ATTRS).toUpperCase

        (Locale.ENGLISH);

    /** the PKCS7 block for this .DSA/.RSA/.EC file */

    private PKCS7 block;

    /** the raw bytes of the .SF file */

    private byte[] sfBytes;

    /** the name of the signature block file, uppercased and without

     *  the extension (.DSA/.RSA/.EC)

     */

    private String name;

    /** the ManifestDigester */

    private ManifestDigester md;

    /** cache of created MessageDigest objects */

    private HashMap<String, MessageDigest> createdDigests;

    /* workaround for parsing Netscape jars  */

    private boolean workaround = false;

    /* for generating certpath objects */

    private CertificateFactory certificateFactory = null;

    /**

     * Create the named SignatureFileVerifier.

     *

     * @param name the name of the signature block file (.DSA/.RSA/.EC)

     *

     * @param rawBytes the raw bytes of the signature block file

     */

    public SignatureFileVerifier(ArrayList<CodeSigner[]> signerCache,

                                 ManifestDigester md,

                                 String name,

                                 byte[] rawBytes)

        throws IOException, CertificateException

    {

        // new PKCS7() calls CertificateFactory.getInstance()

        // need to use local providers here, see Providers class

        Object obj = null;

        try {

            obj = Providers.startJarVerification();

            block = new PKCS7(rawBytes);

            sfBytes = block.getContentInfo().getData();

            certificateFactory = CertificateFactory.getInstance("X509");

        } finally {

            Providers.stopJarVerification(obj);

        }

        this.name = name.substring(0, name.lastIndexOf('.'))

                                                   .toUpperCase(Locale.ENGLISH);

        this.md = md;

        this.signerCache = signerCache;

    }

    /**

     * returns true if we need the .SF file

     */

    public boolean needSignatureFileBytes()

    {

        return sfBytes == null;

    }

    /**

     * returns true if we need this .SF file.

     *

     * @param name the name of the .SF file without the extension

     *

     */

    public boolean needSignatureFile(String name)

    {

        return this.name.equalsIgnoreCase(name);

    }

    /**

     * used to set the raw bytes of the .SF file when it

     * is external to the signature block file.

     */

    public void setSignatureFile(byte[] sfBytes)

    {

        this.sfBytes = sfBytes;

    }

    /**

     * Utility method used by JarVerifier and JarSigner

     * to determine the signature file names and PKCS7 block

     * files names that are supported

     *

     * @param s file name

     * @return true if the input file name is a supported

     *          Signature File or PKCS7 block file name

     */

    public static boolean isBlockOrSF(String s) {

        // we currently only support DSA and RSA PKCS7 blocks

        return s.endsWith(".SF")

            || s.endsWith(".DSA")

            || s.endsWith(".RSA")

            || s.endsWith(".EC");

    }

    /**

     * Yet another utility method used by JarVerifier and JarSigner

     * to determine what files are signature related, which includes

     * the MANIFEST, SF files, known signature block files, and other

     * unknown signature related files (those starting with SIG- with

     * an optional [A-Z0-9]{1,3} extension right inside META-INF).

     *

     * @param name file name

     * @return true if the input file name is signature related

     */

    public static boolean isSigningRelated(String name) {

        name = name.toUpperCase(Locale.ENGLISH);

        if (!name.startsWith("META-INF/")) {

            return false;

        }

        name = name.substring(9);

        if (name.indexOf('/') != -1) {

            return false;

        }

        if (isBlockOrSF(name) || name.equals("MANIFEST.MF")) {

            return true;

        } else if (name.startsWith("SIG-")) {

            // check filename extension

            // see http://docs.oracle.com/javase/7/docs/technotes/guides/jar/jar.html#Digital_Signatures

            // for what filename extensions are legal

            int extIndex = name.lastIndexOf('.');

            if (extIndex != -1) {

                String ext = name.substring(extIndex + 1);

                // validate length first

                if (ext.length() > 3 || ext.length() < 1) {

                    return false;

                }

                // then check chars, must be in [a-zA-Z0-9] per the jar spec

                for (int index = 0; index < ext.length(); index++) {

                    char cc = ext.charAt(index);

                    // chars are promoted to uppercase so skip lowercase checks

                    if ((cc < 'A' || cc > 'Z') && (cc < '0' || cc > '9')) {

                        return false;

                    }

                }

            }

            return true; // no extension is OK

        }

        return false;

    }

    /** get digest from cache */

        if (createdDigests == null)

            createdDigests = new HashMap<>();

        MessageDigest digest = createdDigests.get(algorithm);

        if (digest == null) {

            try {

                digest = MessageDigest.getInstance(algorithm);

                createdDigests.put(algorithm, digest);

            } catch (NoSuchAlgorithmException nsae) {

                // ignore

            }

        }

        return digest;

    }

    /**

     * process the signature block file. Goes through the .SF file

     * and adds code signers for each section where the .SF section

     * hash was verified against the Manifest section.

     *

     *

     */

    public void process(Hashtable<String, CodeSigner[]> signers,

            List<Object> manifestDigests)

        throws IOException, SignatureException, NoSuchAlgorithmException,

            JarException, CertificateException

    {

        // calls Signature.getInstance() and MessageDigest.getInstance()

        // need to use local providers here, see Providers class

        Object obj = null;

        try {

            obj = Providers.startJarVerification();

            processImpl(signers, manifestDigests);

        } finally {

            Providers.stopJarVerification(obj);

        }

    }

    private void processImpl(Hashtable<String, CodeSigner[]> signers,

            List<Object> manifestDigests)

        throws IOException, SignatureException, NoSuchAlgorithmException,

            JarException, CertificateException

    {

        Manifest sf = new Manifest();

        sf.read(new ByteArrayInputStream(sfBytes));

        String version =

            sf.getMainAttributes().getValue(Attributes.Name.SIGNATURE_VERSION);

        if ((version == null) || !(version.equalsIgnoreCase("1.0"))) {

            // XXX: should this be an exception?

            // for now we just ignore this signature file

            return;

        }

        SignerInfo[] infos = block.verify(sfBytes);

        if (infos == null) {

            throw new SecurityException("cannot verify signature block file " +

                                        name);

        }

        CodeSigner[] newSigners = getSigners(infos, block);

        // make sure we have something to do all this work for...

        if (newSigners == null)

            return;

        Iterator<Map.Entry<String,Attributes>> entries =

                                sf.getEntries().entrySet().iterator();

        // see if we can verify the whole manifest first

        boolean manifestSigned = verifyManifestHash(sf, md, manifestDigests);

        // verify manifest main attributes

        if (!manifestSigned && !verifyManifestMainAttrs(sf, md)) {

            throw new SecurityException

                ("Invalid signature file digest for Manifest main attributes");

        }

        // go through each section in the signature file

        while(entries.hasNext()) {

            Map.Entry<String,Attributes> e = entries.next();

            String name = e.getKey();

            if (manifestSigned ||

                (verifySection(e.getValue(), name, md))) {

                if (name.startsWith("./"))

                    name = name.substring(2);

                if (name.startsWith("/"))

                    name = name.substring(1);

                updateSigners(newSigners, signers, name);

                if (debug != null) {

                    debug.println("processSignature signed name = "+name);

                }

            } else if (debug != null) {

                debug.println("processSignature unsigned name = "+name);

            }

        }

        // MANIFEST.MF is always regarded as signed

        updateSigners(newSigners, signers, JarFile.MANIFEST_NAME);

    }

    /**

     * See if the whole manifest was signed.

     */

    private boolean verifyManifestHash(Manifest sf,

                                       ManifestDigester md,

                                       List<Object> manifestDigests)

         throws IOException, SignatureException

    {

        Attributes mattr = sf.getMainAttributes();

        boolean manifestSigned = false;

        // go through all the attributes and process *-Digest-Manifest entries

        for (Map.Entry<Object,Object> se : mattr.entrySet()) {

            String key = se.getKey().toString();

            if (key.toUpperCase(Locale.ENGLISH).endsWith("-DIGEST-MANIFEST")) {

                // 16 is length of "-Digest-Manifest"

                String algorithm = key.substring(0, key.length()-16);

                manifestDigests.add(key);

                manifestDigests.add(se.getValue());

                MessageDigest digest = getDigest(algorithm);

                if (digest != null) {

                    byte[] computedHash = md.manifestDigest(digest);

                    byte[] expectedHash =

                        Base64.getMimeDecoder().decode((String)se.getValue());

                    if (debug != null) {

                    }

                        manifestSigned = true;

                    } else {

                        //XXX: we will continue and verify each section

                    }

                }

            }

        }

        return manifestSigned;

    }

         throws IOException, SignatureException

    {

        Attributes mattr = sf.getMainAttributes();

        boolean attrsVerified = true;