ASN.1 序列混淆

Question

I'm studying the syntax for ASN.1 , and I've read a lot of the relevant material online:

http://www.itu.int/rec/T-REC-X.690-200811-I/en
http://luca.ntop.org/Teaching/Appunti/asn1.html
http://www.obj-sys.com/asn1tutorial/node11.html

I'm very confused over the encoding of ASN.1 SEQUENCE types. In general, I realize that a SEQUENCE is basically an aggregate - what we'd call an OBJECT or an INSTANCE in most programming languages. It's basically a list of name/value pairs, similar to a JSON object. But unlike a JSON object, an ASN.1 SEQUENCE has an implicit SCHEMA, because it is an instance of a "class" .

So, the class/schema for a SEQUENCE might be something like:

{
  name  UTF8String
  age   INTEGER
}

And an INSTANCE of that schema could be the SEQUENCE

{
  "John Smith"
  42
}

But I'm totally confused as to how you can tell the difference between a CLASS and an INSTANCE in the actual BER encoding. In fact, I'm so confused, I'm not even sure if a ASN.1 SEQUENCE is supposed to be a class definition or an instance of a class.

The documentation seems to imply it's an instance:

8.9 Encoding of a sequence value

8.9.1 The encoding of a sequence value shall be constructed.

8.9.2 The contents octets shall consist of the complete encoding of one data value from each of the types listed in the ASN.1 definition of the sequence type, in the order of their appearance in the definition, unless the type was referenced with the keyword OPTIONAL or the keyword DEFAULT.

8.9.3 The encoding of a data value may, but need not, be present for a type which was referenced with the keyword OPTIONAL or the keyword DEFAULT. If present, it shall appear in the encoding at the point corresponding to the appearance of the type in the ASN.1 definition.

So it seems a SEQUENCE is just a list of data values, which must correspond to some schema (class). But ASN.1 doesn't have a CLASS type, so how do you get the actual class, so you know what class any given SEQUENCE is an instance of?

Answer 1

Suppose you write the following:

R DEFINITIONS AUTOMATIC TAGS ::=

 BEGIN

 USPostalAddress ::= SEQUENCE {

      street     IA5String,

      city       IA5String,

      state      IA5String (SIZE (2)) (FROM("A".."Z")),

      zipcode    IA5String (SIZE (5)) (FROM("0".."9"))

 }

 END

The part between BEGIN and END above is called a "type assignment". "USPostalAddress" is the name of a (user-defined) "type". By writing the above, you have specified a user-defined type and you have given a name to it. Each SEQUENCE construct (the above SEQUENCE construct, for example) is a "type". It's a complex type, in that it contains one or more "fields" each having its own type. A possible "value" of the above type is denoted as follows:

{ street "1234 Main St.", city "New York", state "NY", zipcode "12345" }

We are just talking about types and their values, not about classes and instances. Just like you can have a type INTEGER (0..15) whose values are integer numbers between 0 and 15, you can have a SEQUENCE type whose values are arrangements of lower-level values. The above sequence type is a very simple example of the data structures ("types") you can define in ASN.1.

(In ASN.1 there is also something called a "class" but it's a completely different thing.)

In ASN.1, messages of protocols are usually specified as top-level types (usually they are SEQUENCE or CHOICE types). A particular "message value" is a value of a top-level type. When you have a value of a top-level type in your hands, you can encode that value into a stream of bits by using one of the standard encoding rules (BER, PER, etc.). When you receive a stream of bits from the network which you know was a value of a particular ASN.1 type encoded in BER, PER, etc., you can decode those bits and obtain the original value.

Answer 2

ASN.1 file contains usually type assignments (type definitions) like this SEQUENCE type:

myMessage ::= SEQUENCE
{
    a INTEGER(0..100),
    b INTEGER
}

Those SEQUENCE types inside ASN.1 file can be considered same as classes in C++/java or struct definitions in C.

Instances of SEQUENCE can be in encoded format (BER, PER, DER etc) or in local format (objects/variables) inside your programs.

Example how you could implement those in C code:

struct myMessage_t          
{
  int a;
  int b;
};

char buffer[1000];   // BER encoded instance will be stored to this buffer
myMessage_t msg;     // this is the local instance

msg.a = 1;
msg.b = 2;

size_t berLen = berEncode_myMessage( &msg, buffer, sizeof(buffer) );

And decoding side for that:

myMessage_t msg2;            
berDecode_myMessage( buffer, berLen, &msg2 );
assert( msg2.a == 1 );

You usually know what is the top level type of encoded instance, before you decode it.