* This supports BER, and DER forms of the data. *
* DER form is always primitive single OCTET STRING, while * BER support includes the constructed forms. *
*X.690
*8: Basic encoding rules
*8.7 Encoding of an octetstring value
** 8.7.1 The encoding of an octetstring value shall be * either primitive or constructed at the option of the sender. *
* NOTE — Where it is necessary to transfer part of an octet string * before the entire OCTET STRING is available, the constructed encoding * is used. **
* 8.7.2 The primitive encoding contains zero, * one or more contents octets equal in value to the octets * in the data value, in the order they appear in the data value, * and with the most significant bit of an octet of the data value * aligned with the most significant bit of an octet of the contents octets. *
** 8.7.3 The contents octets for the constructed encoding shall consist * of zero, one, or more encodings. *
** NOTE — Each such encoding includes identifier, length, and contents octets, * and may include end-of-contents octets if it is constructed. **
* 8.7.3.1 To encode an octetstring value in this way, * it is segmented. Each segment shall consist of a series of * consecutive octets of the value. There shall be no significance * placed on the segment boundaries.
** NOTE — A segment may be of size zero, i.e. contain no octets. **
* 8.7.3.2 Each encoding in the contents octets shall represent * a segment of the overall octetstring, the encoding arising from * a recursive application of this subclause. * In this recursive application, each segment is treated as if it were * a octetstring value. The encodings of the segments shall appear in the contents * octets in the order in which their octets appear in the overall value. *
** NOTE 1 — As a consequence of this recursion, * each encoding in the contents octets may itself * be primitive or constructed. * However, such encodings will usually be primitive. **
* NOTE 2 — In particular, the tags in the contents octets are always universal class, number 4. **
9: Canonical encoding rules
*9.1 Length forms
** If the encoding is constructed, it shall employ the indefinite-length form. * If the encoding is primitive, it shall include the fewest length octets necessary. * [Contrast with 8.1.3.2 b).] *
*9.2 String encoding forms
** BIT STRING, OCTET STRING,and restricted character string * values shall be encoded with a primitive encoding if they would * require no more than 1000 contents octets, and as a constructed * encoding otherwise. The string fragments contained in * the constructed encoding shall be encoded with a primitive encoding. * The encoding of each fragment, except possibly * the last, shall have 1000 contents octets. (Contrast with 8.21.6.) *
* 10: Distinguished encoding rules *
* 10.1 Length forms * The definite form of length encoding shall be used, * encoded in the minimum number of octets. * [Contrast with 8.1.3.2 b).] *
* 10.2 String encoding forms * For BIT STRING, OCTET STRING and restricted character string types, * the constructed form of encoding shall not be used. * (Contrast with 8.21.6.) * @hide This class is not part of the Android public SDK API */ public abstract class ASN1OctetString extends ASN1Primitive implements ASN1OctetStringParser { byte[] string; /** * return an Octet String from a tagged object. * * @param taggedObject the tagged object holding the object we want. * @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 ASN1OctetString getInstance( ASN1TaggedObject taggedObject, boolean explicit) { if (explicit) { if (!taggedObject.isExplicit()) { throw new IllegalArgumentException("object implicit - explicit expected."); } return getInstance(taggedObject.getObject()); } ASN1Primitive o = taggedObject.getObject(); /* * constructed object which appears to be explicitly tagged and it's really implicit means * we have to add the surrounding octet string. */ if (taggedObject.isExplicit()) { ASN1OctetString singleSegment = getInstance(o); if (taggedObject instanceof BERTaggedObject) { return new BEROctetString(new ASN1OctetString[]{ singleSegment }); } // TODO Should really be similar to the BERTaggedObject case above: // return new DLOctetString(new ASN1OctetString[]{ singleSegment }); return (ASN1OctetString)new BEROctetString(new ASN1OctetString[]{ singleSegment }).toDLObject(); } if (o instanceof ASN1OctetString) { ASN1OctetString s = (ASN1OctetString)o; if (taggedObject instanceof BERTaggedObject) { return s; } return (ASN1OctetString)s.toDLObject(); } /* * in this case the parser returns a sequence, convert it into an octet string. */ if (o instanceof ASN1Sequence) { ASN1Sequence s = (ASN1Sequence)o; if (taggedObject instanceof BERTaggedObject) { return BEROctetString.fromSequence(s); } // TODO Should really be similar to the BERTaggedObject case above: // return DLOctetString.fromSequence(s); return (ASN1OctetString)BEROctetString.fromSequence(s).toDLObject(); } throw new IllegalArgumentException("unknown object in getInstance: " + taggedObject.getClass().getName()); } /** * return an Octet String from the given object. * * @param obj the object we want converted. * @exception IllegalArgumentException if the object cannot be converted. */ public static ASN1OctetString getInstance( Object obj) { if (obj == null || obj instanceof ASN1OctetString) { return (ASN1OctetString)obj; } else if (obj instanceof byte[]) { try { return getInstance(fromByteArray((byte[])obj)); } catch (IOException e) { throw new IllegalArgumentException("failed to construct OCTET STRING from byte[]: " + e.getMessage()); } } else if (obj instanceof ASN1Encodable) { ASN1Primitive primitive = ((ASN1Encodable)obj).toASN1Primitive(); if (primitive instanceof ASN1OctetString) { return (ASN1OctetString)primitive; } } throw new IllegalArgumentException("illegal object in getInstance: " + obj.getClass().getName()); } /** * Base constructor. * * @param string the octets making up the octet string. */ public ASN1OctetString( byte[] string) { if (string == null) { throw new NullPointerException("'string' cannot be null"); } this.string = string; } /** * Return the content of the OCTET STRING as an InputStream. * * @return an InputStream representing the OCTET STRING's content. */ public InputStream getOctetStream() { return new ByteArrayInputStream(string); } /** * Return the parser associated with this object. * * @return a parser based on this OCTET STRING */ public ASN1OctetStringParser parser() { return this; } /** * Return the content of the OCTET STRING as a byte array. * * @return the byte[] representing the OCTET STRING's content. */ public byte[] getOctets() { return string; } public int hashCode() { return Arrays.hashCode(this.getOctets()); } boolean asn1Equals( ASN1Primitive o) { if (!(o instanceof ASN1OctetString)) { return false; } ASN1OctetString other = (ASN1OctetString)o; return Arrays.areEqual(string, other.string); } public ASN1Primitive getLoadedObject() { return this.toASN1Primitive(); } ASN1Primitive toDERObject() { return new DEROctetString(string); } ASN1Primitive toDLObject() { return new DEROctetString(string); } abstract void encode(ASN1OutputStream out, boolean withTag) throws IOException; public String toString() { return "#" + Strings.fromByteArray(Hex.encode(string)); } }