APPLICATION ("Entrust Authority Security Toolkit for the Java Platform")

java.lang.Object
- iaik.asn1.ASN1Object
- - iaik.asn1.ConstructedType
  - - iaik.asn1.TaggedType
    - - iaik.asn1.APPLICATION

```
public class APPLICATION
extends TaggedType
```
This class implements the tagged ASN.1 type "APPLICATION".
ASN.1 types are unequivocally identified by their tags. Every ASN.1 type - except for ANY and CHOICE types - is allocated a particular tag specifying the tag class to which this type belongs and the tag number which separates the current ASN.1 type from the other types belonging to the same tag class. ASN.1 defines four tag classes:
- The Universal Class, which specifies types defined by the ASN.1 standard and having universal validity for any application.
- The Application Class for types defined within a particular application standard.
- The Context-specific Class, which is used when there is need for unequivocally identifying types within a given context (for instance when using CHOICE types or for separating component types with equal underlying tags within a structered type).
- The Private Class for user defined, enterprise-specific types.
For BER (respectively DER) encoding a tagged type which is derived from some underlying type, either EXPLICIT or IMPLICIT tagging may be used. The tag of the underlying type explicitly has to be encoded when EXPLICIT tagging is used. IMPLICIT tagging avoids the extra encoding of the tag of the underlying type and may be used when the actual tag can be derived from the context.

Explicit tagging always enforces constructed encoding, and the contents consists of the full encoding of the underlying base type. When implicit tagging is required, the kind of encoding (primitive or constructed) depends on the base type: if the base type is a simple type, the tagged type is primitive encoded, but if the base type is constructed the tagged type also has to be encoded constructed.

Since explicit tagging is the default value and requires constructed encoding, this APPLICATION class inherits from the ConstructedType class. Implicit tagging may be enforced by setting the implicitlyTagged parameter to true when creating a new APPLICATION object by means of the APPLICATION(int appTag, ASN1Object obj, boolean implicitlyTagged) constructor. The following example creates an ASN.1 SEQUENCE object consisting of two INTEGER components, and one OCTET_STRING component, which is tagged application implicit with tag number 0:
```
 INTEGER i1 = new INTEGER(1);
 OCTET_STRING oct = new OCTET_STRING(new byte[] {(byte)0xAB, (byte)0xCD});
 INTEGER i2 = new INTEGER(2);
 SEQUENCE seq = new SEQUENCE();
 seq.addComponent(i1);
 seq.addComponent(new APPLICATION(0, oct, true));
 seq.addComponent(i2);
 
```
The example above will give the following DER encoding:
```
 30:0A:02:01:01:40:02:AB:CD:02:01:02
 
```
For comparison, if the application tagged OCTET_STRING component of the SEQUENCE above is tagged explicitly, it will be encoded constructed and OCTET_STRING tag (0x04) and length are included in the encoding:
```
 30:0C:02:01:01:60:04:04:02:AB:CD:02:01:02
 
```
Attention has to be paid when implicitly tagging a structured component, e.g. a SEQUENCE component. Since the SEQUENCE tag (0x30) is not included into the encoding, particular care has to be taken when decoding and parsing such a structure. Consider, for instance, two ASN.1 SEQUENCE structures, both containing an application tagged component with the same tag number 0. The application tagged component of the first SEQUENCE shall be explicitly tagged and shall represent a simple OCTET_STRING component. The application tagged component of the second SEQUENCE object shall be implicitly tagged and shall represent a SEQUENCE component containing one OCTET_STRING component with the same value as the OCTET_STRING component of the first SEQUENCE object:

