/*

 * Copyright (c) 1997, 2015, 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 java.util.jar;

import java.io.*;

import java.lang.ref.SoftReference;

import java.net.URL;

import java.util.*;

import java.util.stream.Stream;

import java.util.stream.StreamSupport;

import java.util.zip.*;

import java.security.CodeSigner;

import java.security.cert.Certificate;

import java.security.AccessController;

import java.security.CodeSource;

import jdk.internal.misc.SharedSecrets;

import sun.security.action.GetPropertyAction;

import sun.security.util.ManifestEntryVerifier;

import sun.security.util.SignatureFileVerifier;

/**

 * The {@code JarFile} class is used to read the contents of a jar file

 * from any file that can be opened with {@code java.io.RandomAccessFile}.

 * It extends the class {@code java.util.zip.ZipFile} with support

 * for reading an optional {@code Manifest} entry. The

 * {@code Manifest} can be used to specify meta-information about the

 * jar file and its entries.

 *

 * <p> Unless otherwise noted, passing a {@code null} argument to a constructor

 * or method in this class will cause a {@link NullPointerException} to be

 * thrown.

 *

 * If the verify flag is on when opening a signed jar file, the content of the

 * file is verified against its signature embedded inside the file. Please note

 * that the verification process does not include validating the signer's

 * certificate. A caller should inspect the return value of

 * {@link JarEntry#getCodeSigners()} to further determine if the signature

 * can be trusted.

 *

 * @author  David Connelly

 * @see     Manifest

 * @see     java.util.zip.ZipFile

 * @see     java.util.jar.JarEntry

 * @since   1.2

 */

public

class JarFile extends ZipFile {

    private SoftReference<Manifest> manRef;

    private JarEntry manEntry;

    private JarVerifier jv;

    private boolean jvInitialized;

    private boolean verify;

    // indicates if Class-Path attribute present (only valid if hasCheckedSpecialAttributes true)

    private boolean hasClassPathAttribute;

    // true if manifest checked for special attributes

    private volatile boolean hasCheckedSpecialAttributes;

    // Set up JavaUtilJarAccess in SharedSecrets

    static {

        SharedSecrets.setJavaUtilJarAccess(new JavaUtilJarAccessImpl());

    }

    /**

     * The JAR manifest file name.

     */

    public static final String MANIFEST_NAME = "META-INF/MANIFEST.MF";

    /**

     * Creates a new {@code JarFile} to read from the specified

     * file {@code name}. The {@code JarFile} will be verified if

     * it is signed.

     * @param name the name of the jar file to be opened for reading

     * @throws IOException if an I/O error has occurred

     * @throws SecurityException if access to the file is denied

     *         by the SecurityManager

     */

    public JarFile(String name) throws IOException {

        this(new File(name), true, ZipFile.OPEN_READ);

    }

    /**

     * Creates a new {@code JarFile} to read from the specified

     * file {@code name}.

     * @param name the name of the jar file to be opened for reading

     * @param verify whether or not to verify the jar file if

     * it is signed.

     * @throws IOException if an I/O error has occurred

     * @throws SecurityException if access to the file is denied

     *         by the SecurityManager

     */

    public JarFile(String name, boolean verify) throws IOException {

        this(new File(name), verify, ZipFile.OPEN_READ);

    }

    /**

     * Creates a new {@code JarFile} to read from the specified

     * {@code File} object. The {@code JarFile} will be verified if

     * it is signed.

     * @param file the jar file to be opened for reading

     * @throws IOException if an I/O error has occurred

     * @throws SecurityException if access to the file is denied

     *         by the SecurityManager

     */

    public JarFile(File file) throws IOException {

        this(file, true, ZipFile.OPEN_READ);

    }

    /**

     * Creates a new {@code JarFile} to read from the specified

     * {@code File} object.

     * @param file the jar file to be opened for reading

     * @param verify whether or not to verify the jar file if

     * it is signed.

     * @throws IOException if an I/O error has occurred

     * @throws SecurityException if access to the file is denied

     *         by the SecurityManager.

     */

    public JarFile(File file, boolean verify) throws IOException {

        this(file, verify, ZipFile.OPEN_READ);

    }

    /**

     * Creates a new {@code JarFile} to read from the specified

     * {@code File} object in the specified mode.  The mode argument

     * must be either {@code OPEN_READ} or {@code OPEN_READ | OPEN_DELETE}.

     *

     * @param file the jar file to be opened for reading

     * @param verify whether or not to verify the jar file if

     * it is signed.

     * @param mode the mode in which the file is to be opened

     * @throws IOException if an I/O error has occurred

     * @throws IllegalArgumentException

     *         if the {@code mode} argument is invalid

     * @throws SecurityException if access to the file is denied

     *         by the SecurityManager

     * @since 1.3

     */

    public JarFile(File file, boolean verify, int mode) throws IOException {

        super(file, mode);

        this.verify = verify;

    }

