/*

 * Copyright (c) 1999, 2018, 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 sun.security.pkcs12;

import java.io.*;

import java.security.AccessController;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.security.Key;

import java.security.KeyFactory;

import java.security.KeyStore;

import java.security.KeyStoreSpi;

import java.security.KeyStoreException;

import java.security.PKCS12Attribute;

import java.security.PrivateKey;

import java.security.PrivilegedAction;

import java.security.UnrecoverableEntryException;

import java.security.UnrecoverableKeyException;

import java.security.SecureRandom;

import java.security.Security;

import java.security.cert.Certificate;

import java.security.cert.CertificateFactory;

import java.security.cert.X509Certificate;

import java.security.cert.CertificateException;

import java.security.spec.AlgorithmParameterSpec;

import java.security.spec.InvalidParameterSpecException;

import java.security.spec.KeySpec;

import java.security.spec.PKCS8EncodedKeySpec;

import java.util.*;

import java.security.AlgorithmParameters;

import java.security.InvalidAlgorithmParameterException;

import java.security.InvalidKeyException;

import javax.crypto.spec.PBEParameterSpec;

import javax.crypto.spec.PBEKeySpec;

import javax.crypto.spec.SecretKeySpec;

import javax.crypto.SecretKeyFactory;

import javax.crypto.SecretKey;

import javax.crypto.Cipher;

import javax.crypto.Mac;

import javax.security.auth.DestroyFailedException;

import javax.security.auth.x500.X500Principal;

import sun.security.util.Debug;

import sun.security.util.DerInputStream;

import sun.security.util.DerOutputStream;

import sun.security.util.DerValue;

import sun.security.util.ObjectIdentifier;

import sun.security.pkcs.ContentInfo;

import sun.security.x509.AlgorithmId;

import sun.security.pkcs.EncryptedPrivateKeyInfo;

import sun.security.provider.JavaKeyStore.JKS;

import sun.security.util.KeyStoreDelegator;

/**

 * This class provides the keystore implementation referred to as "PKCS12".

 * Implements the PKCS#12 PFX protected using the Password privacy mode.

 * The contents are protected using Password integrity mode.

 *

 * Currently we support following PBE algorithms:

 *  - pbeWithSHAAnd3KeyTripleDESCBC to encrypt private keys

 *  - pbeWithSHAAnd40BitRC2CBC to encrypt certificates

 *

 * Supported encryption of various implementations :

 *

 * Software and mode.     Certificate encryption  Private key encryption

 * ---------------------------------------------------------------------

 * MSIE4 (domestic            40 bit RC2.            40 bit RC2

 * and xport versions)

 * PKCS#12 export.

 *

 * MSIE4, 5 (domestic         40 bit RC2,            40 bit RC2,

 * and export versions)       3 key triple DES       3 key triple DES

 * PKCS#12 import.

 *

 * MSIE5                      40 bit RC2             3 key triple DES,

 * PKCS#12 export.                                   with SHA1 (168 bits)

 *

 * Netscape Communicator      40 bit RC2             3 key triple DES,

 * (domestic and export                              with SHA1 (168 bits)

 * versions) PKCS#12 export

 *

 * Netscape Communicator      40 bit ciphers only    All.

 * (export version)

 * PKCS#12 import.

 *

 * Netscape Communicator      All.                   All.

 * (domestic or fortified

 * version) PKCS#12 import.

 *

 * OpenSSL PKCS#12 code.      All.                   All.

 * ---------------------------------------------------------------------

 *

 * NOTE: PKCS12 KeyStore supports PrivateKeyEntry and TrustedCertficateEntry.

 * PKCS#12 is mainly used to deliver private keys with their associated

 * certificate chain and aliases. In a PKCS12 keystore, entries are

 * identified by the alias, and a localKeyId is required to match the

 * private key with the certificate. Trusted certificate entries are identified

 * by the presence of an trustedKeyUsage attribute.

 *

 * @author Seema Malkani

 * @author Jeff Nisewanger

 * @author Jan Luehe

 *

 * @see KeyProtector

 * @see java.security.KeyStoreSpi

 * @see KeyTool

 *

 *

 */

public final class PKCS12KeyStore extends KeyStoreSpi {

    // special PKCS12 keystore that supports PKCS12 and JKS file formats

    public static final class DualFormatPKCS12 extends KeyStoreDelegator {

        public DualFormatPKCS12() {

            super("PKCS12", PKCS12KeyStore.class, "JKS", JKS.class);

        }

    }

    public static final int VERSION_3 = 3;

    private static final String[] KEY_PROTECTION_ALGORITHM = {

        "keystore.pkcs12.keyProtectionAlgorithm",

        "keystore.PKCS12.keyProtectionAlgorithm"

    };

    private static final int MAX_ITERATION_COUNT = 5000000;

    private static final int PBE_ITERATION_COUNT = 50000; // default

    private static final int MAC_ITERATION_COUNT = 100000; // default

    private static final int SALT_LEN = 20;

    // friendlyName, localKeyId, trustedKeyUsage

    private static final String[] CORE_ATTRIBUTES = {

        "1.2.840.113549.1.9.20",

        "1.2.840.113549.1.9.21",

        "2.16.840.1.113894.746875.1.1"

    };

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

    private static final int[] keyBag  = {1, 2, 840, 113549, 1, 12, 10, 1, 2};

