1. Abstract Syntax Notation One ASN.1
In the Name of the Most High
Abstract Syntax Notation One ASN.1 by
Behzad Akbari
Fall 2011
These slides are based in parts upon slides of Prof. Dssouli (Concordia university)

2. Abstract Syntax Notation One
Both the information and communications models need to be specified syntactically and semantically.
This requires a language that specifies the management protocol in the application layer.
This is where Abstract Syntax Notation One (ASN.1) plays a role.
ASN.1 is actually more than a syntax; it’s a language that addresses both syntax and semantics
Two type of syntax
Abstract syntax: set of rules that specify data type and structure for information storage
Transfer syntax: set of rules for communicating information between systems
Can generate machine-readable code: Basic Encoding Rules (BER)
ASN.1 is based on the Backus system and uses the formal syntax and grammar of the Backus-Nauer Form (BNF)

3. Backus-Nauer Form (BNF)
Definition: <name> ::= <definition>  where <name> denotes “entity” and the symbol “::=“ represents “defined as”
primitive definitions:
<digit> ::= 0|1|2|3|4|5|6|7|8|9
<op> ::= +|-|x|/
similarly, an entity number can be constructed from primitives:
<number> ::= <number> | <digit> <number>
Example:
9 is primitive 9
19 is construct of 1 and 9
619 is construct of 6 and 19

4. ASN.1 Assignments Assignments
<BooleanType> ::= BOOLEAN  data type assignment (or name of the entity)
<BooleanValue> ::= TRUE | FALSE  value assignment (assigned value to the data type)
Group of assignments: Modules
Start with capital letters
Usually modules are built from primitive (atomic) data types (e.g., INTEGER, REAL, etc..)
May use ASN.1 constructs (e.g., SET, SEQUENCE, etc.)
Constructors are used to build structured data types
Backward and forward references, and inline definition

5. ASN.1 Modules Constructs: “list makers” Primitives data types
A module PersonnelRecord
(a set of data types)
Constructs: “list makers”
Primitives data types
Construct: alternatives
Three construction mechanisms (develop structured data types):
Alternatives: CHOICE
List: SET and SEQUENCE
Repetition: SET OF and SEQUENCE OF

6. ASN.1 Modules Example: “Smith”, “Manager”, {“North”, “Chile”}
Lists built with “SEQUENCE”
maintains the correct order
PersonnelRecord is a set of
different data types, each uniquely
associated with a name and can
be encoded and transmitted
in any order.
Example:
“Smith”, “Manager”, {“North”, “Chile”}
“Manager”, “Smith”, {“North”, “Chile”}
{“North”, “Chile”}, “Smith”, “Manager”

7. ASN.1 Symbols Symbol Meaning ::= Defined as
| or, alternative, options of a list
- Signed number
-- Following the symbol are comments
{} Start and end of a list
[] Start and end of a tag
() Start and end of subtype
.. Range

8. Data Types Structure: simple (or atomic), structured, etc..
Data types are generally defined based on a structure and a tag:
Structure: simple (or atomic), structured, etc..
Tag: class and a tag

9. Data Type: Structure & Tag Structure defines how data type is built
Tag uniquely identifies the data type

10. ASN.1 simple types Basic Types
BOOLEAN
INTEGER
ENUMERATED
REAL
BIT STRING
OCTET STRING
Character String Types (various subsets of ISO )
NumericString (0-9,<space>)
PrintableString (0-9,A-Z,a z,<space>,<special>)
VisibleString
GraphicString
TeletexString
UTF8String
IA5String

