/*

 * Copyright (c) 1999, 2021, 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 static java.nio.charset.StandardCharsets.UTF_8;

import java.security.AlgorithmParameters;

import java.security.InvalidAlgorithmParameterException;

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 jdk.internal.access.SharedSecrets;

import sun.security.action.GetPropertyAction;

import sun.security.tools.KeyStoreUtil;

import sun.security.util.*;

import sun.security.pkcs.ContentInfo;

import sun.security.x509.AlgorithmId;

import sun.security.pkcs.EncryptedPrivateKeyInfo;

import sun.security.provider.JavaKeyStore.JKS;

import sun.security.x509.AuthorityKeyIdentifierExtension;

/**

 * 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.

 *

 * NOTE: 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 java.security.KeyStoreSpi

 */

public final class PKCS12KeyStore extends KeyStoreSpi {

    // Hardcoded defaults. They should be the same with commented out

    // lines inside the java.security file.

    private static final String DEFAULT_CERT_PBE_ALGORITHM

            = "PBEWithHmacSHA256AndAES_256";

    private static final String DEFAULT_KEY_PBE_ALGORITHM

            = "PBEWithHmacSHA256AndAES_256";

    private static final String DEFAULT_MAC_ALGORITHM = "HmacPBESHA256";

    private static final int DEFAULT_CERT_PBE_ITERATION_COUNT = 10000;

    private static final int DEFAULT_KEY_PBE_ITERATION_COUNT = 10000;

    private static final int DEFAULT_MAC_ITERATION_COUNT = 10000;

    // Legacy settings. Used when "keystore.pkcs12.legacy" is set.

    private static final String LEGACY_CERT_PBE_ALGORITHM

            = "PBEWithSHA1AndRC2_40";

    private static final String LEGACY_KEY_PBE_ALGORITHM

            = "PBEWithSHA1AndDESede";

    private static final String LEGACY_MAC_ALGORITHM = "HmacPBESHA1";

    private static final int LEGACY_PBE_ITERATION_COUNT = 50000;

    private static final int LEGACY_MAC_ITERATION_COUNT = 100000;

    // Big switch. When this system property is set. Legacy settings

    // are used no matter what other keystore.pkcs12.* properties are set.

    // Note: This is only a system property, there's no same-name

    // security property defined.

    private static final String USE_LEGACY_PROP = "keystore.pkcs12.legacy";

    // 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 int MAX_ITERATION_COUNT = 5000000;

    private static final int SALT_LEN = 20;

    private static final KnownOIDs[] CORE_ATTRIBUTES = {

        KnownOIDs.FriendlyName,

        KnownOIDs.LocalKeyID,

        KnownOIDs.ORACLE_TrustedKeyUsage

    };

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

    private static final ObjectIdentifier PKCS8ShroudedKeyBag_OID =

            ObjectIdentifier.of(KnownOIDs.PKCS8ShroudedKeyBag);

    private static final ObjectIdentifier CertBag_OID =

            ObjectIdentifier.of(KnownOIDs.CertBag);

    private static final ObjectIdentifier SecretBag_OID =

            ObjectIdentifier.of(KnownOIDs.SecretBag);

    private static final ObjectIdentifier PKCS9FriendlyName_OID =

            ObjectIdentifier.of(KnownOIDs.FriendlyName);

    private static final ObjectIdentifier PKCS9LocalKeyId_OID =

            ObjectIdentifier.of(KnownOIDs.LocalKeyID);

    private static final ObjectIdentifier PKCS9CertType_OID =

            ObjectIdentifier.of(KnownOIDs.CertTypeX509);

    private static final ObjectIdentifier pbes2_OID =

            ObjectIdentifier.of(KnownOIDs.PBES2);

