/*

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

import java.io.*;

import java.util.*;

import java.security.*;

import sun.security.util.*;

/**

 * This class identifies algorithms, such as cryptographic transforms, each

 * of which may be associated with parameters.  Instances of this base class

 * are used when this runtime environment has no special knowledge of the

 * algorithm type, and may also be used in other cases.  Equivalence is

 * defined according to OID and (where relevant) parameters.

 *

 * <P>Subclasses may be used, for example when when the algorithm ID has

 * associated parameters which some code (e.g. code using public keys) needs

 * to have parsed.  Two examples of such algorithms are Diffie-Hellman key

 * exchange, and the Digital Signature Standard Algorithm (DSS/DSA).

 *

 * <P>The OID constants defined in this class correspond to some widely

 * used algorithms, for which conventional string names have been defined.

 * This class is not a general repository for OIDs, or for such string names.

 * Note that the mappings between algorithm IDs and algorithm names is

 * not one-to-one.

 *

 *

 * @author David Brownell

 * @author Amit Kapoor

 * @author Hemma Prafullchandra

 */

public class AlgorithmId implements Serializable, DerEncoder {

    /** use serialVersionUID from JDK 1.1. for interoperability */

    private static final long serialVersionUID = 7205873507486557157L;

    /**

     * The object identitifer being used for this algorithm.

     */

    private ObjectIdentifier algid;

    // The (parsed) parameters

    private AlgorithmParameters algParams;

    private boolean constructedFromDer = true;

    /**

     * Parameters for this algorithm.  These are stored in unparsed

     * DER-encoded form; subclasses can be made to automaticaly parse

     * them so there is fast access to these parameters.

     */

    protected DerValue          params;

    /**

     * Constructs an algorithm ID which will be initialized

     * separately, for example by deserialization.

     * @deprecated use one of the other constructors.

     */

    @Deprecated

    public AlgorithmId() { }

    /**

     * Constructs a parameterless algorithm ID.

     *

     * @param oid the identifier for the algorithm

     */

    public AlgorithmId(ObjectIdentifier oid) {

        algid = oid;

    }

    /**

     * Constructs an algorithm ID with algorithm parameters.

     *

     * @param oid the identifier for the algorithm.

     * @param algparams the associated algorithm parameters.

     */

    public AlgorithmId(ObjectIdentifier oid, AlgorithmParameters algparams) {

        algid = oid;

        algParams = algparams;

        constructedFromDer = false;

    }

    private AlgorithmId(ObjectIdentifier oid, DerValue params)

            throws IOException {

        this.algid = oid;

        this.params = params;

        if (this.params != null) {

            decodeParams();

        }

    }

    protected void decodeParams() throws IOException {

        String algidString = algid.toString();

        try {

            algParams = AlgorithmParameters.getInstance(algidString);

        } catch (NoSuchAlgorithmException e) {

            /*

             * This algorithm parameter type is not supported, so we cannot

             * parse the parameters.

             */

            algParams = null;

            return;

        }

        // Decode (parse) the parameters

        algParams.init(params.toByteArray());

    }

    /**

     * Marshal a DER-encoded "AlgorithmID" sequence on the DER stream.

     */

    public final void encode(DerOutputStream out) throws IOException {

        derEncode(out);

    }

    /**

     * DER encode this object onto an output stream.

     * Implements the <code>DerEncoder</code> interface.

     *

     * @param out

     * the output stream on which to write the DER encoding.

     *

     * @exception IOException on encoding error.

     */

