| /* |
| * 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; |
| } |
| } |