    /*

     * 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 ObjectIdentifier TrustedKeyUsage_OID =

            ObjectIdentifier.of(KnownOIDs.ORACLE_TrustedKeyUsage);

    private static final ObjectIdentifier[] AnyUsage = new ObjectIdentifier[] {

                ObjectIdentifier.of(KnownOIDs.anyExtendedKeyUsage)

            };

    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;

    // Alg/params used for *this* keystore. Initialized as -1 for ic and

    // null for algorithm names. When an existing file is read, they will be

    // assigned inside engineLoad() so storing an existing keystore uses the

    // old alg/params. This makes sure if a keystore is created password-less

    // it will be password-less forever. Otherwise, engineStore() will read

    // the default values. These fields are always reset when load() is called.

    private String certProtectionAlgorithm = null;

    private int certPbeIterationCount = -1;

    private String macAlgorithm = null;

    private int macIterationCount = -1;

    // the source of randomness

    private SecureRandom random;

    // 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 List<X509Certificate> allCerts = new ArrayList<>();

    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("key PBE iteration count too large");

                }

            } else {

                ic = 0;

            }

            key = RetryWithZero.run(pass -> {

                // Use JCE

                Cipher cipher = Cipher.getInstance(

                        mapPBEParamsToAlgorithm(algOid, algParams));

                SecretKey skey = getPBEKey(pass);

                try {

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

                } finally {

                    destroyPBEKey(skey);

                }

                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);

                try {

                    DerInputStream in = val.toDerInputStream();

                    int i = in.getInteger();

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

                    if (value.length < 1 || value.length > 2) {

                        throw new IOException("Invalid length for AlgorithmIdentifier");

                    }

                    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);

                        try {

                            Key tmp = kfac.generatePrivate(kspec);

                            if (debug != null) {

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

                                        " '" + alias + "' (" +

                                        mapPBEParamsToAlgorithm(algOid, algParams) +

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

                            }

                            return tmp;

                        } finally {

                            SharedSecrets.getJavaSecuritySpecAccess()

                                    .clearEncodedKeySpec(kspec);

                        }

                        // decode secret key

                    } else {

                        byte[] keyBytes = in.getOctetString();

                        SecretKeySpec secretKeySpec =

                                new SecretKeySpec(keyBytes, keyAlgo);

                        try {

                            // 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);

                                try {

                                    tmp = sKeyFactory.generateSecret(pbeKeySpec);

                                } finally {

                                    ((PBEKeySpec)pbeKeySpec).clearPassword();

                                    SharedSecrets.getJavaxCryptoSpecAccess()

                                            .clearSecretKeySpec(secretKeySpec);

                                }

                            } else {

                                tmp = secretKeySpec;

                            }

                            if (debug != null) {

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

                                        "'" + alias + "' (" +

                                        mapPBEParamsToAlgorithm(algOid, algParams) +

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

                            }

                            return tmp;

                        } finally {

                            Arrays.fill(keyBytes, (byte)0);

                        }

                    }

                } finally {

                    val.clear();

                    Arrays.fill(keyInfo, (byte) 0);

                }

            }, 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

                    byte[] encoded = key.getEncoded();

                    try {

                        keyEntry.protectedPrivKey =

                                encryptPrivateKey(encoded, passwordProtection);

                    } finally {

                        if (encoded != null) {

                            Arrays.fill(encoded, (byte) 0);

                        }

                    }

                } 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 secretKeyInfo = new DerOutputStream();

                secretKeyInfo.putInteger(0);

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

                algId.encode(secretKeyInfo);

                byte[] encoded = key.getEncoded();

                secretKeyInfo.putOctetString(encoded);

                Arrays.fill(encoded, (byte)0);

                DerValue pkcs8 = DerValue.wrap(DerValue.tag_Sequence, secretKeyInfo);

                byte[] p8Array = pkcs8.toByteArray();

                pkcs8.clear();

                try {

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

                    keyEntry.protectedSecretKey =

                            encryptPrivateKey(p8Array, passwordProtection);

                } finally {

                    Arrays.fill(p8Array, (byte)0);

                }

                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(UTF_8);

            // set the alias

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

            // add the entry

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

        } catch (KeyStoreException kse) {

            throw kse;

        } 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 + "'");

        }

        // set the keyId to current date

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

        // 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, int iterationCount) throws IOException {

        AlgorithmParameters algParams;

        byte[] salt = getSalt();

        if (KnownOIDs.findMatch(algorithm) == KnownOIDs.PBEWithMD5AndDES) {

            // PBES1 scheme such as PBEWithMD5AndDES requires a 8-byte salt

            salt = Arrays.copyOf(salt, 8);

        }

        // create PBE parameters from salt and iteration count

        PBEParameterSpec paramSpec =

                new PBEParameterSpec(salt, iterationCount);

        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;

    }

    /*

     * Destroy the key obtained from getPBEKey().

     */

    private void destroyPBEKey(SecretKey key) {

        try {

            key.destroy();

        } catch (DestroyFailedException e) {

            // Accept this

        }

    }

    /*

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

     * as defined in PKCS#5.

     *

     * @return encrypted private key or secret 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,

                            defaultKeyPbeIterationCount());

                }

            } else {

                // Check default key protection algorithm for PKCS12 keystores

                algorithm = defaultKeyProtectionAlgorithm();

                algParams = getPBEAlgorithmParameters(algorithm,

                        defaultKeyPbeIterationCount());

            }

            ObjectIdentifier pbeOID = mapPBEAlgorithmToOID(algorithm);

            if (pbeOID == null) {

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

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

            }

            // Use JCE

            Cipher cipher = Cipher.getInstance(algorithm);

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

            try {

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

            } finally {

                destroyPBEKey(skey);

            }

            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 new AlgorithmId(algorithm).getName();

    }

    /**

     * 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

    {

        // -- 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 (certProtectionAlgorithm == null) {

                certProtectionAlgorithm = defaultCertProtectionAlgorithm();

            }

            if (certPbeIterationCount < 0) {

                certPbeIterationCount = defaultCertPbeIterationCount();

            }

            if (debug != null) {

                debug.println("Storing " + certificateCount +

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

            }

            byte[] encrData = createEncryptedData(password);

            if (!certProtectionAlgorithm.equalsIgnoreCase("NONE")) {

                ContentInfo encrContentInfo =

                        new ContentInfo(ContentInfo.ENCRYPTED_DATA_OID,

                                new DerValue(encrData));

                encrContentInfo.encode(authSafeContentInfo);

            } else {

                ContentInfo dataContentInfo = new ContentInfo(encrData);

                dataContentInfo.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

        if (macAlgorithm == null) {

            macAlgorithm = defaultMacAlgorithm();

        }

        if (macIterationCount < 0) {

            macIterationCount = defaultMacIterationCount();

        }

        if (!macAlgorithm.equalsIgnoreCase("NONE")) {

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

            pfx.write(macData);

        }

        // write PFX to output stream

        DerOutputStream pfxout = new DerOutputStream();

        pfxout.write(DerValue.tag_Sequence, pfx);