    public void derEncode (OutputStream out) throws IOException {

        DerOutputStream bytes = new DerOutputStream();

        DerOutputStream tmp = new DerOutputStream();

        bytes.putOID(algid);

        // Setup params from algParams since no DER encoding is given

        if (constructedFromDer == false) {

            if (algParams != null) {

                params = new DerValue(algParams.getEncoded());

            } else {

                params = null;

            }

        }

        if (params == null) {

            // Changes backed out for compatibility with Solaris

            // Several AlgorithmId should omit the whole parameter part when

            // it's NULL. They are ---

            // rfc3370 2.1: Implementations SHOULD generate SHA-1

            // AlgorithmIdentifiers with absent parameters.

            // rfc3447 C1: When id-sha1, id-sha224, id-sha256, id-sha384 and

            // id-sha512 are used in an AlgorithmIdentifier the parameters

            // (which are optional) SHOULD be omitted.

            // rfc3279 2.3.2: The id-dsa algorithm syntax includes optional

            // domain parameters... When omitted, the parameters component

            // MUST be omitted entirely

            // rfc3370 3.1: When the id-dsa-with-sha1 algorithm identifier

            // is used, the AlgorithmIdentifier parameters field MUST be absent.

            /*if (

                algid.equals((Object)SHA_oid) ||

                algid.equals((Object)SHA224_oid) ||

                algid.equals((Object)SHA256_oid) ||

                algid.equals((Object)SHA384_oid) ||

                algid.equals((Object)SHA512_oid) ||

                algid.equals((Object)DSA_oid) ||

                algid.equals((Object)sha1WithDSA_oid)) {

                ; // no parameter part encoded

            } else {

                bytes.putNull();

            }*/

            bytes.putNull();

        } else {

            bytes.putDerValue(params);

        }

        tmp.write(DerValue.tag_Sequence, bytes);

        out.write(tmp.toByteArray());

    }

    /**

     * Returns the DER-encoded X.509 AlgorithmId as a byte array.

     */

    public final byte[] encode() throws IOException {

        DerOutputStream out = new DerOutputStream();

        derEncode(out);

        return out.toByteArray();

    }

    /**

     * Returns the ISO OID for this algorithm.  This is usually converted

     * to a string and used as part of an algorithm name, for example

     * "OID.1.3.14.3.2.13" style notation.  Use the <code>getName</code>

     * call when you do not need to ensure cross-system portability

     * of algorithm names, or need a user friendly name.

     */

    public final ObjectIdentifier getOID () {

        return algid;

    }

    /**

     * Returns a name for the algorithm which may be more intelligible

     * to humans than the algorithm's OID, but which won't necessarily

     * be comprehensible on other systems.  For example, this might

     * return a name such as "MD5withRSA" for a signature algorithm on

     * some systems.  It also returns names like "OID.1.2.3.4", when

     * no particular name for the algorithm is known.

     */

    public String getName() {

        String algName = nameTable.get(algid);

        if (algName != null) {

            return algName;

        }

        if ((params != null) && algid.equals((Object)specifiedWithECDSA_oid)) {

            try {

                AlgorithmId paramsId =

                        AlgorithmId.parse(new DerValue(getEncodedParams()));

                String paramsName = paramsId.getName();

                algName = makeSigAlg(paramsName, "EC");

            } catch (IOException e) {

                // ignore

            }

        }

        return (algName == null) ? algid.toString() : algName;

    }

    public AlgorithmParameters getParameters() {

        return algParams;

    }

    /**

     * Returns the DER encoded parameter, which can then be

     * used to initialize java.security.AlgorithmParamters.

     *

     * @return DER encoded parameters, or null not present.

     */

    public byte[] getEncodedParams() throws IOException {

        return (params == null) ? null : params.toByteArray();

    }

    /**

     * Returns true iff the argument indicates the same algorithm

     * with the same parameters.

     */

    public boolean equals(AlgorithmId other) {

        boolean paramsEqual =

          (params == null ? other.params == null : params.equals(other.params));

        return (algid.equals((Object)other.algid) && paramsEqual);

    }

    /**

     * Compares this AlgorithmID to another.  If algorithm parameters are

     * available, they are compared.  Otherwise, just the object IDs

     * for the algorithm are compared.

     *

     * @param other preferably an AlgorithmId, else an ObjectIdentifier

     */

