1 /* 2 * Copyright 2000-2016 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the OpenSSL license (the "License"). You may not use 5 * this file except in compliance with the License. You can obtain a copy 6 * in the file LICENSE in the source distribution or at 7 * https://www.openssl.org/source/license.html 8 */ 9 10 #ifndef HEADER_ASN1T_H 11 # define HEADER_ASN1T_H 12 13 # include <stddef.h> 14 # include <openssl/e_os2.h> 15 # include <openssl/asn1.h> 16 17 # ifdef OPENSSL_BUILD_SHLIBCRYPTO 18 # undef OPENSSL_EXTERN 19 # define OPENSSL_EXTERN OPENSSL_EXPORT 20 # endif 21 22 /* ASN1 template defines, structures and functions */ 23 24 #ifdef __cplusplus 25 extern "C" { 26 #endif 27 28 # ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION 29 30 /* Macro to obtain ASN1_ADB pointer from a type (only used internally) */ 31 # define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)(iptr)) 32 33 /* Macros for start and end of ASN1_ITEM definition */ 34 35 # define ASN1_ITEM_start(itname) \ 36 const ASN1_ITEM itname##_it = { 37 38 # define static_ASN1_ITEM_start(itname) \ 39 static const ASN1_ITEM itname##_it = { 40 41 # define ASN1_ITEM_end(itname) \ 42 }; 43 44 # else 45 46 /* Macro to obtain ASN1_ADB pointer from a type (only used internally) */ 47 # define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)((iptr)())) 48 49 /* Macros for start and end of ASN1_ITEM definition */ 50 51 # define ASN1_ITEM_start(itname) \ 52 const ASN1_ITEM * itname##_it(void) \ 53 { \ 54 static const ASN1_ITEM local_it = { 55 56 # define static_ASN1_ITEM_start(itname) \ 57 static ASN1_ITEM_start(itname) 58 59 # define ASN1_ITEM_end(itname) \ 60 }; \ 61 return &local_it; \ 62 } 63 64 # endif 65 66 /* Macros to aid ASN1 template writing */ 67 68 # define ASN1_ITEM_TEMPLATE(tname) \ 69 static const ASN1_TEMPLATE tname##_item_tt 70 71 # define ASN1_ITEM_TEMPLATE_END(tname) \ 72 ;\ 73 ASN1_ITEM_start(tname) \ 74 ASN1_ITYPE_PRIMITIVE,\ 75 -1,\ 76 &tname##_item_tt,\ 77 0,\ 78 NULL,\ 79 0,\ 80 #tname \ 81 ASN1_ITEM_end(tname) 82 # define static_ASN1_ITEM_TEMPLATE_END(tname) \ 83 ;\ 84 static_ASN1_ITEM_start(tname) \ 85 ASN1_ITYPE_PRIMITIVE,\ 86 -1,\ 87 &tname##_item_tt,\ 88 0,\ 89 NULL,\ 90 0,\ 91 #tname \ 92 ASN1_ITEM_end(tname) 93 94 /* This is a ASN1 type which just embeds a template */ 95 96 /*- 97 * This pair helps declare a SEQUENCE. We can do: 98 * 99 * ASN1_SEQUENCE(stname) = { 100 * ... SEQUENCE components ... 101 * } ASN1_SEQUENCE_END(stname) 102 * 103 * This will produce an ASN1_ITEM called stname_it 104 * for a structure called stname. 105 * 106 * If you want the same structure but a different 107 * name then use: 108 * 109 * ASN1_SEQUENCE(itname) = { 110 * ... SEQUENCE components ... 111 * } ASN1_SEQUENCE_END_name(stname, itname) 112 * 113 * This will create an item called itname_it using 114 * a structure called stname. 115 */ 116 117 # define ASN1_SEQUENCE(tname) \ 118 static const ASN1_TEMPLATE tname##_seq_tt[] 119 120 # define ASN1_SEQUENCE_END(stname) ASN1_SEQUENCE_END_name(stname, stname) 121 122 # define static_ASN1_SEQUENCE_END(stname) static_ASN1_SEQUENCE_END_name(stname, stname) 123 124 # define ASN1_SEQUENCE_END_name(stname, tname) \ 125 ;\ 126 ASN1_ITEM_start(tname) \ 127 ASN1_ITYPE_SEQUENCE,\ 128 V_ASN1_SEQUENCE,\ 129 tname##_seq_tt,\ 130 sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ 131 NULL,\ 132 sizeof(stname),\ 133 #tname \ 134 ASN1_ITEM_end(tname) 135 136 # define static_ASN1_SEQUENCE_END_name(stname, tname) \ 137 ;\ 138 static_ASN1_ITEM_start(tname) \ 139 ASN1_ITYPE_SEQUENCE,\ 140 V_ASN1_SEQUENCE,\ 141 tname##_seq_tt,\ 142 sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ 143 NULL,\ 144 sizeof(stname),\ 145 #stname \ 146 ASN1_ITEM_end(tname) 147 148 # define ASN1_NDEF_SEQUENCE(tname) \ 149 ASN1_SEQUENCE(tname) 150 151 # define ASN1_NDEF_SEQUENCE_cb(tname, cb) \ 152 ASN1_SEQUENCE_cb(tname, cb) 153 154 # define ASN1_SEQUENCE_cb(tname, cb) \ 155 static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \ 156 ASN1_SEQUENCE(tname) 157 158 # define ASN1_BROKEN_SEQUENCE(tname) \ 159 static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_BROKEN, 0, 0, 0, 0}; \ 160 ASN1_SEQUENCE(tname) 161 162 # define ASN1_SEQUENCE_ref(tname, cb) \ 163 static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_REFCOUNT, offsetof(tname, references), offsetof(tname, lock), cb, 0}; \ 164 ASN1_SEQUENCE(tname) 165 166 # define ASN1_SEQUENCE_enc(tname, enc, cb) \ 167 static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_ENCODING, 0, 0, cb, offsetof(tname, enc)}; \ 168 ASN1_SEQUENCE(tname) 169 170 # define ASN1_NDEF_SEQUENCE_END(tname) \ 171 ;\ 172 ASN1_ITEM_start(tname) \ 173 ASN1_ITYPE_NDEF_SEQUENCE,\ 174 V_ASN1_SEQUENCE,\ 175 tname##_seq_tt,\ 176 sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ 177 NULL,\ 178 sizeof(tname),\ 179 #tname \ 180 ASN1_ITEM_end(tname) 181 # define static_ASN1_NDEF_SEQUENCE_END(tname) \ 182 ;\ 183 static_ASN1_ITEM_start(tname) \ 184 ASN1_ITYPE_NDEF_SEQUENCE,\ 185 V_ASN1_SEQUENCE,\ 186 tname##_seq_tt,\ 187 sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ 188 NULL,\ 189 sizeof(tname),\ 190 #tname \ 191 ASN1_ITEM_end(tname) 192 193 # define ASN1_BROKEN_SEQUENCE_END(stname) ASN1_SEQUENCE_END_ref(stname, stname) 194 # define static_ASN1_BROKEN_SEQUENCE_END(stname) \ 195 static_ASN1_SEQUENCE_END_ref(stname, stname) 196 197 # define ASN1_SEQUENCE_END_enc(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname) 198 199 # define ASN1_SEQUENCE_END_cb(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname) 200 # define static_ASN1_SEQUENCE_END_cb(stname, tname) static_ASN1_SEQUENCE_END_ref(stname, tname) 201 202 # define ASN1_SEQUENCE_END_ref(stname, tname) \ 203 ;\ 204 ASN1_ITEM_start(tname) \ 205 ASN1_ITYPE_SEQUENCE,\ 206 V_ASN1_SEQUENCE,\ 207 tname##_seq_tt,\ 208 sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ 209 &tname##_aux,\ 210 sizeof(stname),\ 211 #tname \ 212 ASN1_ITEM_end(tname) 213 # define static_ASN1_SEQUENCE_END_ref(stname, tname) \ 214 ;\ 215 static_ASN1_ITEM_start(tname) \ 216 ASN1_ITYPE_SEQUENCE,\ 217 V_ASN1_SEQUENCE,\ 218 tname##_seq_tt,\ 219 sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ 220 &tname##_aux,\ 221 sizeof(stname),\ 222 #stname \ 223 ASN1_ITEM_end(tname) 224 225 # define ASN1_NDEF_SEQUENCE_END_cb(stname, tname) \ 226 ;\ 227 ASN1_ITEM_start(tname) \ 228 ASN1_ITYPE_NDEF_SEQUENCE,\ 229 V_ASN1_SEQUENCE,\ 230 tname##_seq_tt,\ 231 sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ 232 &tname##_aux,\ 233 sizeof(stname),\ 234 #stname \ 235 ASN1_ITEM_end(tname) 236 237 /*- 238 * This pair helps declare a CHOICE type. We can do: 239 * 240 * ASN1_CHOICE(chname) = { 241 * ... CHOICE options ... 242 * ASN1_CHOICE_END(chname) 243 * 244 * This will produce an ASN1_ITEM called chname_it 245 * for a structure called chname. The structure 246 * definition must look like this: 247 * typedef struct { 248 * int type; 249 * union { 250 * ASN1_SOMETHING *opt1; 251 * ASN1_SOMEOTHER *opt2; 252 * } value; 253 * } chname; 254 * 255 * the name of the selector must be 'type'. 256 * to use an alternative selector name use the 257 * ASN1_CHOICE_END_selector() version. 258 */ 259 260 # define ASN1_CHOICE(tname) \ 261 static const ASN1_TEMPLATE tname##_ch_tt[] 262 263 # define ASN1_CHOICE_cb(tname, cb) \ 264 static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \ 265 ASN1_CHOICE(tname) 266 267 # define ASN1_CHOICE_END(stname) ASN1_CHOICE_END_name(stname, stname) 268 269 # define static_ASN1_CHOICE_END(stname) static_ASN1_CHOICE_END_name(stname, stname) 270 271 # define ASN1_CHOICE_END_name(stname, tname) ASN1_CHOICE_END_selector(stname, tname, type) 272 273 # define static_ASN1_CHOICE_END_name(stname, tname) static_ASN1_CHOICE_END_selector(stname, tname, type) 274 275 # define ASN1_CHOICE_END_selector(stname, tname, selname) \ 276 ;\ 277 ASN1_ITEM_start(tname) \ 278 ASN1_ITYPE_CHOICE,\ 279 offsetof(stname,selname) ,\ 280 tname##_ch_tt,\ 281 sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ 282 NULL,\ 283 sizeof(stname),\ 284 #stname \ 285 ASN1_ITEM_end(tname) 286 287 # define static_ASN1_CHOICE_END_selector(stname, tname, selname) \ 288 ;\ 289 static_ASN1_ITEM_start(tname) \ 290 ASN1_ITYPE_CHOICE,\ 291 offsetof(stname,selname) ,\ 292 tname##_ch_tt,\ 293 sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ 294 NULL,\ 295 sizeof(stname),\ 296 #stname \ 297 ASN1_ITEM_end(tname) 298 299 # define ASN1_CHOICE_END_cb(stname, tname, selname) \ 300 ;\ 301 ASN1_ITEM_start(tname) \ 302 ASN1_ITYPE_CHOICE,\ 303 offsetof(stname,selname) ,\ 304 tname##_ch_tt,\ 305 sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ 306 &tname##_aux,\ 307 sizeof(stname),\ 308 #stname \ 309 ASN1_ITEM_end(tname) 310 311 /* This helps with the template wrapper form of ASN1_ITEM */ 312 313 # define ASN1_EX_TEMPLATE_TYPE(flags, tag, name, type) { \ 314 (flags), (tag), 0,\ 315 #name, ASN1_ITEM_ref(type) } 316 317 /* These help with SEQUENCE or CHOICE components */ 318 319 /* used to declare other types */ 320 321 # define ASN1_EX_TYPE(flags, tag, stname, field, type) { \ 322 (flags), (tag), offsetof(stname, field),\ 323 #field, ASN1_ITEM_ref(type) } 324 325 /* implicit and explicit helper macros */ 326 327 # define ASN1_IMP_EX(stname, field, type, tag, ex) \ 328 ASN1_EX_TYPE(ASN1_TFLG_IMPLICIT | (ex), tag, stname, field, type) 329 330 # define ASN1_EXP_EX(stname, field, type, tag, ex) \ 331 ASN1_EX_TYPE(ASN1_TFLG_EXPLICIT | (ex), tag, stname, field, type) 332 333 /* Any defined by macros: the field used is in the table itself */ 334 335 # ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION 336 # define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) } 337 # define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) } 338 # else 339 # define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, tblname##_adb } 340 # define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, tblname##_adb } 341 # endif 342 /* Plain simple type */ 343 # define ASN1_SIMPLE(stname, field, type) ASN1_EX_TYPE(0,0, stname, field, type) 344 /* Embedded simple type */ 345 # define ASN1_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_EMBED,0, stname, field, type) 346 347 /* OPTIONAL simple type */ 348 # define ASN1_OPT(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL, 0, stname, field, type) 349 # define ASN1_OPT_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED, 0, stname, field, type) 350 351 /* IMPLICIT tagged simple type */ 352 # define ASN1_IMP(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, 0) 353 # define ASN1_IMP_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_EMBED) 354 355 /* IMPLICIT tagged OPTIONAL simple type */ 356 # define ASN1_IMP_OPT(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL) 357 # define ASN1_IMP_OPT_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED) 358 359 /* Same as above but EXPLICIT */ 360 361 # define ASN1_EXP(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, 0) 362 # define ASN1_EXP_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_EMBED) 363 # define ASN1_EXP_OPT(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL) 364 # define ASN1_EXP_OPT_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED) 365 366 /* SEQUENCE OF type */ 367 # define ASN1_SEQUENCE_OF(stname, field, type) \ 368 ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, stname, field, type) 369 370 /* OPTIONAL SEQUENCE OF */ 371 # define ASN1_SEQUENCE_OF_OPT(stname, field, type) \ 372 ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type) 373 374 /* Same as above but for SET OF */ 375 376 # define ASN1_SET_OF(stname, field, type) \ 377 ASN1_EX_TYPE(ASN1_TFLG_SET_OF, 0, stname, field, type) 378 379 # define ASN1_SET_OF_OPT(stname, field, type) \ 380 ASN1_EX_TYPE(ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type) 381 382 /* Finally compound types of SEQUENCE, SET, IMPLICIT, EXPLICIT and OPTIONAL */ 383 384 # define ASN1_IMP_SET_OF(stname, field, type, tag) \ 385 ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF) 386 387 # define ASN1_EXP_SET_OF(stname, field, type, tag) \ 388 ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF) 389 390 # define ASN1_IMP_SET_OF_OPT(stname, field, type, tag) \ 391 ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL) 392 393 # define ASN1_EXP_SET_OF_OPT(stname, field, type, tag) \ 394 ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL) 395 396 # define ASN1_IMP_SEQUENCE_OF(stname, field, type, tag) \ 397 ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF) 398 399 # define ASN1_IMP_SEQUENCE_OF_OPT(stname, field, type, tag) \ 400 ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL) 401 402 # define ASN1_EXP_SEQUENCE_OF(stname, field, type, tag) \ 403 ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF) 404 405 # define ASN1_EXP_SEQUENCE_OF_OPT(stname, field, type, tag) \ 406 ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL) 407 408 /* EXPLICIT using indefinite length constructed form */ 409 # define ASN1_NDEF_EXP(stname, field, type, tag) \ 410 ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_NDEF) 411 412 /* EXPLICIT OPTIONAL using indefinite length constructed form */ 413 # define ASN1_NDEF_EXP_OPT(stname, field, type, tag) \ 414 ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_NDEF) 415 416 /* Macros for the ASN1_ADB structure */ 417 418 # define ASN1_ADB(name) \ 419 static const ASN1_ADB_TABLE name##_adbtbl[] 420 421 # ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION 422 423 # define ASN1_ADB_END(name, flags, field, adb_cb, def, none) \ 424 ;\ 425 static const ASN1_ADB name##_adb = {\ 426 flags,\ 427 offsetof(name, field),\ 428 adb_cb,\ 429 name##_adbtbl,\ 430 sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\ 431 def,\ 432 none\ 433 } 434 435 # else 436 437 # define ASN1_ADB_END(name, flags, field, adb_cb, def, none) \ 438 ;\ 439 static const ASN1_ITEM *name##_adb(void) \ 440 { \ 441 static const ASN1_ADB internal_adb = \ 442 {\ 443 flags,\ 444 offsetof(name, field),\ 445 adb_cb,\ 446 name##_adbtbl,\ 447 sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\ 448 def,\ 449 none\ 450 }; \ 451 return (const ASN1_ITEM *) &internal_adb; \ 452 } \ 453 void dummy_function(void) 454 455 # endif 456 457 # define ADB_ENTRY(val, template) {val, template} 458 459 # define ASN1_ADB_TEMPLATE(name) \ 460 static const ASN1_TEMPLATE name##_tt 461 462 /* 463 * This is the ASN1 template structure that defines a wrapper round the 464 * actual type. It determines the actual position of the field in the value 465 * structure, various flags such as OPTIONAL and the field name. 466 */ 467 468 struct ASN1_TEMPLATE_st { 469 unsigned long flags; /* Various flags */ 470 long tag; /* tag, not used if no tagging */ 471 unsigned long offset; /* Offset of this field in structure */ 472 const char *field_name; /* Field name */ 473 ASN1_ITEM_EXP *item; /* Relevant ASN1_ITEM or ASN1_ADB */ 474 }; 475 476 /* Macro to extract ASN1_ITEM and ASN1_ADB pointer from ASN1_TEMPLATE */ 477 478 # define ASN1_TEMPLATE_item(t) (t->item_ptr) 479 # define ASN1_TEMPLATE_adb(t) (t->item_ptr) 480 481 typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE; 482 typedef struct ASN1_ADB_st ASN1_ADB; 483 484 struct ASN1_ADB_st { 485 unsigned long flags; /* Various flags */ 486 unsigned long offset; /* Offset of selector field */ 487 int (*adb_cb)(long *psel); /* Application callback */ 488 const ASN1_ADB_TABLE *tbl; /* Table of possible types */ 489 long tblcount; /* Number of entries in tbl */ 490 const ASN1_TEMPLATE *default_tt; /* Type to use if no match */ 491 const ASN1_TEMPLATE *null_tt; /* Type to use if selector is NULL */ 492 }; 493 494 struct ASN1_ADB_TABLE_st { 495 long value; /* NID for an object or value for an int */ 496 const ASN1_TEMPLATE tt; /* item for this value */ 497 }; 498 499 /* template flags */ 500 501 /* Field is optional */ 502 # define ASN1_TFLG_OPTIONAL (0x1) 503 504 /* Field is a SET OF */ 505 # define ASN1_TFLG_SET_OF (0x1 << 1) 506 507 /* Field is a SEQUENCE OF */ 508 # define ASN1_TFLG_SEQUENCE_OF (0x2 << 1) 509 510 /* 511 * Special case: this refers to a SET OF that will be sorted into DER order 512 * when encoded *and* the corresponding STACK will be modified to match the 513 * new order. 514 */ 515 # define ASN1_TFLG_SET_ORDER (0x3 << 1) 516 517 /* Mask for SET OF or SEQUENCE OF */ 518 # define ASN1_TFLG_SK_MASK (0x3 << 1) 519 520 /* 521 * These flags mean the tag should be taken from the tag field. If EXPLICIT 522 * then the underlying type is used for the inner tag. 523 */ 524 525 /* IMPLICIT tagging */ 526 # define ASN1_TFLG_IMPTAG (0x1 << 3) 527 528 /* EXPLICIT tagging, inner tag from underlying type */ 529 # define ASN1_TFLG_EXPTAG (0x2 << 3) 530 531 # define ASN1_TFLG_TAG_MASK (0x3 << 3) 532 533 /* context specific IMPLICIT */ 534 # define ASN1_TFLG_IMPLICIT (ASN1_TFLG_IMPTAG|ASN1_TFLG_CONTEXT) 535 536 /* context specific EXPLICIT */ 537 # define ASN1_TFLG_EXPLICIT (ASN1_TFLG_EXPTAG|ASN1_TFLG_CONTEXT) 538 539 /* 540 * If tagging is in force these determine the type of tag to use. Otherwise 541 * the tag is determined by the underlying type. These values reflect the 542 * actual octet format. 543 */ 544 545 /* Universal tag */ 546 # define ASN1_TFLG_UNIVERSAL (0x0<<6) 547 /* Application tag */ 548 # define ASN1_TFLG_APPLICATION (0x1<<6) 549 /* Context specific tag */ 550 # define ASN1_TFLG_CONTEXT (0x2<<6) 551 /* Private tag */ 552 # define ASN1_TFLG_PRIVATE (0x3<<6) 553 554 # define ASN1_TFLG_TAG_CLASS (0x3<<6) 555 556 /* 557 * These are for ANY DEFINED BY type. In this case the 'item' field points to 558 * an ASN1_ADB structure which contains a table of values to decode the 559 * relevant type 560 */ 561 562 # define ASN1_TFLG_ADB_MASK (0x3<<8) 563 564 # define ASN1_TFLG_ADB_OID (0x1<<8) 565 566 # define ASN1_TFLG_ADB_INT (0x1<<9) 567 568 /* 569 * This flag when present in a SEQUENCE OF, SET OF or EXPLICIT causes 570 * indefinite length constructed encoding to be used if required. 571 */ 572 573 # define ASN1_TFLG_NDEF (0x1<<11) 574 575 /* Field is embedded and not a pointer */ 576 # define ASN1_TFLG_EMBED (0x1 << 12) 577 578 /* This is the actual ASN1 item itself */ 579 580 struct ASN1_ITEM_st { 581 char itype; /* The item type, primitive, SEQUENCE, CHOICE 582 * or extern */ 583 long utype; /* underlying type */ 584 const ASN1_TEMPLATE *templates; /* If SEQUENCE or CHOICE this contains 585 * the contents */ 586 long tcount; /* Number of templates if SEQUENCE or CHOICE */ 587 const void *funcs; /* functions that handle this type */ 588 long size; /* Structure size (usually) */ 589 const char *sname; /* Structure name */ 590 }; 591 592 /*- 593 * These are values for the itype field and 594 * determine how the type is interpreted. 595 * 596 * For PRIMITIVE types the underlying type 597 * determines the behaviour if items is NULL. 598 * 599 * Otherwise templates must contain a single 600 * template and the type is treated in the 601 * same way as the type specified in the template. 602 * 603 * For SEQUENCE types the templates field points 604 * to the members, the size field is the 605 * structure size. 606 * 607 * For CHOICE types the templates field points 608 * to each possible member (typically a union) 609 * and the 'size' field is the offset of the 610 * selector. 611 * 612 * The 'funcs' field is used for application 613 * specific functions. 614 * 615 * The EXTERN type uses a new style d2i/i2d. 616 * The new style should be used where possible 617 * because it avoids things like the d2i IMPLICIT 618 * hack. 619 * 620 * MSTRING is a multiple string type, it is used 621 * for a CHOICE of character strings where the 622 * actual strings all occupy an ASN1_STRING 623 * structure. In this case the 'utype' field 624 * has a special meaning, it is used as a mask 625 * of acceptable types using the B_ASN1 constants. 626 * 627 * NDEF_SEQUENCE is the same as SEQUENCE except 628 * that it will use indefinite length constructed 629 * encoding if requested. 630 * 631 */ 632 633 # define ASN1_ITYPE_PRIMITIVE 0x0 634 635 # define ASN1_ITYPE_SEQUENCE 0x1 636 637 # define ASN1_ITYPE_CHOICE 0x2 638 639 # define ASN1_ITYPE_EXTERN 0x4 640 641 # define ASN1_ITYPE_MSTRING 0x5 642 643 # define ASN1_ITYPE_NDEF_SEQUENCE 0x6 644 645 /* 646 * Cache for ASN1 tag and length, so we don't keep re-reading it for things 647 * like CHOICE 648 */ 649 650 struct ASN1_TLC_st { 651 char valid; /* Values below are valid */ 652 int ret; /* return value */ 653 long plen; /* length */ 654 int ptag; /* class value */ 655 int pclass; /* class value */ 656 int hdrlen; /* header length */ 657 }; 658 659 /* Typedefs for ASN1 function pointers */ 660 typedef int ASN1_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, 661 const ASN1_ITEM *it, int tag, int aclass, char opt, 662 ASN1_TLC *ctx); 663 664 typedef int ASN1_ex_i2d(ASN1_VALUE **pval, unsigned char **out, 665 const ASN1_ITEM *it, int tag, int aclass); 666 typedef int ASN1_ex_new_func(ASN1_VALUE **pval, const ASN1_ITEM *it); 667 typedef void ASN1_ex_free_func(ASN1_VALUE **pval, const ASN1_ITEM *it); 668 669 typedef int ASN1_ex_print_func(BIO *out, ASN1_VALUE **pval, 670 int indent, const char *fname, 671 const ASN1_PCTX *pctx); 672 673 typedef int ASN1_primitive_i2c(ASN1_VALUE **pval, unsigned char *cont, 674 int *putype, const ASN1_ITEM *it); 675 typedef int ASN1_primitive_c2i(ASN1_VALUE **pval, const unsigned char *cont, 676 int len, int utype, char *free_cont, 677 const ASN1_ITEM *it); 678 typedef int ASN1_primitive_print(BIO *out, ASN1_VALUE **pval, 679 const ASN1_ITEM *it, int indent, 680 const ASN1_PCTX *pctx); 681 682 typedef struct ASN1_EXTERN_FUNCS_st { 683 void *app_data; 684 ASN1_ex_new_func *asn1_ex_new; 685 ASN1_ex_free_func *asn1_ex_free; 686 ASN1_ex_free_func *asn1_ex_clear; 687 ASN1_ex_d2i *asn1_ex_d2i; 688 ASN1_ex_i2d *asn1_ex_i2d; 689 ASN1_ex_print_func *asn1_ex_print; 690 } ASN1_EXTERN_FUNCS; 691 692 typedef struct ASN1_PRIMITIVE_FUNCS_st { 693 void *app_data; 694 unsigned long flags; 695 ASN1_ex_new_func *prim_new; 696 ASN1_ex_free_func *prim_free; 697 ASN1_ex_free_func *prim_clear; 698 ASN1_primitive_c2i *prim_c2i; 699 ASN1_primitive_i2c *prim_i2c; 700 ASN1_primitive_print *prim_print; 701 } ASN1_PRIMITIVE_FUNCS; 702 703 /* 704 * This is the ASN1_AUX structure: it handles various miscellaneous 705 * requirements. For example the use of reference counts and an informational 706 * callback. The "informational callback" is called at various points during 707 * the ASN1 encoding and decoding. It can be used to provide minor 708 * customisation of the structures used. This is most useful where the 709 * supplied routines *almost* do the right thing but need some extra help at 710 * a few points. If the callback returns zero then it is assumed a fatal 711 * error has occurred and the main operation should be abandoned. If major 712 * changes in the default behaviour are required then an external type is 713 * more appropriate. 714 */ 715 716 typedef int ASN1_aux_cb(int operation, ASN1_VALUE **in, const ASN1_ITEM *it, 717 void *exarg); 718 719 typedef struct ASN1_AUX_st { 720 void *app_data; 721 int flags; 722 int ref_offset; /* Offset of reference value */ 723 int ref_lock; /* Lock type to use */ 724 ASN1_aux_cb *asn1_cb; 725 int enc_offset; /* Offset of ASN1_ENCODING structure */ 726 } ASN1_AUX; 727 728 /* For print related callbacks exarg points to this structure */ 729 typedef struct ASN1_PRINT_ARG_st { 730 BIO *out; 731 int indent; 732 const ASN1_PCTX *pctx; 733 } ASN1_PRINT_ARG; 734 735 /* For streaming related callbacks exarg points to this structure */ 736 typedef struct ASN1_STREAM_ARG_st { 737 /* BIO to stream through */ 738 BIO *out; 739 /* BIO with filters appended */ 740 BIO *ndef_bio; 741 /* Streaming I/O boundary */ 742 unsigned char **boundary; 743 } ASN1_STREAM_ARG; 744 745 /* Flags in ASN1_AUX */ 746 747 /* Use a reference count */ 748 # define ASN1_AFLG_REFCOUNT 1 749 /* Save the encoding of structure (useful for signatures) */ 750 # define ASN1_AFLG_ENCODING 2 751 /* The Sequence length is invalid */ 752 # define ASN1_AFLG_BROKEN 4 753 754 /* operation values for asn1_cb */ 755 756 # define ASN1_OP_NEW_PRE 0 757 # define ASN1_OP_NEW_POST 1 758 # define ASN1_OP_FREE_PRE 2 759 # define ASN1_OP_FREE_POST 3 760 # define ASN1_OP_D2I_PRE 4 761 # define ASN1_OP_D2I_POST 5 762 # define ASN1_OP_I2D_PRE 6 763 # define ASN1_OP_I2D_POST 7 764 # define ASN1_OP_PRINT_PRE 8 765 # define ASN1_OP_PRINT_POST 9 766 # define ASN1_OP_STREAM_PRE 10 767 # define ASN1_OP_STREAM_POST 11 768 # define ASN1_OP_DETACHED_PRE 12 769 # define ASN1_OP_DETACHED_POST 13 770 771 /* Macro to implement a primitive type */ 772 # define IMPLEMENT_ASN1_TYPE(stname) IMPLEMENT_ASN1_TYPE_ex(stname, stname, 0) 773 # define IMPLEMENT_ASN1_TYPE_ex(itname, vname, ex) \ 774 ASN1_ITEM_start(itname) \ 775 ASN1_ITYPE_PRIMITIVE, V_##vname, NULL, 0, NULL, ex, #itname \ 776 ASN1_ITEM_end(itname) 777 778 /* Macro to implement a multi string type */ 779 # define IMPLEMENT_ASN1_MSTRING(itname, mask) \ 780 ASN1_ITEM_start(itname) \ 781 ASN1_ITYPE_MSTRING, mask, NULL, 0, NULL, sizeof(ASN1_STRING), #itname \ 782 ASN1_ITEM_end(itname) 783 784 # define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs) \ 785 ASN1_ITEM_start(sname) \ 786 ASN1_ITYPE_EXTERN, \ 787 tag, \ 788 NULL, \ 789 0, \ 790 &fptrs, \ 791 0, \ 792 #sname \ 793 ASN1_ITEM_end(sname) 794 795 /* Macro to implement standard functions in terms of ASN1_ITEM structures */ 796 797 # define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname) 798 799 # define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname) 800 801 # define IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name(stname, itname) \ 802 IMPLEMENT_ASN1_FUNCTIONS_ENCODE_fname(stname, itname, itname) 803 804 # define IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(stname) \ 805 IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(static, stname, stname, stname) 806 807 # define IMPLEMENT_ASN1_ALLOC_FUNCTIONS(stname) \ 808 IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, stname, stname) 809 810 # define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(pre, stname, itname, fname) \ 811 pre stname *fname##_new(void) \ 812 { \ 813 return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \ 814 } \ 815 pre void fname##_free(stname *a) \ 816 { \ 817 ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \ 818 } 819 820 # define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \ 821 stname *fname##_new(void) \ 822 { \ 823 return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \ 824 } \ 825 void fname##_free(stname *a) \ 826 { \ 827 ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \ 828 } 829 830 # define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname) \ 831 IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \ 832 IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) 833 834 # define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \ 835 stname *d2i_##fname(stname **a, const unsigned char **in, long len) \ 836 { \ 837 return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\ 838 } \ 839 int i2d_##fname(stname *a, unsigned char **out) \ 840 { \ 841 return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\ 842 } 843 844 # define IMPLEMENT_ASN1_NDEF_FUNCTION(stname) \ 845 int i2d_##stname##_NDEF(stname *a, unsigned char **out) \ 846 { \ 847 return ASN1_item_ndef_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(stname));\ 848 } 849 850 # define IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(stname) \ 851 static stname *d2i_##stname(stname **a, \ 852 const unsigned char **in, long len) \ 853 { \ 854 return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, \ 855 ASN1_ITEM_rptr(stname)); \ 856 } \ 857 static int i2d_##stname(stname *a, unsigned char **out) \ 858 { \ 859 return ASN1_item_i2d((ASN1_VALUE *)a, out, \ 860 ASN1_ITEM_rptr(stname)); \ 861 } 862 863 /* 864 * This includes evil casts to remove const: they will go away when full ASN1 865 * constification is done. 866 */ 867 # define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \ 868 stname *d2i_##fname(stname **a, const unsigned char **in, long len) \ 869 { \ 870 return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\ 871 } \ 872 int i2d_##fname(const stname *a, unsigned char **out) \ 873 { \ 874 return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\ 875 } 876 877 # define IMPLEMENT_ASN1_DUP_FUNCTION(stname) \ 878 stname * stname##_dup(stname *x) \ 879 { \ 880 return ASN1_item_dup(ASN1_ITEM_rptr(stname), x); \ 881 } 882 883 # define IMPLEMENT_ASN1_PRINT_FUNCTION(stname) \ 884 IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, stname, stname) 885 886 # define IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, itname, fname) \ 887 int fname##_print_ctx(BIO *out, stname *x, int indent, \ 888 const ASN1_PCTX *pctx) \ 889 { \ 890 return ASN1_item_print(out, (ASN1_VALUE *)x, indent, \ 891 ASN1_ITEM_rptr(itname), pctx); \ 892 } 893 894 # define IMPLEMENT_ASN1_FUNCTIONS_const(name) \ 895 IMPLEMENT_ASN1_FUNCTIONS_const_fname(name, name, name) 896 897 # define IMPLEMENT_ASN1_FUNCTIONS_const_fname(stname, itname, fname) \ 898 IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \ 899 IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) 900 901 /* external definitions for primitive types */ 902 903 DECLARE_ASN1_ITEM(ASN1_BOOLEAN) 904 DECLARE_ASN1_ITEM(ASN1_TBOOLEAN) 905 DECLARE_ASN1_ITEM(ASN1_FBOOLEAN) 906 DECLARE_ASN1_ITEM(ASN1_SEQUENCE) 907 DECLARE_ASN1_ITEM(CBIGNUM) 908 DECLARE_ASN1_ITEM(BIGNUM) 909 DECLARE_ASN1_ITEM(INT32) 910 DECLARE_ASN1_ITEM(ZINT32) 911 DECLARE_ASN1_ITEM(UINT32) 912 DECLARE_ASN1_ITEM(ZUINT32) 913 DECLARE_ASN1_ITEM(INT64) 914 DECLARE_ASN1_ITEM(ZINT64) 915 DECLARE_ASN1_ITEM(UINT64) 916 DECLARE_ASN1_ITEM(ZUINT64) 917 918 # if OPENSSL_API_COMPAT < 0x10200000L 919 /* 920 * LONG and ZLONG are strongly discouraged for use as stored data, as the 921 * underlying C type (long) differs in size depending on the architecture. 922 * They are designed with 32-bit longs in mind. 923 */ 924 DECLARE_ASN1_ITEM(LONG) 925 DECLARE_ASN1_ITEM(ZLONG) 926 # endif 927 928 DEFINE_STACK_OF(ASN1_VALUE) 929 930 /* Functions used internally by the ASN1 code */ 931 932 int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it); 933 void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it); 934 935 int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, 936 const ASN1_ITEM *it, int tag, int aclass, char opt, 937 ASN1_TLC *ctx); 938 939 int ASN1_item_ex_i2d(ASN1_VALUE **pval, unsigned char **out, 940 const ASN1_ITEM *it, int tag, int aclass); 941 942 #ifdef __cplusplus 943 } 944 #endif 945 #endif 946
Indexes created Sat Feb 28 05:31:39 UTC 2026