11. ASN.1 simple types Syntax : <type name> ::= type
Example: counter ::= INTEGER
IpAddress ::= OCTET STRING
PageNumber ::= INTEGER
ChapterNumber::= INTEGER
Months ::= ENUMERATED {january (1),
february (2),
march (3),
april (4),
may (5),
june (6),
july (7
august (8),
september (9),
october (10),
november (11),
december (12)}

12. ASN.1 simple types A subtype is derived from a parent type
Syntax: <subtype name> ::= <type> ( <constraint> )
Examples:
Counter ::= INTEGER ( )
IpAddress ::= OCTET STRING ( SIZE(4) )
Spring ::= Months ( march | april | may )
Summer ::= Months ( june | july | august )
SmallPrime ::= INTEGER ( 2 | 3 | 5 | 7 | 11 )

13. Structure PageNumber ::= INTEGER
Simple
PageNumber ::= INTEGER
ChapterNumber ::= INTEGER
Structured / Construct
BookPageNumber ::= SEQUENCE {ChapterNumber, Separator, PageNumber}
Tagged
Derived from another type; given a new ID
In Fig. 3-14, INTEGER is either universal or application specific
Other
CHOICE, ANY

14. Structured Type SEQUENCE SEQUENCE OF SET SET OF Ordered list maker
Ordered array of repetitive data
SET
Unordered list maker
SET OF
Unordered list of repetitive data

15. ASN.1 structured types
A data type is structured type when it contains other types (i.e., have components)
BookPageNumber ::= SEQUENCE {ChapterNumber, Separator, PageNumber}
separator is a VisibleString data type with value “-”
Example: {1-1, 2-3, 3-39}
BookPages ::= SEQUENCE OF { BookPageNumber }
BookPages ::= SEQUENCE OF {
SEQUENCE
{ChapterNumber, Separator, PageNumber}}
Example: {1-1, 1-2,..,2-1, 2-2,…..}

16. ASN.1 structured types
The pages of a book could also be specified as a collection of individual pages in random order
BookPages ::= SET OF {
SEQUENCE
{ChapterNumber, Separator, PageNumber} }

17. ASN.1 Tagged Types
Tag uniquely identifies a data type and is required for encoding the data types for communication
Comprises class and tag number
Class:
Universal - similar to global variables
Application - only in the application used
Context-specific - specific context in application
Private - used extensively by commercial vendors
Example: BOOLEAN Universal 1 INTEGER Universal 2 research Application [1]
product-based Context-specific under research [0]

18. ASN.1 Tagged Types UNIVERSAL 1 UNIVERSAL 3 UNIVERSAL 9 UNIVERSAL 10
BOOLEAN
BIT STRING
REAL
ENUMERATED
UNIVERSAL 2
INTEGER
UNIVERSAL 4
OCTET STRING
- basic types
UNIVERSAL 6
UNIVERSAL 7
ObjectDescriptor
OBJECT IDENTIFIER
- object types
- character string types
UNIVERSAL 26
VisibleString
. . .
UNIVERSAL 5
NULL
UNIVERSAL 23
UTCTime
UNIVERSAL 24
GeneralizedTime
- miscellaneous types
- structured types
UNIVERSAL 16
SEQUENCE [OF]
UNIVERSAL 17
SET [OF]

19. ASN.1 Tagged Types Tag nb is 1 (overrides that of BOOLEAN)
Application specific
Context specific (subset of
an application, and limited
to the application)

20. ASN.1 Object Types Used to name and describe information objects
Such as standard documents, data structures, managed objects
In general, an information object is a class of information, e.g., file format, rather than an instance of such a class (i.e., individual file)
Object identifier is a unique identifier for a particular object and its value consist of a set of integers
Object descriptor is a human readable description of an information object

21. ASN.1 Object Types root ccitt(0) iso(1) joint-iso-ccitt(2) org(3)
dod(6)
internet(1)
mgmt(2)
private(4)
experimental(3)
mib-2(1)
enterprise(1)
internet OBJECT IDENTIFIER ::= {iso(1) org(3) dod(6) 1 }
private OBJECT IDENTIFIER ::= {internet 4 }

22. ASN.1 Object Types
Private type is used extensively by vendors of network products
A vendor is assigned a node on the MIT, all branches and leaves under that node will be assigned private data types by the vendor
ibm OBJECT IDENTIFIER ::= {iso(1) org(3) dod(6) internet(1) private(4) enterprize(1) 2}

23. Encoding Structure
ASN.1 syntax containing management information is encoded using the Basic Encoding Rules (BER) that is defined for the transfer syntax
BER is a specification developed and standardized by CCITT and OSI
ASCII data is converted to bit-oriented data
TLV, Type-Length-Value: is a specific encoding structure
Type: indicates the ASN.1 type, class of the type
Length: length of the actual value representation
Value: the value of the ASN.1 type as a string of octets

24. Encoding Structure
1 byte
P/C (1-bit) specifies whether the structure is simple or a construct
0 for simple
1 for construct

25. Encoding Structure Class (2 bits): specifies the class being used
1 byte
Class (2 bits): specifies the class being used

26. Encoding Structure Tag Number: designates the tag value in binary
1 byte
Tag Number: designates the tag value in binary
Example: for encoding INTEGER
Universal class
Primitive
Tag value = 2

27. Tag number < 31 Identifier Octet Class P/C Tag number 8 7 6 5 4 3 2
Bits
Identifier Octet
Class
P/C
Tag number
0 0 = Universal
0 1 = Application
1 0 = Context-specific
1 1 = Private
0 = Primitive
1 = Constructed

28. Tag number >= 31 Class P/C 1 1 1 1 1 Leading octet 2nd octet
Last octet 1 1
. . . +
. . .
= Tag number

29. Encoding of Length Field
Short form ( L < 128 octets)
Length L
one octet
Contents (or Value) field
L octets
Long form ( 128  L < octets) 1 K
first octet
Length L
K octets
Contents field
L octets
Example, L = 128:
Binary equivalent of 128

30. BER, Examples 02 01 1B 02 00 81 51 02 00 81 Type Length Value
distance INTEGER ::= 27 00
00010
UNIVERSAL P 2
today INTEGER ::= 129 02
00 81
Length is 2 to
indicate 2 octets
for Value
DayOfYear ::= [APPLICATION 17] IMPLICIT INTEGER 01
10001
APPLICATION P 17 51 02
00 81
today DayOfYear ::= 129

31. BER, Examples
Birthday ::= SEQUENCE { name VisibleString, day DayOfYear }
Type Definition
UNIVERSAL 16
myBirthday Birthday ::= { name "Jane", day 129 }
Value Assignment
Birthday Length Contents ??
VisibleString Length Contents
1A "Jane"
DayOfYear Length Contents
BER Encoding 0A

32. Example: SNMP Message Message ::= SEQUENCE { version INTEGER {
Tag
Message ::= SEQUENCE {
version INTEGER {
version-1(0) },
community OCTET STRING,
data ANY } 30 02 04

33. Example: SNMP Message Type  30: SEQUENCE
Length  c0: 448 octets
82:

34. Type  30: SEQUENCE
Length  32: 50 octets

35. Macros <macroname> MACRO ::= BEGIN
TYPE NOTATION ::= <syntaxOfNewType>
VALUE NOTATION ::= <syntaxOfNewValue>
<auxiliaryAssignments>
END

36. Macro Example OBJECT-TYPE MACRO ::= BEGIN
TYPE NOTATION ::= "SYNTAX" type (TYPE ObjectSyntax)
“ACCESS" Access
"STATUS" Status
VALUE NOTATION ::= value (VALUE ObjectName)
Access ::= "read-only" | "read-write“ | "write-only | "not-accessible"
Status ::= "mandatory” | "optional“ | "obsolete"
END

37. Object-Type Example sysName OBJECT-TYPE
SYNTAX DisplayString (SIZE (0..255))
ACCESS read-write
STATUS mandatory
::= { system 5 }

38. Marco Example 2 CAR MACRO::= BEGIN
TYPE NOTATION ::= Brand Engine CarType Year
VALUE NOTATION ::= value (VALUE OBJECT IDENTIFIER)
Brand ::= “BRAND” value (PrintableString)
Engine ::= “CC” Ccs
Ccs ::= Cc | Ccs”,” Cc
Cc ::= value (INTEGER ( ))
CarType ::= “STYLE” CType
CType ::= “Sedan” | “Liftback” | “SUV” | “Other”
Year ::= “YEAR” value (INTEGER)
END

39. Camry CAR
BRAND Toyota
CC 2000, 2400, 3000
STYLE Sedan
YEAR 2006
::= {toyota 3}