    /**

     * Returns the jar file manifest, or {@code null} if none.

     *

     * @return the jar file manifest, or {@code null} if none

     *

     * @throws IllegalStateException

     *         may be thrown if the jar file has been closed

     * @throws IOException  if an I/O error has occurred

     */

    public Manifest getManifest() throws IOException {

        return getManifestFromReference();

    }

    private Manifest getManifestFromReference() throws IOException {

        Manifest man = manRef != null ? manRef.get() : null;

        if (man == null) {

            JarEntry manEntry = getManEntry();

            // If found then load the manifest

            if (manEntry != null) {

                if (verify) {

                    byte[] b = getBytes(manEntry);

                    man = new Manifest(new ByteArrayInputStream(b));

                    if (!jvInitialized) {

                        jv = new JarVerifier(b);

                    }

                } else {

                    man = new Manifest(super.getInputStream(manEntry));

                }

                manRef = new SoftReference<>(man);

            }

        }

        return man;

    }

    /**

     * Returns the {@code JarEntry} for the given entry name or

     * {@code null} if not found.

     *

     * @param name the jar file entry name

     * @return the {@code JarEntry} for the given entry name or

     *         {@code null} if not found.

     *

     * @throws IllegalStateException

     *         may be thrown if the jar file has been closed

     *

     * @see java.util.jar.JarEntry

     */

    public JarEntry getJarEntry(String name) {

        return (JarEntry)getEntry(name);

    }

    /**

     * Returns the {@code ZipEntry} for the given entry name or

     * {@code null} if not found.

     *

     * @param name the jar file entry name

     * @return the {@code ZipEntry} for the given entry name or

     *         {@code null} if not found

     *

     * @throws IllegalStateException

     *         may be thrown if the jar file has been closed

     *

     * @see java.util.zip.ZipEntry

     */

    public ZipEntry getEntry(String name) {

        ZipEntry ze = super.getEntry(name);

        if (ze != null) {

            return new JarFileEntry(ze);

        }

        return null;

    }

    private class JarEntryIterator implements Enumeration<JarEntry>,

            Iterator<JarEntry>

    {

        final Enumeration<? extends ZipEntry> e = JarFile.super.entries();

        public boolean hasNext() {

            return e.hasMoreElements();

        }

        public JarEntry next() {

            ZipEntry ze = e.nextElement();

            return new JarFileEntry(ze);

        }

        public boolean hasMoreElements() {

            return hasNext();

        }

        public JarEntry nextElement() {

            return next();

        }

        public Iterator<JarEntry> asIterator() {

            return this;

        }

    }

    /**

     * Returns an enumeration of the jar file entries.

     *

     * @return an enumeration of the jar file entries

     * @throws IllegalStateException

     *         may be thrown if the jar file has been closed

     */

    public Enumeration<JarEntry> entries() {

        return new JarEntryIterator();

    }

    /**

     * Returns an ordered {@code Stream} over the jar file entries.

     * Entries appear in the {@code Stream} in the order they appear in

     * the central directory of the jar file.

     *

     * @return an ordered {@code Stream} of entries in this jar file

     * @throws IllegalStateException if the jar file has been closed

     * @since 1.8

     */

    public Stream<JarEntry> stream() {

        return StreamSupport.stream(Spliterators.spliterator(

                new JarEntryIterator(), size(),

                Spliterator.ORDERED | Spliterator.DISTINCT |

                        Spliterator.IMMUTABLE | Spliterator.NONNULL), false);

    }

    private class JarFileEntry extends JarEntry {

        JarFileEntry(ZipEntry ze) {

            super(ze);

        }

        public Attributes getAttributes() throws IOException {

            Manifest man = JarFile.this.getManifest();

            if (man != null) {

                return man.getAttributes(getName());

            } else {

                return null;

            }

        }

        public Certificate[] getCertificates() {

            try {

                maybeInstantiateVerifier();

            } catch (IOException e) {

                throw new RuntimeException(e);

            }

            if (certs == null && jv != null) {

                certs = jv.getCerts(JarFile.this, this);

            }

            return certs == null ? null : certs.clone();

        }

        public CodeSigner[] getCodeSigners() {

            try {

                maybeInstantiateVerifier();

            } catch (IOException e) {

                throw new RuntimeException(e);

            }

            if (signers == null && jv != null) {

                signers = jv.getCodeSigners(JarFile.this, this);

            }

            return signers == null ? null : signers.clone();

        }

    }

    /*

     * Ensures that the JarVerifier has been created if one is

     * necessary (i.e., the jar appears to be signed.) This is done as

     * a quick check to avoid processing of the manifest for unsigned

     * jars.

     */

