/* * Copyright (c) 1996, 2003, 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.x509; import java.io.IOException;import java.math.BigInteger;import java.security.*;import java.security.interfaces.DSAParams; import sun.security.util.*;  /** * This class identifies DSS/DSA Algorithm variants, which are distinguished * by using different algorithm parameters <em>P, Q, G</em>.  It uses the * NIST/IETF standard DER encoding.  These are used to implement the Digital * Signature Standard (DSS), FIPS 186. * * <P><em><b>NOTE:</b>  DSS/DSA Algorithm IDs may be created without these * parameters.  Use of DSS/DSA in modes where parameters are * either implicit (e.g. a default applicable to a site or a larger scope), * or are derived from some Certificate Authority's DSS certificate, is * not supported directly.  The application is responsible for creating a key * containing the required parameters prior to using the key in cryptographic * operations.  The follwoing is an example of how this may be done assuming * that we have a certificate called <code>currentCert</code> which doesn't * contain DSS/DSA parameters and we need to derive DSS/DSA parameters * from a CA's certificate called <code>caCert</code>. * <p> * <code><pre> * // key containing parameters to use * DSAPublicKey cAKey = (DSAPublicKey)(caCert.getPublicKey()); * // key without parameters * DSAPublicKey nullParamsKey = (DSAPublicKey)(currentCert.getPublicKey()); * * DSAParams cAKeyParams = cAKey.getParams(); * KeyFactory kf = KeyFactory.getInstance("DSA"); * DSAPublicKeySpec ks = new DSAPublicKeySpec(nullParamsKey.getY(), *                                            cAKeyParams.getP(), *                                            cAKeyParams.getQ(), *                                            cAKeyParams.getG()); * DSAPublicKey usableKey = kf.generatePublic(ks); * </pre></code> * * @see java.security.interfaces.DSAParams * @see java.security.interfaces.DSAPublicKey * @see java.security.KeyFactory * @see java.security.spec.DSAPublicKeySpec * * @author David Brownell */public finalclass AlgIdDSA extends AlgorithmId implements DSAParams{     private static final long serialVersionUID = 3437177836797504046L;     /*     * The three unsigned integer parameters.     */    private BigInteger  p , q, g;     /** Returns the DSS/DSA parameter "P" */    public BigInteger   getP () { return p; }     /** Returns the DSS/DSA parameter "Q" */    public BigInteger   getQ () { return q; }     /** Returns the DSS/DSA parameter "G" */    public BigInteger   getG () { return g; }     /**     * Default constructor.  The OID and parameters must be     * deserialized before this algorithm ID is used.     */    // XXX deprecated for general use    public AlgIdDSA () {}     AlgIdDSA (DerValue val) throws IOException        { super(val.getOID()); }     /**     * Construct an AlgIdDSA from an X.509 encoded byte array.     */    public AlgIdDSA (byte[] encodedAlg) throws IOException        { super (new DerValue(encodedAlg).getOID()); }     /**     * Constructs a DSS/DSA Algorithm ID from unsigned integers that     * define the algorithm parameters.  Those integers are encoded     * as big-endian byte arrays.     *     * @param p the DSS/DSA paramter "P"     * @param q the DSS/DSA paramter "Q"     * @param g the DSS/DSA paramter "G"     */    public AlgIdDSA (byte p [], byte q [], byte g [])    throws IOException    {        this (new BigInteger (1, p),            new BigInteger (1, q),            new BigInteger (1, g));    }     /**     * Constructs a DSS/DSA Algorithm ID from numeric parameters.     * If all three are null, then the parameters portion of the algorithm id     * is set to null.  See note in header regarding use.     *     * @param p the DSS/DSA paramter "P"     * @param q the DSS/DSA paramter "Q"     * @param g the DSS/DSA paramter "G"     */    public AlgIdDSA (BigInteger p, BigInteger q, BigInteger g)    {        super (DSA_oid);         if (p != null || q != null || g != null) {            if (p == null || q == null || g == null)                throw new ProviderException("Invalid parameters for DSS/DSA" +                                            " Algorithm ID");            try {                this.p = p;                this.q = q;                this.g = g;                initializeParams ();             } catch (IOException e) {                /* this should not happen */                throw new ProviderException ("Construct DSS/DSA Algorithm ID");            }        }    }     /**     * Returns "DSA", indicating the Digital Signature Algorithm (DSA) as     * defined by the Digital Signature Standard (DSS), FIPS 186.     */    public String getName ()        { return "DSA"; }      /*     * For algorithm IDs which haven't been created from a DER encoded     * value, "params" must be created.     */    private void initializeParams ()    throws IOException    {        DerOutputStream out = new DerOutputStream ();         out.putInteger(p);        out.putInteger(q);        out.putInteger(g);        params = new DerValue (DerValue.tag_Sequence,out.toByteArray ());    }     /**     * Parses algorithm parameters P, Q, and G.  They're found     * in the "params" member, which never needs to be changed.     */    protected void decodeParams ()    throws IOException    {        if (params == null)            throw new IOException("DSA alg params are null");        if (params.tag != DerValue.tag_Sequence)            throw new  IOException("DSA alg parsing error");         params.data.reset ();         this.p = params.data.getBigInteger();        this.q = params.data.getBigInteger();        this.g = params.data.getBigInteger();         if (params.data.available () != 0)            throw new IOException ("AlgIdDSA params, extra="+                                   params.data.available ());    }      /*     * Returns a formatted string describing the parameters.     */    public String toString ()        { return paramsToString (); }     /*     * Returns a string describing the parameters.     */    protected String paramsToString ()    {        if (params == null)            return " null\n";        else            return                "\n    p:\n" + Debug.toHexString(p) +                "\n    q:\n" + Debug.toHexString(q) +                "\n    g:\n" + Debug.toHexString(g) +                "\n";    }}