First SEQUENCE:
```
 SEQUENCE[C] = 3 elements
  INTEGER = 1
  APPLICATION[C] = [0] EXPLICIT
   OCTET STRING = 2 bytes: AB:CD
  INTEGER = 2
 
```
Second SEQUENCE:
```
 SEQUENCE[C] = 3 elements
  INTEGER = 1
  APPLICATION[C] = [0] IMPLICIT
   SEQUENCE[C] = 1 elements
    OCTET STRING = 2 bytes: AB:CD
  INTEGER = 2
 
```
The encoding will be the same, since the application tagged component of the first SEQUENCE object is explicitly tagged and therefore constructed encoded giving a tag of 0x60 (01100000: tag class: application (01), encoding type: constrcuted (1), tag number: 0 (00000). The application tagged component of the second SEQUENCE object is implicitly tagged and therefore the encoding type (primitive or constructed) is derived from the base type, which is a SEQUENCE and therefore gives the same application tag as in the first example: 0x60. Since implicit tagging does not encode the tag of the base type (SEQUENCE 0x30), the encoding result is the same for both SEQUENCE objects:
```
 30:0C:02:01:01:60:04:04:02:AB:CD:02:01:02
 
```
However the application that parses the received SEQUENCE object knows that implictly tagging has been used and therefore can recognize the right encoding by using the forceImplicitlyTagged method:
```
 SEQUENCE obtained_sequence = (SEQUENCE)DerCoder.decode(encoding);
 APPLICATION ap = (APPLICATION)obtained_sequnce.getComponentAt(1);
 ap.forceImplicitlyTagged(ASN.SEQUENCE);
 SEQUENCE seq_component = (SEQUENCE)ap.getValue();
 OCTET_STRING oct = (OCTET_STRING)seq_component.getComponentAt(0);
 
```
Since:

7.2 SP1

See Also:

ASN1Object, ASN, DerCoder

Field Summary
- Fields inherited from class iaik.asn1.ConstructedType
  content_count, content_data
- Fields inherited from class iaik.asn1.ASN1Object
  asnType, constructed, encode_listener, indefinite_length, isStringType, stream_mode

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`APPLICATION()` Creates an empty APPLICATION object.
	`APPLICATION(int appTag, ASN1Object obj)` Creates a new explicitly tagged application tagged ASN.1 type.
	`APPLICATION(int appTag, ASN1Object obj, boolean implicitlyTagged)` Creates a new application tagged ASN.1 type.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static OCTET_STRING`	`parseImplicitApplicationTaggedOctetString(ASN1Object obj, int expectedTag, java.lang.String objName)` Ensures that the ASN.1 object is an [APPLICATION] IMPLICIT OCTET STRING with the indicated value.
`static SEQUENCE`	`parseImplicitApplicationTaggedSequence(ASN1Object obj, int expectedTag, java.lang.String objName)` Ensures that the ASN.1 object is an [APPLICATION] IMPLICIT SEQUENCE with the indicated value.
`static UTF8String`	`parseImplicitApplicationTaggedUtf8String(ASN1Object obj, int expectedTag, java.lang.String objName)` Ensures that the ASN.1 object is an [APPLICATION] IMPLICIT UTF8String with the indicated value.

Methods inherited from class iaik.asn1.TaggedType
decode, encode, forceImplicitlyTagged, getValue, isImplicitlyTagged, toString

Methods inherited from class iaik.asn1.ConstructedType
addComponent, addComponent, addEncodeListener, countComponents, getComponentAt, getComponents, removeComponent, removeComponent, setComponent, setValue

Methods inherited from class iaik.asn1.ASN1Object
addEncodeListener, encodeObject, getAsnType, indefiniteLength, isA, isConstructed, isStringType, setAutomaticRepair, setAutomaticRepairRecursive, setIndefiniteLength, setIndefiniteRecursive

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - APPLICATION
```
protected APPLICATION()
```
    Creates an empty APPLICATION object.
  - APPLICATION
```
public APPLICATION(int appTag,
                   ASN1Object obj)
```
    Creates a new explicitly tagged application tagged ASN.1 type. Use the #APPLICATION(int, ASN1Object, boolean) constructor for enforcing implicit tagging.
    
    Parameters:
    
    appTag - the application tag number
    
    obj - the underlying ASN1Object
  - APPLICATION
```
public APPLICATION(int appTag,
                   ASN1Object obj,
                   boolean implicitlyTagged)
```
    Creates a new application tagged ASN.1 type. The calling application decides if implicit or explicit tagging is to be used.
    
    Parameters:
    
    appTag - the application tag number
    
    obj - the underlying ASN1Object
    
    implicitlyTagged - true if creating an implicitly tagged object, false if creating an explicitly tagged object
- Method Detail
  - parseImplicitApplicationTaggedOctetString
```
public static OCTET_STRING parseImplicitApplicationTaggedOctetString(ASN1Object obj,
                                                                     int expectedTag,
                                                                     java.lang.String objName)
                                                              throws CodingException
```
    Ensures that the ASN.1 object is an [APPLICATION] IMPLICIT OCTET STRING with the indicated value.
    
    Parameters:
    
    obj - an ASN.1 object
    
    expectedTag - the tag value that is expected
    
    objName - a string name for this ASN.1 object (used in excpetion messages)
    
    Returns:
    
    the OCTET STRING that this [APPLICATION] IMPLICIT tagged ASN.1 object represents
    
    Throws:
    
    CodingException - if the ASN.1 object is not an [APPLICATION] IMPLICIT OCTET STRING with the indicated value
  - parseImplicitApplicationTaggedSequence
```
public static SEQUENCE parseImplicitApplicationTaggedSequence(ASN1Object obj,
                                                              int expectedTag,
                                                              java.lang.String objName)
                                                       throws CodingException
```
    Ensures that the ASN.1 object is an [APPLICATION] IMPLICIT SEQUENCE with the indicated value.
    
    Parameters:
    
    obj - an ASN.1 object
    
    expectedTag - the tag value that is expected
    
    objName - a string name for this ASN.1 object (used in excpetion messages)
    
    Returns:
    
    the SEQUENCE that this [APPLICATION] IMPLICIT tagged ASN.1 object represents
    
    Throws:
    
    CodingException - if the ASN.1 object is not an [APPLICATION] IMPLICIT SEQUENCE with the indicated value
  - parseImplicitApplicationTaggedUtf8String
```
public static UTF8String parseImplicitApplicationTaggedUtf8String(ASN1Object obj,
                                                                  int expectedTag,
                                                                  java.lang.String objName)
                                                           throws CodingException
```
    Ensures that the ASN.1 object is an [APPLICATION] IMPLICIT UTF8String with the indicated value.
    
    Parameters:
    
    obj - an ASN.1 object
    
    expectedTag - the tag value that is expected
    
    objName - a string name for this ASN.1 object (used in excpetion messages)
    
    Returns:
    
    the UTF8String that this [APPLICATION] IMPLICIT tagged ASN.1 object represents
    
    Throws:
    
    CodingException - if the ASN.1 object is not an [APPLICATION] IMPLICIT UTF8String with the indicated value

Class APPLICATION

Field Summary

Fields inherited from class iaik.asn1.ConstructedType

Fields inherited from class iaik.asn1.ASN1Object

Constructor Summary

Method Summary

Methods inherited from class iaik.asn1.TaggedType

Methods inherited from class iaik.asn1.ConstructedType

Methods inherited from class iaik.asn1.ASN1Object

Methods inherited from class java.lang.Object

Constructor Detail

APPLICATION

APPLICATION

APPLICATION

Method Detail

parseImplicitApplicationTaggedOctetString

parseImplicitApplicationTaggedSequence

parseImplicitApplicationTaggedUtf8String