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