    private static final int[] certBag = {1, 2, 840, 113549, 1, 12, 10, 1, 3};

    private static final int[] secretBag = {1, 2, 840, 113549, 1, 12, 10, 1, 5};

    private static final int[] pkcs9Name  = {1, 2, 840, 113549, 1, 9, 20};

    private static final int[] pkcs9KeyId = {1, 2, 840, 113549, 1, 9, 21};

    private static final int[] pkcs9certType = {1, 2, 840, 113549, 1, 9, 22, 1};

    private static final int[] pbeWithSHAAnd40BitRC2CBC =

                                        {1, 2, 840, 113549, 1, 12, 1, 6};

    private static final int[] pbeWithSHAAnd3KeyTripleDESCBC =

                                        {1, 2, 840, 113549, 1, 12, 1, 3};

    private static final int[] pbes2 = {1, 2, 840, 113549, 1, 5, 13};

    // TODO: temporary Oracle OID

    /*

     * { joint-iso-itu-t(2) country(16) us(840) organization(1) oracle(113894)

     *   jdk(746875) crypto(1) id-at-trustedKeyUsage(1) }

     */

    private static final int[] TrustedKeyUsage =

                                        {2, 16, 840, 1, 113894, 746875, 1, 1};

    private static final int[] AnyExtendedKeyUsage = {2, 5, 29, 37, 0};

    private static ObjectIdentifier PKCS8ShroudedKeyBag_OID;

    private static ObjectIdentifier CertBag_OID;

    private static ObjectIdentifier SecretBag_OID;

    private static ObjectIdentifier PKCS9FriendlyName_OID;

    private static ObjectIdentifier PKCS9LocalKeyId_OID;

    private static ObjectIdentifier PKCS9CertType_OID;

    private static ObjectIdentifier pbeWithSHAAnd40BitRC2CBC_OID;

    private static ObjectIdentifier pbeWithSHAAnd3KeyTripleDESCBC_OID;

    private static ObjectIdentifier pbes2_OID;

    private static ObjectIdentifier TrustedKeyUsage_OID;

    private static ObjectIdentifier[] AnyUsage;

    private int counter = 0;

    // private key count

    // Note: This is a workaround to allow null localKeyID attribute

    // in pkcs12 with one private key entry and associated cert-chain

    private int privateKeyCount = 0;

    // secret key count

    private int secretKeyCount = 0;

    // certificate count

    private int certificateCount = 0;

    // the source of randomness

    private SecureRandom random;

    static {

        try {

            PKCS8ShroudedKeyBag_OID = new ObjectIdentifier(keyBag);

            CertBag_OID = new ObjectIdentifier(certBag);

            SecretBag_OID = new ObjectIdentifier(secretBag);

            PKCS9FriendlyName_OID = new ObjectIdentifier(pkcs9Name);

            PKCS9LocalKeyId_OID = new ObjectIdentifier(pkcs9KeyId);

            PKCS9CertType_OID = new ObjectIdentifier(pkcs9certType);

            pbeWithSHAAnd40BitRC2CBC_OID =

                        new ObjectIdentifier(pbeWithSHAAnd40BitRC2CBC);

            pbeWithSHAAnd3KeyTripleDESCBC_OID =

                        new ObjectIdentifier(pbeWithSHAAnd3KeyTripleDESCBC);

            pbes2_OID = new ObjectIdentifier(pbes2);

            TrustedKeyUsage_OID = new ObjectIdentifier(TrustedKeyUsage);

            AnyUsage = new ObjectIdentifier[]{

                new ObjectIdentifier(AnyExtendedKeyUsage)};

        } catch (IOException ioe) {

            // should not happen

        }

    }

    // A keystore entry and associated attributes

    private static class Entry {

        Date date; // the creation date of this entry

        String alias;

        byte[] keyId;

        Set<KeyStore.Entry.Attribute> attributes;

    }

    // A key entry

    private static class KeyEntry extends Entry {

    }

    // A private key entry and its supporting certificate chain

    private static class PrivateKeyEntry extends KeyEntry {

        byte[] protectedPrivKey;

        Certificate[] chain;

    };

    // A secret key

    private static class SecretKeyEntry extends KeyEntry {

        byte[] protectedSecretKey;

    };

    // A certificate entry

    private static class CertEntry extends Entry {

        final X509Certificate cert;

        ObjectIdentifier[] trustedKeyUsage;

        CertEntry(X509Certificate cert, byte[] keyId, String alias) {

            this(cert, keyId, alias, null, null);

        }

        CertEntry(X509Certificate cert, byte[] keyId, String alias,

                ObjectIdentifier[] trustedKeyUsage,

                Set<? extends KeyStore.Entry.Attribute> attributes) {

            this.date = new Date();

            this.cert = cert;

            this.keyId = keyId;

            this.alias = alias;

            this.trustedKeyUsage = trustedKeyUsage;

            this.attributes = new HashSet<>();

            if (attributes != null) {

                this.attributes.addAll(attributes);

            }

        }

    }

    /**

     * Retries an action with password "\0" if "" fails.

     * @param <T> the return type

     */

    @FunctionalInterface

    private interface RetryWithZero<T> {

        T tryOnce(char[] password) throws Exception;

