lib/asn1/test.asn1

   1 -- $Id$ --
   2
   3 TEST DEFINITIONS ::=
   4
   5 BEGIN
   6
   7 IMPORTS HEIM_ANY FROM heim;
   8
   9 -- Check that we handle out of order definitions.
  10 -- The compiler should emit the definition of TESTOutOfOrderBar before that of
  11 -- TESTOutOfOrderFoo.
  12 TESTOutOfOrderFoo ::= SEQUENCE {
  13         bar TESTOutOfOrderBar
  14 }
  15
  16 TESTOutOfOrderBar ::= SEQUENCE {
  17         aMember INTEGER
  18 }
  19
  20 -- Check that we can handle rpc.mountd style "lists".  This is unnecessarily
  21 -- inefficient in its encoding, and there's no point to using this over
  22 -- SEQUENCE OF (arrays), but it's neat that we can do this now that we can do
  23 -- out of order definitions.
  24 --
  25 -- This could be useful if we ever extend asn1_compile to also handle XDR,
  26 -- which we well might since XDR's syntax is a dual of a strict subset of
  27 -- ASN.1, and since XDR the encoding is fairly straightforward.
  28 --
  29 -- Note that the `next' member has to be OPTIONAL for this to work.
  30 TESTCircular ::= SEQUENCE {
  31         name UTF8String,
  32         next TESTCircular OPTIONAL
  33 }
  34
  35 TESTDefault ::= SEQUENCE {
  36         name UTF8String DEFAULT "Heimdal",
  37         version [0] TESTuint32 DEFAULT 8,
  38         maxint TESTuint64 DEFAULT 9223372036854775807,
  39         works BOOLEAN DEFAULT TRUE
  40 }
  41
  42 TESTuint32 ::= INTEGER (0..4294967295)
  43 TESTuint64 ::= INTEGER(0..9223372036854775807)
  44 TESTint64 ::= INTEGER(-9223372036854775808..9223372036854775807)
  45
  46 TESTLargeTag ::= SEQUENCE {
  47         foo[127] INTEGER (-2147483648..2147483647),
  48         bar[128] INTEGER (-2147483648..2147483647)
  49 }
  50
  51 TESTSeq ::= SEQUENCE {
  52         tag0[0] INTEGER (-2147483648..2147483647),
  53         tag1[1] TESTLargeTag,
  54         tagless INTEGER (-2147483648..2147483647),
  55         tag3[2] INTEGER (-2147483648..2147483647)
  56 }
  57
  58 TESTChoice1 ::= CHOICE {
  59         i1[1]   INTEGER (-2147483648..2147483647),
  60         i2[2]   INTEGER (-2147483648..2147483647),
  61         ...
  62 }
  63
  64 TESTChoice2 ::= CHOICE {
  65         i1[1]   INTEGER (-2147483648..2147483647),
  66         ...
  67 }
  68
  69 TESTInteger ::= INTEGER (-2147483648..2147483647)
  70
  71 TESTInteger2 ::= [4] IMPLICIT TESTInteger
  72 TESTInteger3 ::= [5] IMPLICIT TESTInteger2
  73
  74 TESTImplicit ::= SEQUENCE {
  75         ti1[0] IMPLICIT INTEGER (-2147483648..2147483647),
  76         ti2[1] IMPLICIT SEQUENCE {
  77                 foo[127] INTEGER (-2147483648..2147483647)
  78         },
  79         ti3[2] IMPLICIT [5] IMPLICIT [4] IMPLICIT INTEGER (-2147483648..2147483647)
  80 }
  81
  82 TESTImplicit2 ::= SEQUENCE {
  83         ti1[0]  IMPLICIT TESTInteger,
  84 --      ti2[1]  IMPLICIT TESTLargeTag,   this is disabled since the IMPLICT encoder does't get the types right when stepping inside an structure --
  85         ti3[2]  IMPLICIT TESTInteger3,
  86         ti4[51] IMPLICIT TESTInteger OPTIONAL
  87 }
  88
  89 TESTImplicit3 ::= CHOICE {
  90         ti1[0] IMPLICIT INTEGER (-2147483648..2147483647),
  91         ti2[5] IMPLICIT CHOICE { i1[1] INTEGER (-2147483648..2147483647) }
  92 }
  93
  94 TESTImplicit4 ::= CHOICE {
  95         ti1[0] IMPLICIT INTEGER (-2147483648..2147483647),
  96         ti2[5] IMPLICIT TESTChoice2
  97 }
  98
  99 TESTAllocInner ::= SEQUENCE {
 100         ai[0] TESTInteger
 101 }
 102
 103 TESTAlloc ::= SEQUENCE {
 104           tagless TESTAllocInner OPTIONAL,
 105           three [1] INTEGER (-2147483648..2147483647),
 106           tagless2 HEIM_ANY OPTIONAL
 107 }
 108
 109 TESTOptional ::= SEQUENCE {
 110           zero [0] INTEGER (-2147483648..2147483647) OPTIONAL,
 111           one [1] INTEGER (-2147483648..2147483647) OPTIONAL
 112 }
 113
 114
 115 TESTCONTAINING ::= OCTET STRING ( CONTAINING INTEGER )
 116 TESTENCODEDBY ::= OCTET STRING ( ENCODED BY
 117   { joint-iso-itu-t(2) asn(1) ber-derived(2) distinguished-encoding(1) }
 118 )
 119
 120 testDer OBJECT IDENTIFIER ::= {
 121         joint-iso-itu-t(2) asn(1) ber-derived(2) distinguished-encoding(1)
 122 }
 123
 124 testContainingEncodedBy ::= OCTET STRING ( CONTAINING INTEGER ENCODED BY
 125   { joint-iso-itu-t(2) asn(1) ber-derived(2) distinguished-encoding(1) }
 126 )
 127
 128 testContainingEncodedBy2 ::= OCTET STRING (
 129         CONTAINING INTEGER ENCODED BY testDer
 130 )
 131
 132
 133 testValue1 INTEGER ::= 1
 134
 135 testUserConstrained ::= OCTET STRING (CONSTRAINED BY { -- meh -- })
 136 -- TESTUSERCONSTRAINED2 ::= OCTET STRING (CONSTRAINED BY { TESTInteger })
 137 -- TESTUSERCONSTRAINED3 ::= OCTET STRING (CONSTRAINED BY { INTEGER })
 138 -- TESTUSERCONSTRAINED4 ::= OCTET STRING (CONSTRAINED BY { INTEGER : 1 })
 139
 140 TESTSeqOf ::= SEQUENCE OF TESTInteger
 141
 142 TESTSeqSizeOf1 ::= SEQUENCE SIZE (2) OF TESTInteger
 143 TESTSeqSizeOf2 ::= SEQUENCE SIZE (1..2) OF TESTInteger
 144 TESTSeqSizeOf3 ::= SEQUENCE SIZE (1..MAX) OF TESTInteger
 145 TESTSeqSizeOf4 ::= SEQUENCE SIZE (0..2) OF TESTInteger
 146
 147 TESTOSSize1 ::= OCTET STRING SIZE (1..2)
 148
 149 TESTSeqOfSeq ::= SEQUENCE OF SEQUENCE {
 150         zero [0] TESTInteger
 151 }
 152
 153 TESTSeqOfSeq2 ::= SEQUENCE OF SEQUENCE {
 154         string [0] GeneralString
 155 }
 156
 157 TESTSeqOfSeq3 ::= SEQUENCE OF SEQUENCE {
 158         zero [0] TESTInteger,
 159         string [0] GeneralString
 160 }
 161
 162 TESTSeqOf2 ::= SEQUENCE {
 163         strings SEQUENCE OF GeneralString
 164 }
 165
 166 TESTSeqOf3 ::= SEQUENCE {
 167         strings SEQUENCE OF GeneralString OPTIONAL
 168 }
 169
 170 -- Larger/more complex to increase odds of out-of-bounds
 171 -- read/writes if miscoded
 172
 173 TESTSeqOf4 ::= SEQUENCE {
 174         b1 [0] SEQUENCE OF SEQUENCE {
 175                 s1 OCTET STRING,
 176                 s2 OCTET STRING,
 177                 u1 TESTuint64,
 178                 u2 TESTuint64
 179         } OPTIONAL,
 180         b2 [1] IMPLICIT SEQUENCE OF SEQUENCE {
 181                 u1 TESTuint64,
 182                 u2 TESTuint64,
 183                 u3 TESTuint64,
 184                 s1 OCTET STRING,
 185                 s2 OCTET STRING,
 186                 s3 OCTET STRING
 187         } OPTIONAL,
 188         b3 [2] IMPLICIT SEQUENCE OF SEQUENCE {
 189                 s1 OCTET STRING,
 190                 u1 TESTuint64,
 191                 s2 OCTET STRING,
 192                 u2 TESTuint64,
 193                 s3 OCTET STRING,
 194                 u3 TESTuint64,
 195                 s4 OCTET STRING,
 196                 u4 TESTuint64
 197         } OPTIONAL
 198 }
 199
 200 TESTSeqOf5 ::= SEQUENCE {
 201         outer SEQUENCE {
 202           inner SEQUENCE {
 203                         u0 TESTuint64,
 204                         s0 OCTET STRING,
 205                         u1 TESTuint64,
 206                         s1 OCTET STRING,
 207                         u2 TESTuint64,
 208                         s2 OCTET STRING,
 209                         u3 TESTuint64,
 210                         s3 OCTET STRING,
 211                         u4 TESTuint64,
 212                         s4 OCTET STRING,
 213                         u5 TESTuint64,
 214                         s5 OCTET STRING,
 215                         u6 TESTuint64,
 216                         s6 OCTET STRING,
 217                         u7 TESTuint64,
 218                         s7 OCTET STRING
 219                 }
 220             }
 221         OPTIONAL
 222 }
 223
 224 TESTPreserve ::= SEQUENCE {
 225         zero [0] TESTInteger,
 226         one [1] TESTInteger
 227 }
 228
 229 TESTBitString ::= BIT STRING {
 230               zero(0),
 231               eight(8),
 232               thirtyone(31)
 233 }
 234
 235 TESTBitString64 ::= BIT STRING {
 236               zero(0),
 237               eight(8),
 238               thirtyone(31),
 239               thirtytwo(32),
 240               sixtythree(63)
 241 }
 242
 243 TESTLargeBitString ::= BIT STRING {
 244               zero(0),
 245               eight(8),
 246               thirtyone(31),
 247               onehundredtwenty(120)
 248 }
 249
 250 TESTMechType::= OBJECT IDENTIFIER
 251 TESTMechTypeList ::= SEQUENCE OF TESTMechType
 252
 253
 254 -- IOS stuff
 255 _EXTENSION ::= CLASS {
 256     &id  OBJECT IDENTIFIER UNIQUE,
 257     &ExtnType,
 258     &Critical    BOOLEAN DEFAULT FALSE
 259 }
 260
 261 TESTExtension{_EXTENSION:ExtensionSet} ::= SEQUENCE {
 262     extnID      _EXTENSION.&id({ExtensionSet}),
 263     critical    BOOLEAN
 264 --                     (EXTENSION.&Critical({ExtensionSet}{@extnID}))
 265                      DEFAULT FALSE,
 266     extnValue   OCTET STRING (CONTAINING
 267                 _EXTENSION.&ExtnType({ExtensionSet}{@extnID}))
 268 }
 269
 270 id-test-default OBJECT IDENTIFIER ::=  { 1 2 3 4 }
 271 testext-TESTDefault _EXTENSION ::= {
 272      &id id-test-default,
 273      &Critical FALSE,
 274      &ExtnType TESTDefault
 275 }
 276
 277 -- And Here's an object set for the EXTENSION CLASS collecting a bunch of
 278 -- related extensions (here they are the extensions that certificates can
 279 -- carry in their extensions member):
 280 TestExtensions _EXTENSION ::= { testext-TESTDefault }
 281
 282 TESTExtension ::= TESTExtension { TestExtensions }
 283
 284 TESTExtensible ::= SEQUENCE {
 285   version     INTEGER,
 286   extensions  SEQUENCE OF TESTExtension
 287 }
 288
 289 TESTDecorated ::= SEQUENCE {
 290   version     TESTuint32
 291   -- gets decorated with varius fields (see test.opt)
 292 }
 293
 294 TESTNotDecorated ::= SEQUENCE {
 295   version     TESTuint32
 296   -- should have the same encoding as TESTDecorated
 297 }
 298
 299 TESTDecoratedChoice ::= CHOICE {
 300   version     TESTuint32
 301   -- gets decorated with varius fields (see test.opt)
 302 }
 303
 304 TESTNotDecoratedChoice ::= CHOICE {
 305   version     TESTuint32
 306   -- should have the same encoding as TESTDecoratedChoice
 307 }
 308
 309 END