    public boolean equals(Object other) {

        if (this == other) {

            return true;

        }

        if (other instanceof AlgorithmId) {

            return equals((AlgorithmId) other);

        } else if (other instanceof ObjectIdentifier) {

            return equals((ObjectIdentifier) other);

        } else {

            return false;

        }

    }

    /**

     * Compares two algorithm IDs for equality.  Returns true iff

     * they are the same algorithm, ignoring algorithm parameters.

     */

    public final boolean equals(ObjectIdentifier id) {

        return algid.equals((Object)id);

    }

    /**

     * Returns a hashcode for this AlgorithmId.

     *

     * @return a hashcode for this AlgorithmId.

     */

    public int hashCode() {

        StringBuilder sbuf = new StringBuilder();

        sbuf.append(algid.toString());

        sbuf.append(paramsToString());

        return sbuf.toString().hashCode();

    }

    /**

     * Provides a human-readable description of the algorithm parameters.

     * This may be redefined by subclasses which parse those parameters.

     */

    protected String paramsToString() {

        if (params == null) {

            return "";

        } else if (algParams != null) {

            return algParams.toString();

        } else {

            return ", params unparsed";

        }

    }

    /**

     * Returns a string describing the algorithm and its parameters.

     */

    public String toString() {

        return getName() + paramsToString();

    }

    /**

     * Parse (unmarshal) an ID from a DER sequence input value.  This form

     * parsing might be used when expanding a value which has already been

     * partially unmarshaled as a set or sequence member.

     *

     * @exception IOException on error.

     * @param val the input value, which contains the algid and, if

     *          there are any parameters, those parameters.

     * @return an ID for the algorithm.  If the system is configured

     *          appropriately, this may be an instance of a class

     *          with some kind of special support for this algorithm.

     *          In that case, you may "narrow" the type of the ID.

     */

    public static AlgorithmId parse(DerValue val) throws IOException {

        if (val.tag != DerValue.tag_Sequence) {

            throw new IOException("algid parse error, not a sequence");

        }

        /*

         * Get the algorithm ID and any parameters.

         */

        ObjectIdentifier        algid;

        DerValue                params;

        DerInputStream          in = val.toDerInputStream();

        algid = in.getOID();

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

            params = null;

        } else {

            params = in.getDerValue();

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

                if (params.length() != 0) {

                    throw new IOException("invalid NULL");

                }

                params = null;

            }

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