        static <S> S run(RetryWithZero<S> f, char[] password) throws Exception {

            try {

                return f.tryOnce(password);

            } catch (Exception e) {

                if (password.length == 0) {

                    // Retry using an empty password with a NUL terminator.

                    if (debug != null) {

                        debug.println("Retry with a NUL password");

                    }

                    return f.tryOnce(new char[1]);

                }

                throw e;

            }

        }

    }

    /**

     * Private keys and certificates are stored in a map.

     * Map entries are keyed by alias names.

     */

    private Map<String, Entry> entries =

        Collections.synchronizedMap(new LinkedHashMap<String, Entry>());

    private ArrayList<KeyEntry> keyList = new ArrayList<KeyEntry>();

    private LinkedHashMap<X500Principal, X509Certificate> certsMap =

            new LinkedHashMap<X500Principal, X509Certificate>();

    private ArrayList<CertEntry> certEntries = new ArrayList<CertEntry>();

    /**

     * Returns the key associated with the given alias, using the given

     * password to recover it.

     *

     * @param alias the alias name

     * @param password the password for recovering the key

     *

     * @return the requested key, or null if the given alias does not exist

     * or does not identify a <i>key entry</i>.

     *

     * @exception NoSuchAlgorithmException if the algorithm for recovering the

     * key cannot be found

     * @exception UnrecoverableKeyException if the key cannot be recovered

     * (e.g., the given password is wrong).

     */

    public Key engineGetKey(String alias, char[] password)

        throws NoSuchAlgorithmException, UnrecoverableKeyException

    {

        Entry entry = entries.get(alias.toLowerCase(Locale.ENGLISH));

        Key key = null;

        if (entry == null || (!(entry instanceof KeyEntry))) {

            return null;

        }

        // get the encoded private key or secret key

        byte[] encrBytes = null;

        if (entry instanceof PrivateKeyEntry) {

            encrBytes = ((PrivateKeyEntry) entry).protectedPrivKey;

        } else if (entry instanceof SecretKeyEntry) {

            encrBytes = ((SecretKeyEntry) entry).protectedSecretKey;

        } else {

            throw new UnrecoverableKeyException("Error locating key");

        }

        byte[] encryptedKey;

        AlgorithmParameters algParams;

        ObjectIdentifier algOid;

        try {

            // get the encrypted private key

            EncryptedPrivateKeyInfo encrInfo =

                        new EncryptedPrivateKeyInfo(encrBytes);

            encryptedKey = encrInfo.getEncryptedData();

            // parse Algorithm parameters

            DerValue val = new DerValue(encrInfo.getAlgorithm().encode());

            DerInputStream in = val.toDerInputStream();

            algOid = in.getOID();

            algParams = parseAlgParameters(algOid, in);

        } catch (IOException ioe) {

            UnrecoverableKeyException uke =

                new UnrecoverableKeyException("Private key not stored as "

                                 + "PKCS#8 EncryptedPrivateKeyInfo: " + ioe);

            uke.initCause(ioe);

            throw uke;

        }

       try {

            PBEParameterSpec pbeSpec;

            int ic;

            if (algParams != null) {

                try {

                    pbeSpec =

                        algParams.getParameterSpec(PBEParameterSpec.class);

                } catch (InvalidParameterSpecException ipse) {

                    throw new IOException("Invalid PBE algorithm parameters");

                }

                ic = pbeSpec.getIterationCount();

                if (ic > MAX_ITERATION_COUNT) {

                    throw new IOException("PBE iteration count too large");

                }

            } else {

                ic = 0;

            }

            key = RetryWithZero.run(pass -> {

                // Use JCE

                SecretKey skey = getPBEKey(pass);

                Cipher cipher = Cipher.getInstance(

                        mapPBEParamsToAlgorithm(algOid, algParams));

                cipher.init(Cipher.DECRYPT_MODE, skey, algParams);

                byte[] keyInfo = cipher.doFinal(encryptedKey);

                /*

                 * Parse the key algorithm and then use a JCA key factory

                 * to re-create the key.

                 */

                DerValue val = new DerValue(keyInfo);

                DerInputStream in = val.toDerInputStream();

                int i = in.getInteger();

                DerValue[] value = in.getSequence(2);

                AlgorithmId algId = new AlgorithmId(value[0].getOID());

                String keyAlgo = algId.getName();

                // decode private key

                if (entry instanceof PrivateKeyEntry) {

                    KeyFactory kfac = KeyFactory.getInstance(keyAlgo);

                    PKCS8EncodedKeySpec kspec = new PKCS8EncodedKeySpec(keyInfo);

                    Key tmp = kfac.generatePrivate(kspec);

                    if (debug != null) {

                        debug.println("Retrieved a protected private key at alias" +

                                " '" + alias + "' (" +

                                new AlgorithmId(algOid).getName() +

                                " iterations: " + ic + ")");

                    }

                    return tmp;

                    // decode secret key

                } else {

                    byte[] keyBytes = in.getOctetString();

                    SecretKeySpec secretKeySpec =

                            new SecretKeySpec(keyBytes, keyAlgo);

                    // Special handling required for PBE: needs a PBEKeySpec

                    Key tmp;

                    if (keyAlgo.startsWith("PBE")) {

                        SecretKeyFactory sKeyFactory =

                                SecretKeyFactory.getInstance(keyAlgo);

                        KeySpec pbeKeySpec =

                                sKeyFactory.getKeySpec(secretKeySpec, PBEKeySpec.class);

                        tmp = sKeyFactory.generateSecret(pbeKeySpec);

                    } else {

                        tmp = secretKeySpec;

                    }

                    if (debug != null) {

                        debug.println("Retrieved a protected secret key at alias " +

                                "'" + alias + "' (" +

                                new AlgorithmId(algOid).getName() +

                                " iterations: " + ic + ")");

                    }

                    return tmp;

                }

            }, password);

        } catch (Exception e) {

            UnrecoverableKeyException uke =

                new UnrecoverableKeyException("Get Key failed: " +

                                        e.getMessage());

            uke.initCause(e);

            throw uke;

        }

        return key;

    }

