/**
* Produce an object suitable for an ASN1OutputStream.
*
* <pre>
* IDEA-CBCPar ::= SEQUENCE {
* iv OCTET STRING OPTIONAL -- exactly 8 octets
* }
* </pre>
*/
public DERObject getDERObject() {
ASN1EncodableVector v = new ASN1EncodableVector();
if (iv != null) {
v.add(iv);
}
return new DERSequence(v);
}
/**
* Produce an object suitable for an ASN1OutputStream.
*
* <pre>
* ContentInfo ::= SEQUENCE {
* contentType ContentType,
* content
* [0] EXPLICIT ANY DEFINED BY contentType OPTIONAL }
* </pre>
*/
public DERObject toASN1Object() {
ASN1EncodableVector v = new ASN1EncodableVector();
v.add(contentType);
if (content != null) {
v.add(new BERTaggedObject(0, content));
}
return new BERSequence(v);
}
public DERApplicationSpecific(int tagNo, ASN1EncodableVector vec) {
this.tag = tagNo;
this.isConstructed = true;
ByteArrayOutputStream bOut = new ByteArrayOutputStream();
for (int i = 0; i != vec.size(); i++) {
try {
bOut.write(((ASN1Encodable) vec.get(i)).getEncoded());
} catch (IOException e) {
throw new ASN1ParsingException("malformed object: " + e, e);
}
}
this.octets = bOut.toByteArray();
}
/**
* Produce an object suitable for an ASN1OutputStream.
*
* <pre>
* CrlID ::= SEQUENCE {
* crlUrl [0] EXPLICIT IA5String OPTIONAL,
* crlNum [1] EXPLICIT INTEGER OPTIONAL,
* crlTime [2] EXPLICIT GeneralizedTime OPTIONAL }
* </pre>
*/
public DERObject toASN1Object() {
ASN1EncodableVector v = new ASN1EncodableVector();
if (crlUrl != null) {
v.add(new DERTaggedObject(true, 0, crlUrl));
}
if (crlNum != null) {
v.add(new DERTaggedObject(true, 1, crlNum));
}
if (crlTime != null) {
v.add(new DERTaggedObject(true, 2, crlTime));
}
return new DERSequence(v);
}
/**
* Return an ASN1 set from a tagged object. There is a special case here, if an object appears to
* have been explicitly tagged on reading but we were expecting it to be implicitly tagged in the
* normal course of events it indicates that we lost the surrounding set - so we need to add it
* back (this will happen if the tagged object is a sequence that contains other sequences). If
* you are dealing with implicitly tagged sets you really <b>should</b> be using this method.
*
* @param obj the tagged object.
* @param explicit true if the object is meant to be explicitly tagged false otherwise.
* @exception IllegalArgumentException if the tagged object cannot be converted.
*/
public static ASN1Set getInstance(ASN1TaggedObject obj, boolean explicit) {
if (explicit) {
if (!obj.isExplicit()) {
throw new IllegalArgumentException("object implicit - explicit expected.");
}
return (ASN1Set) obj.getObject();
} else {
//
// constructed object which appears to be explicitly tagged
// and it's really implicit means we have to add the
// surrounding sequence.
//
if (obj.isExplicit()) {
ASN1Set set = new DERSet(obj.getObject());
return set;
} else {
if (obj.getObject() instanceof ASN1Set) {
return (ASN1Set) obj.getObject();
}
//
// in this case the parser returns a sequence, convert it
// into a set.
//
ASN1EncodableVector v = new ASN1EncodableVector();
if (obj.getObject() instanceof ASN1Sequence) {
ASN1Sequence s = (ASN1Sequence) obj.getObject();
Enumeration e = s.getObjects();
while (e.hasMoreElements()) {
v.add((DEREncodable) e.nextElement());
}
return new DERSet(v, false);
}
}
}
throw new IllegalArgumentException(
"unknown object in getInstance: " + obj.getClass().getName());
}
/** build an object given its tag and a byte stream to construct it from. */
protected DERObject buildObject(int tag, byte[] bytes) throws IOException {
switch (tag) {
case NULL:
return null;
case SEQUENCE | CONSTRUCTED:
ByteArrayInputStream bIn = new ByteArrayInputStream(bytes);
BERInputStream dIn = new BERInputStream(bIn);
DERConstructedSequence seq = new DERConstructedSequence();
try {
for (; ; ) {
DERObject obj = dIn.readObject();
seq.addObject(obj);
}
} catch (EOFException ex) {
return seq;
}
case SET | CONSTRUCTED:
bIn = new ByteArrayInputStream(bytes);
dIn = new BERInputStream(bIn);
ASN1EncodableVector v = new ASN1EncodableVector();
try {
for (; ; ) {
DERObject obj = dIn.readObject();
v.add(obj);
}
} catch (EOFException ex) {
return new DERConstructedSet(v);
}
case BOOLEAN:
return new DERBoolean(bytes);
case INTEGER:
return new DERInteger(bytes);
case ENUMERATED:
return new DEREnumerated(bytes);
case OBJECT_IDENTIFIER:
return new DERObjectIdentifier(bytes);
case BIT_STRING:
int padBits = bytes[0];
byte[] data = new byte[bytes.length - 1];
System.arraycopy(bytes, 1, data, 0, bytes.length - 1);
return new DERBitString(data, padBits);
case UTF8_STRING:
return new DERUTF8String(bytes);
case PRINTABLE_STRING:
return new DERPrintableString(bytes);
case IA5_STRING:
return new DERIA5String(bytes);
case T61_STRING:
return new DERT61String(bytes);
case VISIBLE_STRING:
return new DERVisibleString(bytes);
case UNIVERSAL_STRING:
return new DERUniversalString(bytes);
case GENERAL_STRING:
return new DERGeneralString(bytes);
case BMP_STRING:
return new DERBMPString(bytes);
case OCTET_STRING:
return new DEROctetString(bytes);
case UTC_TIME:
return new DERUTCTime(bytes);
case GENERALIZED_TIME:
return new DERGeneralizedTime(bytes);
default:
//
// with tagged object tag number is bottom 5 bits
//
if ((tag & TAGGED) != 0) {
if ((tag & 0x1f) == 0x1f) {
throw new IOException("unsupported high tag encountered");
}
if (bytes.length == 0) // empty tag!
{
if ((tag & CONSTRUCTED) == 0) {
return new DERTaggedObject(false, tag & 0x1f, new DERNull());
} else {
return new DERTaggedObject(false, tag & 0x1f, new DERConstructedSequence());
}
}
//
// simple type - implicit... return an octet string
//
if ((tag & CONSTRUCTED) == 0) {
return new DERTaggedObject(false, tag & 0x1f, new DEROctetString(bytes));
}
bIn = new ByteArrayInputStream(bytes);
dIn = new BERInputStream(bIn);
DEREncodable dObj = dIn.readObject();
//
// explicitly tagged (probably!) - if it isn't we'd have to
// tell from the context
//
if (dIn.available() == 0) {
return new DERTaggedObject(tag & 0x1f, dObj);
}
//
// another implicit object, we'll create a sequence...
//
seq = new DERConstructedSequence();
seq.addObject(dObj);
try {
for (; ; ) {
dObj = dIn.readObject();
seq.addObject(dObj);
}
} catch (EOFException ex) {
// ignore --
}
return new DERTaggedObject(false, tag & 0x1f, seq);
}
return new DERUnknownTag(tag, bytes);
}
}
/** create a sequence containing a vector of objects. */
public DERSequence(ASN1EncodableVector v) {
for (int i = 0; i != v.size(); i++) {
this.addObject(v.get(i));
}
}
