326 lines · 10.8 KB · Java
RawDownload
/* * Copyright (c) 1997, 2001, 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 com.sun.security.cert.internal.x509; import java.io.ByteArrayInputStream;import java.io.IOException;import java.io.Serializable;import java.io.InputStream;import java.io.ObjectInputStream;import java.io.OutputStream;import java.io.ObjectOutputStream;import java.math.BigInteger;import java.security.Signature;import javax.security.cert.*;import java.security.*;import java.util.Date;import java.util.BitSet;import java.util.Enumeration;import java.util.Vector; /** * The X509V1CertImpl class is used as a conversion wrapper around * sun.security.x509.X509Cert certificates when running under JDK1.1.x. * * @author Jeff Nisewanger */public class X509V1CertImpl extends X509Certificate implements Serializable {    static final long serialVersionUID = -2048442350420423405L;    private java.security.cert.X509Certificate wrappedCert;     synchronized private static java.security.cert.CertificateFactory    getFactory()    throws java.security.cert.CertificateException    {        return java.security.cert.CertificateFactory.getInstance("X.509");    }     /**     * Default constructor.     */    public X509V1CertImpl() { }     /**     * Unmarshals a certificate from its encoded form, parsing the     * encoded bytes.  This form of constructor is used by agents which     * need to examine and use certificate contents.  That is, this is     * one of the more commonly used constructors.  Note that the buffer     * must include only a certificate, and no "garbage" may be left at     * the end.  If you need to ignore data at the end of a certificate,     * use another constructor.     *     * @param certData the encoded bytes, with no trailing padding.     * @exception CertificateException on parsing errors.     */    public X509V1CertImpl(byte[] certData)    throws CertificateException {        try {            ByteArrayInputStream bs;             bs = new ByteArrayInputStream(certData);            wrappedCert = (java.security.cert.X509Certificate)                getFactory().generateCertificate(bs);        } catch (java.security.cert.CertificateException e) {            throw new CertificateException(e.getMessage());        }    }     /**     * unmarshals an X.509 certificate from an input stream.     *     * @param in an input stream holding at least one certificate     * @exception CertificateException on parsing errors.     */    public X509V1CertImpl(InputStream in)    throws CertificateException {        try {            wrappedCert = (java.security.cert.X509Certificate)                getFactory().generateCertificate(in);        } catch (java.security.cert.CertificateException e) {            throw new CertificateException(e.getMessage());        }    }     /**     * Returns the encoded form of this certificate. It is     * assumed that each certificate type would have only a single     * form of encoding; for example, X.509 certificates would     * be encoded as ASN.1 DER.     */    public byte[] getEncoded() throws CertificateEncodingException {        try {            return wrappedCert.getEncoded();        } catch (java.security.cert.CertificateEncodingException e) {            throw new CertificateEncodingException(e.getMessage());        }    }     /**     * Throws an exception if the certificate was not signed using the     * verification key provided.  Successfully verifying a certificate     * does <em>not</em> indicate that one should trust the entity which     * it represents.     *     * @param key the public key used for verification.     */    public void verify(PublicKey key)        throws CertificateException, NoSuchAlgorithmException,        InvalidKeyException, NoSuchProviderException,        SignatureException    {        try {            wrappedCert.verify(key);        } catch (java.security.cert.CertificateException e) {            throw new CertificateException(e.getMessage());        }    }     /**     * Throws an exception if the certificate was not signed using the     * verification key provided.  Successfully verifying a certificate     * does <em>not</em> indicate that one should trust the entity which     * it represents.     *     * @param key the public key used for verification.     * @param sigProvider the name of the provider.     */    public void verify(PublicKey key, String sigProvider)        throws CertificateException, NoSuchAlgorithmException,        InvalidKeyException, NoSuchProviderException,        SignatureException    {        try {            wrappedCert.verify(key, sigProvider);        } catch (java.security.cert.CertificateException e) {            throw new CertificateException(e.getMessage());        }    }     /**     * Checks that the certificate is currently valid, i.e. the current     * time is within the specified validity period.     */    public void checkValidity() throws      CertificateExpiredException, CertificateNotYetValidException {        checkValidity(new Date());    }     /**     * Checks that the specified date is within the certificate's     * validity period, or basically if the certificate would be     * valid at the specified date/time.     *     * @param date the Date to check against to see if this certificate     *        is valid at that date/time.     */    public void checkValidity(Date date) throws      CertificateExpiredException, CertificateNotYetValidException {        try {            wrappedCert.checkValidity(date);        } catch (java.security.cert.CertificateNotYetValidException e) {            throw new CertificateNotYetValidException(e.getMessage());        } catch (java.security.cert.CertificateExpiredException e) {            throw new CertificateExpiredException(e.getMessage());        }    }      /**     * Returns a printable representation of the certificate.  This does not     * contain all the information available to distinguish this from any     * other certificate.  The certificate must be fully constructed     * before this function may be called.     */    public String toString() {        return wrappedCert.toString();    }     /**     * Gets the publickey from this certificate.     *     * @return the publickey.     */    public PublicKey getPublicKey() {        PublicKey key = wrappedCert.getPublicKey();        return key;    }     /*     * Gets the version number from the certificate.     *     * @return the version number.     */    public int getVersion() {        return wrappedCert.getVersion() - 1;    }     /**     * Gets the serial number from the certificate.     *     * @return the serial number.     */    public BigInteger getSerialNumber() {        return wrappedCert.getSerialNumber();    }     /**     * Gets the subject distinguished name from the certificate.     *     * @return the subject name.     * @exception CertificateException if a parsing error occurs.     */    public Principal getSubjectDN() {        return wrappedCert.getSubjectDN();    }     /**     * Gets the issuer distinguished name from the certificate.     *     * @return the issuer name.     * @exception CertificateException if a parsing error occurs.     */    public Principal getIssuerDN() {        return wrappedCert.getIssuerDN();    }     /**     * Gets the notBefore date from the validity period of the certificate.     *     * @return the start date of the validity period.     * @exception CertificateException if a parsing error occurs.     */    public Date getNotBefore() {        return wrappedCert.getNotBefore();    }     /**     * Gets the notAfter date from the validity period of the certificate.     *     * @return the end date of the validity period.     * @exception CertificateException if a parsing error occurs.     */    public Date getNotAfter() {        return wrappedCert.getNotAfter();    }     /**     * Gets the signature algorithm name for the certificate     * signature algorithm.     * For example, the string "SHA1/DSA".     *     * @return the signature algorithm name.     * @exception CertificateException if a parsing error occurs.     */    public String getSigAlgName() {        return wrappedCert.getSigAlgName();    }     /**     * Gets the signature algorithm OID string from the certificate.     * For example, the string "1.2.840.10040.4.3"     *     * @return the signature algorithm oid string.     * @exception CertificateException if a parsing error occurs.     */    public String getSigAlgOID() {        return wrappedCert.getSigAlgOID();    }     /**     * Gets the DER encoded signature algorithm parameters from this     * certificate's signature algorithm.     *     * @return the DER encoded signature algorithm parameters, or     *         null if no parameters are present.     * @exception CertificateException if a parsing error occurs.     */    public byte[] getSigAlgParams() {        return wrappedCert.getSigAlgParams();    }     private synchronized void writeObject(ObjectOutputStream stream)        throws IOException {        try {            stream.write(getEncoded());        } catch (CertificateEncodingException e) {            throw new IOException("getEncoded failed: " + e.getMessage());        }    }     private synchronized void readObject(ObjectInputStream stream)        throws IOException {        try {            wrappedCert = (java.security.cert.X509Certificate)                getFactory().generateCertificate(stream);        } catch (java.security.cert.CertificateException e) {            throw new IOException("generateCertificate failed: " + e.getMessage());        }    }     public java.security.cert.X509Certificate getX509Certificate() {        return wrappedCert;    }}