    /**

     * Returns the certificate chain associated with the given alias.

     *

     * @param alias the alias name

     *

     * @return the certificate chain (ordered with the user's certificate first

     * and the root certificate authority last), or null if the given alias

     * does not exist or does not contain a certificate chain (i.e., the given

     * alias identifies either a <i>trusted certificate entry</i> or a

     * <i>key entry</i> without a certificate chain).

     */

    public Certificate[] engineGetCertificateChain(String alias) {

        Entry entry = entries.get(alias.toLowerCase(Locale.ENGLISH));

        if (entry != null && entry instanceof PrivateKeyEntry) {

            if (((PrivateKeyEntry) entry).chain == null) {

                return null;

            } else {

                if (debug != null) {

                    debug.println("Retrieved a " +

                        ((PrivateKeyEntry) entry).chain.length +

                        "-certificate chain at alias '" + alias + "'");

                }

                return ((PrivateKeyEntry) entry).chain.clone();

            }

        } else {

            return null;

        }

    }

    /**

     * Returns the certificate associated with the given alias.

     *

     * <p>If the given alias name identifies a

     * <i>trusted certificate entry</i>, the certificate associated with that

     * entry is returned. If the given alias name identifies a

     * <i>key entry</i>, the first element of the certificate chain of that

     * entry is returned, or null if that entry does not have a certificate

     * chain.

     *

     * @param alias the alias name

     *

     * @return the certificate, or null if the given alias does not exist or

     * does not contain a certificate.

     */

    public Certificate engineGetCertificate(String alias) {

        Entry entry = entries.get(alias.toLowerCase(Locale.ENGLISH));

        if (entry == null) {

            return null;

        }

        if (entry instanceof CertEntry &&

            ((CertEntry) entry).trustedKeyUsage != null) {

            if (debug != null) {

                if (Arrays.equals(AnyUsage,

                    ((CertEntry) entry).trustedKeyUsage)) {

                    debug.println("Retrieved a certificate at alias '" + alias +

                        "' (trusted for any purpose)");

                } else {

                    debug.println("Retrieved a certificate at alias '" + alias +

                        "' (trusted for limited purposes)");

                }

            }

            return ((CertEntry) entry).cert;

        } else if (entry instanceof PrivateKeyEntry) {

            if (((PrivateKeyEntry) entry).chain == null) {

                return null;

            } else {

                if (debug != null) {

                    debug.println("Retrieved a certificate at alias '" + alias +

                        "'");

                }

                return ((PrivateKeyEntry) entry).chain[0];

            }

        } else {

            return null;

        }

    }

    /**

     * Returns the creation date of the entry identified by the given alias.

     *

     * @param alias the alias name

     *

     * @return the creation date of this entry, or null if the given alias does

     * not exist

     */

    public Date engineGetCreationDate(String alias) {

        Entry entry = entries.get(alias.toLowerCase(Locale.ENGLISH));

        if (entry != null) {

            return new Date(entry.date.getTime());

        } else {

            return null;

        }

    }

    /**

     * Assigns the given key to the given alias, protecting it with the given

     * password.

     *

     * <p>If the given key is of type <code>java.security.PrivateKey</code>,

     * it must be accompanied by a certificate chain certifying the

     * corresponding public key.

     *

     * <p>If the given alias already exists, the keystore information

     * associated with it is overridden by the given key (and possibly

     * certificate chain).

     *

     * @param alias the alias name

     * @param key the key to be associated with the alias

     * @param password the password to protect the key

     * @param chain the certificate chain for the corresponding public

     * key (only required if the given key is of type

     * <code>java.security.PrivateKey</code>).

     *

     * @exception KeyStoreException if the given key cannot be protected, or

     * this operation fails for some other reason

     */

    public synchronized void engineSetKeyEntry(String alias, Key key,

                        char[] password, Certificate[] chain)

        throws KeyStoreException

    {

        KeyStore.PasswordProtection passwordProtection =

            new KeyStore.PasswordProtection(password);

        try {

            setKeyEntry(alias, key, passwordProtection, chain, null);

        } finally {

            try {

                passwordProtection.destroy();

            } catch (DestroyFailedException dfe) {

                // ignore

            }

        }

    }

    /*

     * Sets a key entry (with attributes, when present)

     */

    private void setKeyEntry(String alias, Key key,

        KeyStore.PasswordProtection passwordProtection, Certificate[] chain,

        Set<KeyStore.Entry.Attribute> attributes)

            throws KeyStoreException

