| package org.bouncycastle.asn1.x509; |
| |
| import java.util.Enumeration; |
| import java.util.Hashtable; |
| import java.util.Vector; |
| |
| import org.bouncycastle.asn1.ASN1Encodable; |
| import org.bouncycastle.asn1.ASN1EncodableVector; |
| import org.bouncycastle.asn1.ASN1Object; |
| import org.bouncycastle.asn1.ASN1ObjectIdentifier; |
| import org.bouncycastle.asn1.ASN1Primitive; |
| import org.bouncycastle.asn1.ASN1Sequence; |
| import org.bouncycastle.asn1.ASN1TaggedObject; |
| import org.bouncycastle.asn1.DERSequence; |
| |
| public class Extensions |
| extends ASN1Object |
| { |
| private Hashtable extensions = new Hashtable(); |
| private Vector ordering = new Vector(); |
| |
| public static Extensions getInstance( |
| ASN1TaggedObject obj, |
| boolean explicit) |
| { |
| return getInstance(ASN1Sequence.getInstance(obj, explicit)); |
| } |
| |
| public static Extensions getInstance( |
| Object obj) |
| { |
| if (obj instanceof Extensions) |
| { |
| return (Extensions)obj; |
| } |
| else if (obj != null) |
| { |
| return new Extensions(ASN1Sequence.getInstance(obj)); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Constructor from ASN1Sequence. |
| * <p> |
| * The extensions are a list of constructed sequences, either with (OID, OctetString) or (OID, Boolean, OctetString) |
| * </p> |
| */ |
| private Extensions( |
| ASN1Sequence seq) |
| { |
| Enumeration e = seq.getObjects(); |
| |
| while (e.hasMoreElements()) |
| { |
| Extension ext = Extension.getInstance(e.nextElement()); |
| |
| if (extensions.containsKey(ext.getExtnId())) |
| { |
| throw new IllegalArgumentException("repeated extension found: " + ext.getExtnId()); |
| } |
| |
| extensions.put(ext.getExtnId(), ext); |
| ordering.addElement(ext.getExtnId()); |
| } |
| } |
| |
| /** |
| * Base Constructor |
| * |
| * @param extension a single extension. |
| */ |
| public Extensions( |
| Extension extension) |
| { |
| this.ordering.addElement(extension.getExtnId()); |
| this.extensions.put(extension.getExtnId(), extension); |
| } |
| |
| /** |
| * Base Constructor |
| * |
| * @param extensions an array of extensions. |
| */ |
| public Extensions( |
| Extension[] extensions) |
| { |
| for (int i = 0; i != extensions.length; i++) |
| { |
| Extension ext = extensions[i]; |
| |
| this.ordering.addElement(ext.getExtnId()); |
| this.extensions.put(ext.getExtnId(), ext); |
| } |
| } |
| |
| /** |
| * return an Enumeration of the extension field's object ids. |
| */ |
| public Enumeration oids() |
| { |
| return ordering.elements(); |
| } |
| |
| /** |
| * return the extension represented by the object identifier |
| * passed in. |
| * |
| * @return the extension if it's present, null otherwise. |
| */ |
| public Extension getExtension( |
| ASN1ObjectIdentifier oid) |
| { |
| return (Extension)extensions.get(oid); |
| } |
| |
| /** |
| * return the parsed value of the extension represented by the object identifier |
| * passed in. |
| * |
| * @return the parsed value of the extension if it's present, null otherwise. |
| */ |
| public ASN1Encodable getExtensionParsedValue(ASN1ObjectIdentifier oid) |
| { |
| Extension ext = this.getExtension(oid); |
| |
| if (ext != null) |
| { |
| return ext.getParsedValue(); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * <pre> |
| * Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension |
| * |
| * Extension ::= SEQUENCE { |
| * extnId EXTENSION.&id ({ExtensionSet}), |
| * critical BOOLEAN DEFAULT FALSE, |
| * extnValue OCTET STRING } |
| * </pre> |
| */ |
| public ASN1Primitive toASN1Primitive() |
| { |
| ASN1EncodableVector vec = new ASN1EncodableVector(); |
| Enumeration e = ordering.elements(); |
| |
| while (e.hasMoreElements()) |
| { |
| ASN1ObjectIdentifier oid = (ASN1ObjectIdentifier)e.nextElement(); |
| Extension ext = (Extension)extensions.get(oid); |
| |
| vec.add(ext); |
| } |
| |
| return new DERSequence(vec); |
| } |
| |
| public boolean equivalent( |
| Extensions other) |
| { |
| if (extensions.size() != other.extensions.size()) |
| { |
| return false; |
| } |
| |
| Enumeration e1 = extensions.keys(); |
| |
| while (e1.hasMoreElements()) |
| { |
| Object key = e1.nextElement(); |
| |
| if (!extensions.get(key).equals(other.extensions.get(key))) |
| { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| public ASN1ObjectIdentifier[] getExtensionOIDs() |
| { |
| return toOidArray(ordering); |
| } |
| |
| public ASN1ObjectIdentifier[] getNonCriticalExtensionOIDs() |
| { |
| return getExtensionOIDs(false); |
| } |
| |
| public ASN1ObjectIdentifier[] getCriticalExtensionOIDs() |
| { |
| return getExtensionOIDs(true); |
| } |
| |
| private ASN1ObjectIdentifier[] getExtensionOIDs(boolean isCritical) |
| { |
| Vector oidVec = new Vector(); |
| |
| for (int i = 0; i != ordering.size(); i++) |
| { |
| Object oid = ordering.elementAt(i); |
| |
| if (((Extension)extensions.get(oid)).isCritical() == isCritical) |
| { |
| oidVec.addElement(oid); |
| } |
| } |
| |
| return toOidArray(oidVec); |
| } |
| |
| private ASN1ObjectIdentifier[] toOidArray(Vector oidVec) |
| { |
| ASN1ObjectIdentifier[] oids = new ASN1ObjectIdentifier[oidVec.size()]; |
| |
| for (int i = 0; i != oids.length; i++) |
| { |
| oids[i] = (ASN1ObjectIdentifier)oidVec.elementAt(i); |
| } |
| return oids; |
| } |
| } |