    private void maybeInstantiateVerifier() throws IOException {

        if (jv != null) {

            return;

        }

        if (verify) {

            String[] names = getMetaInfEntryNames();

            if (names != null) {

                for (String nameLower : names) {

                    String name = nameLower.toUpperCase(Locale.ENGLISH);

                    if (name.endsWith(".DSA") ||

                        name.endsWith(".RSA") ||

                        name.endsWith(".EC") ||

                        name.endsWith(".SF")) {

                        // Assume since we found a signature-related file

                        // that the jar is signed and that we therefore

                        // need a JarVerifier and Manifest

                        getManifest();

                        return;

                    }

                }

            }

            // No signature-related files; don't instantiate a

            // verifier

            verify = false;

        }

    }

    /*

     * Initializes the verifier object by reading all the manifest

     * entries and passing them to the verifier.

     */

    private void initializeVerifier() {

        ManifestEntryVerifier mev = null;

        // Verify "META-INF/" entries...

        try {

            String[] names = getMetaInfEntryNames();

            if (names != null) {

                for (String name : names) {

                    String uname = name.toUpperCase(Locale.ENGLISH);

                    if (MANIFEST_NAME.equals(uname)

                            || SignatureFileVerifier.isBlockOrSF(uname)) {

                        JarEntry e = getJarEntry(name);

                        if (e == null) {

                            throw new JarException("corrupted jar file");

                        }

                        if (mev == null) {

                            mev = new ManifestEntryVerifier

                                (getManifestFromReference());

                        }

                        byte[] b = getBytes(e);

                        if (b != null && b.length > 0) {

                            jv.beginEntry(e, mev);

                            jv.update(b.length, b, 0, b.length, mev);

                            jv.update(-1, null, 0, 0, mev);

                        }

                    }

                }

            }

        } catch (IOException ex) {

            // if we had an error parsing any blocks, just

            // treat the jar file as being unsigned

            jv = null;

            verify = false;

            if (JarVerifier.debug != null) {

                JarVerifier.debug.println("jarfile parsing error!");

                ex.printStackTrace();

            }

        }

        // if after initializing the verifier we have nothing

        // signed, we null it out.

        if (jv != null) {

            jv.doneWithMeta();

            if (JarVerifier.debug != null) {

                JarVerifier.debug.println("done with meta!");

            }

            if (jv.nothingToVerify()) {

                if (JarVerifier.debug != null) {

                    JarVerifier.debug.println("nothing to verify!");

                }

                jv = null;

                verify = false;

            }

        }

    }

    /*

     * Reads all the bytes for a given entry. Used to process the

     * META-INF files.

     */

    private byte[] getBytes(ZipEntry ze) throws IOException {

        try (InputStream is = super.getInputStream(ze)) {

            int len = (int)ze.getSize();

            int bytesRead;

            byte[] b;

            // trust specified entry sizes when reasonably small

            if (len != -1 && len <= 65535) {

                b = new byte[len];

                bytesRead = is.readNBytes(b, 0, len);

            } else {

                b = is.readAllBytes();

                bytesRead = b.length;

            }

            if (len != -1 && len != bytesRead) {

                throw new EOFException("Expected:" + len + ", read:" + bytesRead);

            }

            return b;

        }

    }

    /**

     * Returns an input stream for reading the contents of the specified

     * zip file entry.

     * @param ze the zip file entry

     * @return an input stream for reading the contents of the specified

     *         zip file entry

     * @throws ZipException if a zip file format error has occurred

     * @throws IOException if an I/O error has occurred

     * @throws SecurityException if any of the jar file entries

     *         are incorrectly signed.

     * @throws IllegalStateException

     *         may be thrown if the jar file has been closed

     */

    public synchronized InputStream getInputStream(ZipEntry ze)

        throws IOException

    {

        maybeInstantiateVerifier();

        if (jv == null) {

            return super.getInputStream(ze);

        }

        if (!jvInitialized) {

            initializeVerifier();

            jvInitialized = true;

            // could be set to null after a call to

            // initializeVerifier if we have nothing to

            // verify

            if (jv == null)

                return super.getInputStream(ze);

        }

        // wrap a verifier stream around the real stream

        return new JarVerifier.VerifierStream(

            getManifestFromReference(),

            ze instanceof JarFileEntry ?

            (JarEntry) ze : getJarEntry(ze.getName()),

            super.getInputStream(ze),

            jv);

    }

    // Statics for hand-coded Boyer-Moore search

    private static final char[] CLASSPATH_CHARS = {'c','l','a','s','s','-','p','a','t','h'};

    // The bad character shift for "class-path"

    private static final int[] CLASSPATH_LASTOCC;

    // The good suffix shift for "class-path"

    private static final int[] CLASSPATH_OPTOSFT;

    static {

        CLASSPATH_LASTOCC = new int[128];

        CLASSPATH_OPTOSFT = new int[10];

        CLASSPATH_LASTOCC[(int)'c'] = 1;

        CLASSPATH_LASTOCC[(int)'l'] = 2;