    {

        try {

            Entry entry;

            if (key instanceof PrivateKey) {

                // Check that all the certs are X.509 certs

                checkX509Certs(chain);

                PrivateKeyEntry keyEntry = new PrivateKeyEntry();

                keyEntry.date = new Date();

                if ((key.getFormat().equals("PKCS#8")) ||

                    (key.getFormat().equals("PKCS8"))) {

                    if (debug != null) {

                        debug.println(

                            "Setting a protected private key at alias '" +

                            alias + "'");

                        }

                    // Encrypt the private key

                    keyEntry.protectedPrivKey =

                        encryptPrivateKey(key.getEncoded(), passwordProtection);

                } else {

                    throw new KeyStoreException("Private key is not encoded" +

                                "as PKCS#8");

                }

                // clone the chain

                if (chain != null) {

                    // validate cert-chain

                    if ((chain.length > 1) && (!validateChain(chain)))

                       throw new KeyStoreException("Certificate chain is " +

                                                "not valid");

                    keyEntry.chain = chain.clone();

                    certificateCount += chain.length;

                    if (debug != null) {

                        debug.println("Setting a " + chain.length +

                            "-certificate chain at alias '" + alias + "'");

                    }

                }

                privateKeyCount++;

                entry = keyEntry;

            } else if (key instanceof SecretKey) {

                SecretKeyEntry keyEntry = new SecretKeyEntry();

                keyEntry.date = new Date();

                // Encode secret key in a PKCS#8

                DerOutputStream pkcs8 = new DerOutputStream();

                DerOutputStream secretKeyInfo = new DerOutputStream();

                secretKeyInfo.putInteger(0);

                AlgorithmId algId = AlgorithmId.get(key.getAlgorithm());

                algId.encode(secretKeyInfo);

                secretKeyInfo.putOctetString(key.getEncoded());

                pkcs8.write(DerValue.tag_Sequence, secretKeyInfo);

                // Encrypt the secret key (using same PBE as for private keys)

                keyEntry.protectedSecretKey =

                    encryptPrivateKey(pkcs8.toByteArray(), passwordProtection);

                if (debug != null) {

                    debug.println("Setting a protected secret key at alias '" +

                        alias + "'");

                }

                secretKeyCount++;

                entry = keyEntry;

            } else {

                throw new KeyStoreException("Unsupported Key type");

            }

            entry.attributes = new HashSet<>();

            if (attributes != null) {

                entry.attributes.addAll(attributes);

            }

            // set the keyId to current date

            entry.keyId = ("Time " + (entry.date).getTime()).getBytes("UTF8");

            // set the alias

            entry.alias = alias.toLowerCase(Locale.ENGLISH);

            // add the entry

            entries.put(alias.toLowerCase(Locale.ENGLISH), entry);

        } catch (Exception nsae) {

            throw new KeyStoreException("Key protection " +

                       " algorithm not found: " + nsae, nsae);

        }

    }

    /**

     * Assigns the given key (that has already been protected) to the given

     * alias.

     *

     * <p>If the protected key is of type

     * <code>java.security.PrivateKey</code>, it must be accompanied by a

     * certificate chain certifying the corresponding public key. If the

     * underlying keystore implementation is of type <code>jks</code>,

     * <code>key</code> must be encoded as an

     * <code>EncryptedPrivateKeyInfo</code> as defined in the PKCS #8 standard.

     *

     * <p>If the given alias already exists, the keystore information

     * associated with it is overridden by the given key (and possibly

     * certificate chain).

     *

     * @param alias the alias name

     * @param key the key (in protected format) to be associated with the alias

     * @param chain the certificate chain for the corresponding public

     * key (only useful if the protected key is of type

     * <code>java.security.PrivateKey</code>).

     *

     * @exception KeyStoreException if this operation fails.

     */

    public synchronized void engineSetKeyEntry(String alias, byte[] key,

                                  Certificate[] chain)

        throws KeyStoreException

    {

        // Check that all the certs are X.509 certs

        checkX509Certs(chain);

        // Private key must be encoded as EncryptedPrivateKeyInfo

        // as defined in PKCS#8

        try {

            new EncryptedPrivateKeyInfo(key);

        } catch (IOException ioe) {

            throw new KeyStoreException("Private key is not stored"

                    + " as PKCS#8 EncryptedPrivateKeyInfo: " + ioe, ioe);

        }

        PrivateKeyEntry entry = new PrivateKeyEntry();

        entry.date = new Date();

        if (debug != null) {

            debug.println("Setting a protected private key at alias '" +

                alias + "'");

        }

        try {

            // set the keyId to current date

            entry.keyId = ("Time " + (entry.date).getTime()).getBytes("UTF8");

        } catch (UnsupportedEncodingException ex) {

            // Won't happen

        }

        // set the alias

        entry.alias = alias.toLowerCase(Locale.ENGLISH);

        entry.protectedPrivKey = key.clone();

        if (chain != null) {

            // validate cert-chain

            if ((chain.length > 1) && (!validateChain(chain))) {

                throw new KeyStoreException("Certificate chain is "

                        + "not valid");

            }

            entry.chain = chain.clone();

            certificateCount += chain.length;

            if (debug != null) {

                debug.println("Setting a " + entry.chain.length +

                    "-certificate chain at alias '" + alias + "'");

            }

        }

        // add the entry

        privateKeyCount++;

        entries.put(alias.toLowerCase(Locale.ENGLISH), entry);

    }

    /*

     * Generate random salt

     */

    private byte[] getSalt()