                throw new IOException("Invalid AlgorithmIdentifier: extra data");

            }

        }

        return new AlgorithmId(algid, params);

    }

    /**

     * Returns one of the algorithm IDs most commonly associated

     * with this algorithm name.

     *

     * @param algname the name being used

     * @deprecated use the short get form of this method.

     * @exception NoSuchAlgorithmException on error.

     */

    @Deprecated

    public static AlgorithmId getAlgorithmId(String algname)

            throws NoSuchAlgorithmException {

        return get(algname);

    }

    /**

     * Returns one of the algorithm IDs most commonly associated

     * with this algorithm name.

     *

     * @param algname the name being used

     * @exception NoSuchAlgorithmException on error.

     */

    public static AlgorithmId get(String algname)

            throws NoSuchAlgorithmException {

        ObjectIdentifier oid;

        try {

            oid = algOID(algname);

        } catch (IOException ioe) {

            throw new NoSuchAlgorithmException

                ("Invalid ObjectIdentifier " + algname);

        }

        if (oid == null) {

            throw new NoSuchAlgorithmException

                ("unrecognized algorithm name: " + algname);

        }

        return new AlgorithmId(oid);

    }

    /**

     * Returns one of the algorithm IDs most commonly associated

     * with this algorithm parameters.

     *

     * @param algparams the associated algorithm parameters.

     * @exception NoSuchAlgorithmException on error.

     */

    public static AlgorithmId get(AlgorithmParameters algparams)

            throws NoSuchAlgorithmException {

        ObjectIdentifier oid;

        String algname = algparams.getAlgorithm();

        try {

            oid = algOID(algname);

        } catch (IOException ioe) {

            throw new NoSuchAlgorithmException

                ("Invalid ObjectIdentifier " + algname);

        }

        if (oid == null) {

            throw new NoSuchAlgorithmException

                ("unrecognized algorithm name: " + algname);

        }

        return new AlgorithmId(oid, algparams);

    }

    /*

     * Translates from some common algorithm names to the

     * OID with which they're usually associated ... this mapping

     * is the reverse of the one below, except in those cases

     * where synonyms are supported or where a given algorithm

     * is commonly associated with multiple OIDs.

     *

     * XXX This method needs to be enhanced so that we can also pass the

     * scope of the algorithm name to it, e.g., the algorithm name "DSA"

     * may have a different OID when used as a "Signature" algorithm than when

     * used as a "KeyPairGenerator" algorithm.

     */

    private static ObjectIdentifier algOID(String name) throws IOException {

        // See if algname is in printable OID ("dot-dot") notation

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

            if (name.startsWith("OID.")) {

                return new ObjectIdentifier(name.substring("OID.".length()));

            } else {

                return new ObjectIdentifier(name);

            }

        }

        // Digesting algorithms

        if (name.equalsIgnoreCase("MD5")) {

            return AlgorithmId.MD5_oid;

        }

        if (name.equalsIgnoreCase("MD2")) {

            return AlgorithmId.MD2_oid;

        }

        if (name.equalsIgnoreCase("SHA") || name.equalsIgnoreCase("SHA1")

            || name.equalsIgnoreCase("SHA-1")) {

            return AlgorithmId.SHA_oid;

        }

        if (name.equalsIgnoreCase("SHA-256") ||

            name.equalsIgnoreCase("SHA256")) {

            return AlgorithmId.SHA256_oid;

        }

        if (name.equalsIgnoreCase("SHA-384") ||

            name.equalsIgnoreCase("SHA384")) {

            return AlgorithmId.SHA384_oid;

        }

        if (name.equalsIgnoreCase("SHA-512") ||

            name.equalsIgnoreCase("SHA512")) {

            return AlgorithmId.SHA512_oid;

        }

        if (name.equalsIgnoreCase("SHA-224") ||

            name.equalsIgnoreCase("SHA224")) {

            return AlgorithmId.SHA224_oid;

        }

        // Various public key algorithms

        if (name.equalsIgnoreCase("RSA")) {

            return AlgorithmId.RSAEncryption_oid;

        }

        if (name.equalsIgnoreCase("Diffie-Hellman")

            || name.equalsIgnoreCase("DH")) {

            return AlgorithmId.DH_oid;

        }

        if (name.equalsIgnoreCase("DSA")) {

            return AlgorithmId.DSA_oid;

        }

        if (name.equalsIgnoreCase("EC")) {

            return EC_oid;

        }

        if (name.equalsIgnoreCase("ECDH")) {

            return AlgorithmId.ECDH_oid;

        }

        // Common signature types

        if (name.equalsIgnoreCase("MD5withRSA")

            || name.equalsIgnoreCase("MD5/RSA")) {

            return AlgorithmId.md5WithRSAEncryption_oid;

        }

        if (name.equalsIgnoreCase("MD2withRSA")

            || name.equalsIgnoreCase("MD2/RSA")) {

            return AlgorithmId.md2WithRSAEncryption_oid;

        }

        if (name.equalsIgnoreCase("SHAwithDSA")

            || name.equalsIgnoreCase("SHA1withDSA")

            || name.equalsIgnoreCase("SHA/DSA")

            || name.equalsIgnoreCase("SHA1/DSA")

            || name.equalsIgnoreCase("DSAWithSHA1")

            || name.equalsIgnoreCase("DSS")

            || name.equalsIgnoreCase("SHA-1/DSA")) {