    {

        // Generate a random salt.

        byte[] salt = new byte[SALT_LEN];

        if (random == null) {

           random = new SecureRandom();

        }

        random.nextBytes(salt);

        return salt;

    }

    /*

     * Generate PBE Algorithm Parameters

     */

    private AlgorithmParameters getPBEAlgorithmParameters(String algorithm)

        throws IOException

    {

        AlgorithmParameters algParams = null;

        // create PBE parameters from salt and iteration count

        PBEParameterSpec paramSpec =

                new PBEParameterSpec(getSalt(), PBE_ITERATION_COUNT);

        try {

           algParams = AlgorithmParameters.getInstance(algorithm);

           algParams.init(paramSpec);

        } catch (Exception e) {

           throw new IOException("getPBEAlgorithmParameters failed: " +

                                 e.getMessage(), e);

        }

        return algParams;

    }

    /*

     * parse Algorithm Parameters

     */

    private AlgorithmParameters parseAlgParameters(ObjectIdentifier algorithm,

        DerInputStream in) throws IOException

    {

        AlgorithmParameters algParams = null;

        try {

            DerValue params;

            if (in.available() == 0) {

                params = null;

            } else {

                params = in.getDerValue();

                if (params.tag == DerValue.tag_Null) {

                   params = null;

                }

            }

            if (params != null) {

                if (algorithm.equals(pbes2_OID)) {

                    algParams = AlgorithmParameters.getInstance("PBES2");

                } else {

                    algParams = AlgorithmParameters.getInstance("PBE");

                }

                algParams.init(params.toByteArray());

            }

        } catch (Exception e) {

           throw new IOException("parseAlgParameters failed: " +

                                 e.getMessage(), e);

        }

        return algParams;

    }

    /*

     * Generate PBE key

     */

    private SecretKey getPBEKey(char[] password) throws IOException

    {

        SecretKey skey = null;

        try {

            PBEKeySpec keySpec = new PBEKeySpec(password);

            SecretKeyFactory skFac = SecretKeyFactory.getInstance("PBE");

            skey = skFac.generateSecret(keySpec);

            keySpec.clearPassword();

        } catch (Exception e) {

           throw new IOException("getSecretKey failed: " +

                                 e.getMessage(), e);

        }

        return skey;

    }

    /*

     * Encrypt private key using Password-based encryption (PBE)

     * as defined in PKCS#5.

     *

     * NOTE: By default, pbeWithSHAAnd3-KeyTripleDES-CBC algorithmID is

     *       used to derive the key and IV.

     *

     * @return encrypted private key encoded as EncryptedPrivateKeyInfo

     */

    private byte[] encryptPrivateKey(byte[] data,

        KeyStore.PasswordProtection passwordProtection)

        throws IOException, NoSuchAlgorithmException, UnrecoverableKeyException

    {

        byte[] key = null;

        try {

            String algorithm;

            AlgorithmParameters algParams;

            AlgorithmId algid;

            // Initialize PBE algorithm and parameters

            algorithm = passwordProtection.getProtectionAlgorithm();

            if (algorithm != null) {

                AlgorithmParameterSpec algParamSpec =

                    passwordProtection.getProtectionParameters();

                if (algParamSpec != null) {

                    algParams = AlgorithmParameters.getInstance(algorithm);

                    algParams.init(algParamSpec);

                } else {

                    algParams = getPBEAlgorithmParameters(algorithm);

                }

            } else {

                // Check default key protection algorithm for PKCS12 keystores

                algorithm = AccessController.doPrivileged(

                    new PrivilegedAction<String>() {

                        public String run() {

                            String prop =

                                Security.getProperty(

                                    KEY_PROTECTION_ALGORITHM[0]);

                            if (prop == null) {

                                prop = Security.getProperty(

                                    KEY_PROTECTION_ALGORITHM[1]);

                            }

                            return prop;

                        }

                    });

                if (algorithm == null || algorithm.isEmpty()) {

                    algorithm = "PBEWithSHA1AndDESede";

                }

                algParams = getPBEAlgorithmParameters(algorithm);

            }

            ObjectIdentifier pbeOID = mapPBEAlgorithmToOID(algorithm);

            if (pbeOID == null) {

                    throw new IOException("PBE algorithm '" + algorithm +

                        " 'is not supported for key entry protection");

            }

            // Use JCE

            SecretKey skey = getPBEKey(passwordProtection.getPassword());

            Cipher cipher = Cipher.getInstance(algorithm);

            cipher.init(Cipher.ENCRYPT_MODE, skey, algParams);

            byte[] encryptedKey = cipher.doFinal(data);

            algid = new AlgorithmId(pbeOID, cipher.getParameters());

            if (debug != null) {

                debug.println("  (Cipher algorithm: " + cipher.getAlgorithm() +

                    ")");

            }

            // wrap encrypted private key in EncryptedPrivateKeyInfo

            // as defined in PKCS#8

            EncryptedPrivateKeyInfo encrInfo =

                new EncryptedPrivateKeyInfo(algid, encryptedKey);

            key = encrInfo.getEncoded();

        } catch (Exception e) {

            UnrecoverableKeyException uke =

                new UnrecoverableKeyException("Encrypt Private Key failed: "

                                                + e.getMessage());

            uke.initCause(e);

            throw uke;

        }

        return key;

    }

    /*

     * Map a PBE algorithm name onto its object identifier

     */

    private static ObjectIdentifier mapPBEAlgorithmToOID(String algorithm)

        throws NoSuchAlgorithmException {

        // Check for PBES2 algorithms

        if (algorithm.toLowerCase(Locale.ENGLISH).startsWith("pbewithhmacsha")) {

            return pbes2_OID;

        }

        return AlgorithmId.get(algorithm).getOID();

    }

    /*

     * Map a PBE algorithm parameters onto its algorithm name

     */

    private static String mapPBEParamsToAlgorithm(ObjectIdentifier algorithm,

        AlgorithmParameters algParams) throws NoSuchAlgorithmException {

        // Check for PBES2 algorithms

        if (algorithm.equals(pbes2_OID) && algParams != null) {

            return algParams.toString();

        }

        return algorithm.toString();

    }

    /**

     * Assigns the given certificate to the given alias.

     *

     * <p>If the given alias already exists in this keystore and identifies a

     * <i>trusted certificate entry</i>, the certificate associated with it is

     * overridden by the given certificate.

     *

     * @param alias the alias name

     * @param cert the certificate

     *

     * @exception KeyStoreException if the given alias already exists and does

     * not identify a <i>trusted certificate entry</i>, or this operation fails

     * for some other reason.

     */

    public synchronized void engineSetCertificateEntry(String alias,

        Certificate cert) throws KeyStoreException

    {

        setCertEntry(alias, cert, null);

    }

    /*

     * Sets a trusted cert entry (with attributes, when present)

     */

    private void setCertEntry(String alias, Certificate cert,

        Set<KeyStore.Entry.Attribute> attributes) throws KeyStoreException {

        // Check that the cert is an X.509 cert

        if (cert != null && (!(cert instanceof X509Certificate))) {

            throw new KeyStoreException(

                "Only X.509 certificates are supported - rejecting class: " +

                cert.getClass().getName());

        }

        Entry entry = entries.get(alias.toLowerCase(Locale.ENGLISH));

        if (entry != null && entry instanceof KeyEntry) {

            throw new KeyStoreException("Cannot overwrite own certificate");

        }

        CertEntry certEntry =

            new CertEntry((X509Certificate) cert, null, alias, AnyUsage,

                attributes);

        certificateCount++;

        entries.put(alias.toLowerCase(Locale.ENGLISH), certEntry);

        if (debug != null) {

            debug.println("Setting a trusted certificate at alias '" + alias +

                "'");

        }

    }

    /**

     * Deletes the entry identified by the given alias from this keystore.

     *

     * @param alias the alias name

     *

     * @exception KeyStoreException if the entry cannot be removed.

     */

    public synchronized void engineDeleteEntry(String alias)

        throws KeyStoreException

    {

        if (debug != null) {

            debug.println("Removing entry at alias '" + alias + "'");

        }

        Entry entry = entries.get(alias.toLowerCase(Locale.ENGLISH));

        if (entry instanceof PrivateKeyEntry) {

            PrivateKeyEntry keyEntry = (PrivateKeyEntry) entry;

            if (keyEntry.chain != null) {

                certificateCount -= keyEntry.chain.length;

            }

            privateKeyCount--;

        } else if (entry instanceof CertEntry) {

            certificateCount--;

        } else if (entry instanceof SecretKeyEntry) {

            secretKeyCount--;

        }

        entries.remove(alias.toLowerCase(Locale.ENGLISH));

    }

    /**

     * Lists all the alias names of this keystore.

     *

     * @return enumeration of the alias names

     */

    public Enumeration<String> engineAliases() {

        return Collections.enumeration(entries.keySet());

    }

    /**

     * Checks if the given alias exists in this keystore.

     *

     * @param alias the alias name

     *

     * @return true if the alias exists, false otherwise

     */

    public boolean engineContainsAlias(String alias) {

        return entries.containsKey(alias.toLowerCase(Locale.ENGLISH));

    }

    /**

     * Retrieves the number of entries in this keystore.

     *

     * @return the number of entries in this keystore

     */

    public int engineSize() {

        return entries.size();

    }

    /**

     * Returns true if the entry identified by the given alias is a

     * <i>key entry</i>, and false otherwise.

     *

     * @return true if the entry identified by the given alias is a

     * <i>key entry</i>, false otherwise.

     */

    public boolean engineIsKeyEntry(String alias) {

        Entry entry = entries.get(alias.toLowerCase(Locale.ENGLISH));

        if (entry != null && entry instanceof KeyEntry) {

            return true;

        } else {

            return false;

        }

    }

    /**

     * Returns true if the entry identified by the given alias is a

     * <i>trusted certificate entry</i>, and false otherwise.

     *

     * @return true if the entry identified by the given alias is a

     * <i>trusted certificate entry</i>, false otherwise.

     */

    public boolean engineIsCertificateEntry(String alias) {

        Entry entry = entries.get(alias.toLowerCase(Locale.ENGLISH));

        if (entry != null && entry instanceof CertEntry &&

            ((CertEntry) entry).trustedKeyUsage != null) {

            return true;

        } else {

            return false;

        }

    }

    /**

     * Determines if the keystore {@code Entry} for the specified

     * {@code alias} is an instance or subclass of the specified

     * {@code entryClass}.

     *

     * @param alias the alias name

     * @param entryClass the entry class

     *

     * @return true if the keystore {@code Entry} for the specified

     *          {@code alias} is an instance or subclass of the

     *          specified {@code entryClass}, false otherwise

     *

     * @since 1.5

     */

    @Override

    public boolean

        engineEntryInstanceOf(String alias,

                              Class<? extends KeyStore.Entry> entryClass)

    {

        if (entryClass == KeyStore.TrustedCertificateEntry.class) {

            return engineIsCertificateEntry(alias);

        }

        Entry entry = entries.get(alias.toLowerCase(Locale.ENGLISH));

        if (entryClass == KeyStore.PrivateKeyEntry.class) {

            return (entry != null && entry instanceof PrivateKeyEntry);

        }

        if (entryClass == KeyStore.SecretKeyEntry.class) {

            return (entry != null && entry instanceof SecretKeyEntry);

        }

        return false;

    }

    /**

     * Returns the (alias) name of the first keystore entry whose certificate

     * matches the given certificate.

     *

     * <p>This method attempts to match the given certificate with each

     * keystore entry. If the entry being considered

     * is a <i>trusted certificate entry</i>, the given certificate is

     * compared to that entry's certificate. If the entry being considered is

     * a <i>key entry</i>, the given certificate is compared to the first

     * element of that entry's certificate chain (if a chain exists).

     *

     * @param cert the certificate to match with.

     *

     * @return the (alias) name of the first entry with matching certificate,

     * or null if no such entry exists in this keystore.

     */

    public String engineGetCertificateAlias(Certificate cert) {

        Certificate certElem = null;

        for (Enumeration<String> e = engineAliases(); e.hasMoreElements(); ) {

            String alias = e.nextElement();

            Entry entry = entries.get(alias);

            if (entry instanceof PrivateKeyEntry) {

                if (((PrivateKeyEntry) entry).chain != null) {

                    certElem = ((PrivateKeyEntry) entry).chain[0];

                }

            } else if (entry instanceof CertEntry &&

                    ((CertEntry) entry).trustedKeyUsage != null) {

                certElem = ((CertEntry) entry).cert;

            } else {

                continue;

            }

            if (certElem != null && certElem.equals(cert)) {

                return alias;

            }

        }

        return null;

    }

    /**

     * Stores this keystore to the given output stream, and protects its

     * integrity with the given password.

     *

     * @param stream the output stream to which this keystore is written.

     * @param password the password to generate the keystore integrity check

     *

     * @exception IOException if there was an I/O problem with data

     * @exception NoSuchAlgorithmException if the appropriate data integrity

     * algorithm could not be found

     * @exception CertificateException if any of the certificates included in

     * the keystore data could not be stored

     */

    public synchronized void engineStore(OutputStream stream, char[] password)

        throws IOException, NoSuchAlgorithmException, CertificateException

    {

        // password is mandatory when storing

        if (password == null) {

           throw new IllegalArgumentException("password can't be null");

        }

        // -- Create PFX

        DerOutputStream pfx = new DerOutputStream();

        // PFX version (always write the latest version)

        DerOutputStream version = new DerOutputStream();

        version.putInteger(VERSION_3);

        byte[] pfxVersion = version.toByteArray();

        pfx.write(pfxVersion);

        // -- Create AuthSafe

        DerOutputStream authSafe = new DerOutputStream();

        // -- Create ContentInfos

        DerOutputStream authSafeContentInfo = new DerOutputStream();

        // -- create safeContent Data ContentInfo

        if (privateKeyCount > 0 || secretKeyCount > 0) {

            if (debug != null) {

                debug.println("Storing " + (privateKeyCount + secretKeyCount) +

                    " protected key(s) in a PKCS#7 data");

            }

            byte[] safeContentData = createSafeContent();

            ContentInfo dataContentInfo = new ContentInfo(safeContentData);

            dataContentInfo.encode(authSafeContentInfo);

        }

        // -- create EncryptedContentInfo

        if (certificateCount > 0) {

            if (debug != null) {

                debug.println("Storing " + certificateCount +

                    " certificate(s) in a PKCS#7 encryptedData");

            }

            byte[] encrData = createEncryptedData(password);

            ContentInfo encrContentInfo =

                new ContentInfo(ContentInfo.ENCRYPTED_DATA_OID,

                                new DerValue(encrData));

            encrContentInfo.encode(authSafeContentInfo);

        }

        // wrap as SequenceOf ContentInfos

        DerOutputStream cInfo = new DerOutputStream();

        cInfo.write(DerValue.tag_SequenceOf, authSafeContentInfo);

        byte[] authenticatedSafe = cInfo.toByteArray();

        // Create Encapsulated ContentInfo

        ContentInfo contentInfo = new ContentInfo(authenticatedSafe);

        contentInfo.encode(authSafe);

        byte[] authSafeData = authSafe.toByteArray();

        pfx.write(authSafeData);

        // -- MAC

        byte[] macData = calculateMac(password, authenticatedSafe);

        pfx.write(macData);

        // write PFX to output stream

        DerOutputStream pfxout = new DerOutputStream();

        pfxout.write(DerValue.tag_Sequence, pfx);

        byte[] pfxData = pfxout.toByteArray();

        stream.write(pfxData);

        stream.flush();

    }

    /**

     * Gets a <code>KeyStore.Entry</code> for the specified alias

     * with the specified protection parameter.