1 /* 2 * Copyright 1995-2017 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_ASN1_H 11 # define HEADER_ASN1_H 12 13 # include <time.h> 14 # include <openssl/e_os2.h> 15 # include <openssl/opensslconf.h> 16 # include <openssl/bio.h> 17 # include <openssl/safestack.h> 18 # include <openssl/asn1err.h> 19 # include <openssl/symhacks.h> 20 21 # include <openssl/ossl_typ.h> 22 # if OPENSSL_API_COMPAT < 0x10100000L 23 # include <openssl/bn.h> 24 # endif 25 26 # ifdef OPENSSL_BUILD_SHLIBCRYPTO 27 # undef OPENSSL_EXTERN 28 # define OPENSSL_EXTERN OPENSSL_EXPORT 29 # endif 30 31 #ifdef __cplusplus 32 extern "C" { 33 #endif 34 35 # define V_ASN1_UNIVERSAL 0x00 36 # define V_ASN1_APPLICATION 0x40 37 # define V_ASN1_CONTEXT_SPECIFIC 0x80 38 # define V_ASN1_PRIVATE 0xc0 39 40 # define V_ASN1_CONSTRUCTED 0x20 41 # define V_ASN1_PRIMITIVE_TAG 0x1f 42 # define V_ASN1_PRIMATIVE_TAG /*compat*/ V_ASN1_PRIMITIVE_TAG 43 44 # define V_ASN1_APP_CHOOSE -2/* let the recipient choose */ 45 # define V_ASN1_OTHER -3/* used in ASN1_TYPE */ 46 # define V_ASN1_ANY -4/* used in ASN1 template code */ 47 48 # define V_ASN1_UNDEF -1 49 /* ASN.1 tag values */ 50 # define V_ASN1_EOC 0 51 # define V_ASN1_BOOLEAN 1 /**/ 52 # define V_ASN1_INTEGER 2 53 # define V_ASN1_BIT_STRING 3 54 # define V_ASN1_OCTET_STRING 4 55 # define V_ASN1_NULL 5 56 # define V_ASN1_OBJECT 6 57 # define V_ASN1_OBJECT_DESCRIPTOR 7 58 # define V_ASN1_EXTERNAL 8 59 # define V_ASN1_REAL 9 60 # define V_ASN1_ENUMERATED 10 61 # define V_ASN1_UTF8STRING 12 62 # define V_ASN1_SEQUENCE 16 63 # define V_ASN1_SET 17 64 # define V_ASN1_NUMERICSTRING 18 /**/ 65 # define V_ASN1_PRINTABLESTRING 19 66 # define V_ASN1_T61STRING 20 67 # define V_ASN1_TELETEXSTRING 20/* alias */ 68 # define V_ASN1_VIDEOTEXSTRING 21 /**/ 69 # define V_ASN1_IA5STRING 22 70 # define V_ASN1_UTCTIME 23 71 # define V_ASN1_GENERALIZEDTIME 24 /**/ 72 # define V_ASN1_GRAPHICSTRING 25 /**/ 73 # define V_ASN1_ISO64STRING 26 /**/ 74 # define V_ASN1_VISIBLESTRING 26/* alias */ 75 # define V_ASN1_GENERALSTRING 27 /**/ 76 # define V_ASN1_UNIVERSALSTRING 28 /**/ 77 # define V_ASN1_BMPSTRING 30 78 79 /* 80 * NB the constants below are used internally by ASN1_INTEGER 81 * and ASN1_ENUMERATED to indicate the sign. They are *not* on 82 * the wire tag values. 83 */ 84 85 # define V_ASN1_NEG 0x100 86 # define V_ASN1_NEG_INTEGER (2 | V_ASN1_NEG) 87 # define V_ASN1_NEG_ENUMERATED (10 | V_ASN1_NEG) 88 89 /* For use with d2i_ASN1_type_bytes() */ 90 # define B_ASN1_NUMERICSTRING 0x0001 91 # define B_ASN1_PRINTABLESTRING 0x0002 92 # define B_ASN1_T61STRING 0x0004 93 # define B_ASN1_TELETEXSTRING 0x0004 94 # define B_ASN1_VIDEOTEXSTRING 0x0008 95 # define B_ASN1_IA5STRING 0x0010 96 # define B_ASN1_GRAPHICSTRING 0x0020 97 # define B_ASN1_ISO64STRING 0x0040 98 # define B_ASN1_VISIBLESTRING 0x0040 99 # define B_ASN1_GENERALSTRING 0x0080 100 # define B_ASN1_UNIVERSALSTRING 0x0100 101 # define B_ASN1_OCTET_STRING 0x0200 102 # define B_ASN1_BIT_STRING 0x0400 103 # define B_ASN1_BMPSTRING 0x0800 104 # define B_ASN1_UNKNOWN 0x1000 105 # define B_ASN1_UTF8STRING 0x2000 106 # define B_ASN1_UTCTIME 0x4000 107 # define B_ASN1_GENERALIZEDTIME 0x8000 108 # define B_ASN1_SEQUENCE 0x10000 109 /* For use with ASN1_mbstring_copy() */ 110 # define MBSTRING_FLAG 0x1000 111 # define MBSTRING_UTF8 (MBSTRING_FLAG) 112 # define MBSTRING_ASC (MBSTRING_FLAG|1) 113 # define MBSTRING_BMP (MBSTRING_FLAG|2) 114 # define MBSTRING_UNIV (MBSTRING_FLAG|4) 115 # define SMIME_OLDMIME 0x400 116 # define SMIME_CRLFEOL 0x800 117 # define SMIME_STREAM 0x1000 118 struct X509_algor_st; 119 DEFINE_STACK_OF(X509_ALGOR) 120 121 # define ASN1_STRING_FLAG_BITS_LEFT 0x08/* Set if 0x07 has bits left value */ 122 /* 123 * This indicates that the ASN1_STRING is not a real value but just a place 124 * holder for the location where indefinite length constructed data should be 125 * inserted in the memory buffer 126 */ 127 # define ASN1_STRING_FLAG_NDEF 0x010 128 129 /* 130 * This flag is used by the CMS code to indicate that a string is not 131 * complete and is a place holder for content when it had all been accessed. 132 * The flag will be reset when content has been written to it. 133 */ 134 135 # define ASN1_STRING_FLAG_CONT 0x020 136 /* 137 * This flag is used by ASN1 code to indicate an ASN1_STRING is an MSTRING 138 * type. 139 */ 140 # define ASN1_STRING_FLAG_MSTRING 0x040 141 /* String is embedded and only content should be freed */ 142 # define ASN1_STRING_FLAG_EMBED 0x080 143 /* String should be parsed in RFC 5280's time format */ 144 # define ASN1_STRING_FLAG_X509_TIME 0x100 145 /* This is the base type that holds just about everything :-) */ 146 struct asn1_string_st { 147 int length; 148 int type; 149 unsigned char *data; 150 /* 151 * The value of the following field depends on the type being held. It 152 * is mostly being used for BIT_STRING so if the input data has a 153 * non-zero 'unused bits' value, it will be handled correctly 154 */ 155 long flags; 156 }; 157 158 /* 159 * ASN1_ENCODING structure: this is used to save the received encoding of an 160 * ASN1 type. This is useful to get round problems with invalid encodings 161 * which can break signatures. 162 */ 163 164 typedef struct ASN1_ENCODING_st { 165 unsigned char *enc; /* DER encoding */ 166 long len; /* Length of encoding */ 167 int modified; /* set to 1 if 'enc' is invalid */ 168 } ASN1_ENCODING; 169 170 /* Used with ASN1 LONG type: if a long is set to this it is omitted */ 171 # define ASN1_LONG_UNDEF 0x7fffffffL 172 173 # define STABLE_FLAGS_MALLOC 0x01 174 /* 175 * A zero passed to ASN1_STRING_TABLE_new_add for the flags is interpreted 176 * as "don't change" and STABLE_FLAGS_MALLOC is always set. By setting 177 * STABLE_FLAGS_MALLOC only we can clear the existing value. Use the alias 178 * STABLE_FLAGS_CLEAR to reflect this. 179 */ 180 # define STABLE_FLAGS_CLEAR STABLE_FLAGS_MALLOC 181 # define STABLE_NO_MASK 0x02 182 # define DIRSTRING_TYPE \ 183 (B_ASN1_PRINTABLESTRING|B_ASN1_T61STRING|B_ASN1_BMPSTRING|B_ASN1_UTF8STRING) 184 # define PKCS9STRING_TYPE (DIRSTRING_TYPE|B_ASN1_IA5STRING) 185 186 typedef struct asn1_string_table_st { 187 int nid; 188 long minsize; 189 long maxsize; 190 unsigned long mask; 191 unsigned long flags; 192 } ASN1_STRING_TABLE; 193 194 DEFINE_STACK_OF(ASN1_STRING_TABLE) 195 196 /* size limits: this stuff is taken straight from RFC2459 */ 197 198 # define ub_name 32768 199 # define ub_common_name 64 200 # define ub_locality_name 128 201 # define ub_state_name 128 202 # define ub_organization_name 64 203 # define ub_organization_unit_name 64 204 # define ub_title 64 205 # define ub_email_address 128 206 207 /* 208 * Declarations for template structures: for full definitions see asn1t.h 209 */ 210 typedef struct ASN1_TEMPLATE_st ASN1_TEMPLATE; 211 typedef struct ASN1_TLC_st ASN1_TLC; 212 /* This is just an opaque pointer */ 213 typedef struct ASN1_VALUE_st ASN1_VALUE; 214 215 /* Declare ASN1 functions: the implement macro in in asn1t.h */ 216 217 # define DECLARE_ASN1_FUNCTIONS(type) DECLARE_ASN1_FUNCTIONS_name(type, type) 218 219 # define DECLARE_ASN1_ALLOC_FUNCTIONS(type) \ 220 DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, type) 221 222 # define DECLARE_ASN1_FUNCTIONS_name(type, name) \ 223 DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \ 224 DECLARE_ASN1_ENCODE_FUNCTIONS(type, name, name) 225 226 # define DECLARE_ASN1_FUNCTIONS_fname(type, itname, name) \ 227 DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \ 228 DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name) 229 230 # define DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name) \ 231 type *d2i_##name(type **a, const unsigned char **in, long len); \ 232 int i2d_##name(type *a, unsigned char **out); \ 233 DECLARE_ASN1_ITEM(itname) 234 235 # define DECLARE_ASN1_ENCODE_FUNCTIONS_const(type, name) \ 236 type *d2i_##name(type **a, const unsigned char **in, long len); \ 237 int i2d_##name(const type *a, unsigned char **out); \ 238 DECLARE_ASN1_ITEM(name) 239 240 # define DECLARE_ASN1_NDEF_FUNCTION(name) \ 241 int i2d_##name##_NDEF(name *a, unsigned char **out); 242 243 # define DECLARE_ASN1_FUNCTIONS_const(name) \ 244 DECLARE_ASN1_ALLOC_FUNCTIONS(name) \ 245 DECLARE_ASN1_ENCODE_FUNCTIONS_const(name, name) 246 247 # define DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \ 248 type *name##_new(void); \ 249 void name##_free(type *a); 250 251 # define DECLARE_ASN1_PRINT_FUNCTION(stname) \ 252 DECLARE_ASN1_PRINT_FUNCTION_fname(stname, stname) 253 254 # define DECLARE_ASN1_PRINT_FUNCTION_fname(stname, fname) \ 255 int fname##_print_ctx(BIO *out, stname *x, int indent, \ 256 const ASN1_PCTX *pctx); 257 258 # define D2I_OF(type) type *(*)(type **,const unsigned char **,long) 259 # define I2D_OF(type) int (*)(type *,unsigned char **) 260 # define I2D_OF_const(type) int (*)(const type *,unsigned char **) 261 262 # define CHECKED_D2I_OF(type, d2i) \ 263 ((d2i_of_void*) (1 ? d2i : ((D2I_OF(type))0))) 264 # define CHECKED_I2D_OF(type, i2d) \ 265 ((i2d_of_void*) (1 ? i2d : ((I2D_OF(type))0))) 266 # define CHECKED_NEW_OF(type, xnew) \ 267 ((void *(*)(void)) (1 ? xnew : ((type *(*)(void))0))) 268 # define CHECKED_PTR_OF(type, p) \ 269 ((void*) (1 ? p : (type*)0)) 270 # define CHECKED_PPTR_OF(type, p) \ 271 ((void**) (1 ? p : (type**)0)) 272 273 # define TYPEDEF_D2I_OF(type) typedef type *d2i_of_##type(type **,const unsigned char **,long) 274 # define TYPEDEF_I2D_OF(type) typedef int i2d_of_##type(type *,unsigned char **) 275 # define TYPEDEF_D2I2D_OF(type) TYPEDEF_D2I_OF(type); TYPEDEF_I2D_OF(type) 276 277 TYPEDEF_D2I2D_OF(void); 278 279 /*- 280 * The following macros and typedefs allow an ASN1_ITEM 281 * to be embedded in a structure and referenced. Since 282 * the ASN1_ITEM pointers need to be globally accessible 283 * (possibly from shared libraries) they may exist in 284 * different forms. On platforms that support it the 285 * ASN1_ITEM structure itself will be globally exported. 286 * Other platforms will export a function that returns 287 * an ASN1_ITEM pointer. 288 * 289 * To handle both cases transparently the macros below 290 * should be used instead of hard coding an ASN1_ITEM 291 * pointer in a structure. 292 * 293 * The structure will look like this: 294 * 295 * typedef struct SOMETHING_st { 296 * ... 297 * ASN1_ITEM_EXP *iptr; 298 * ... 299 * } SOMETHING; 300 * 301 * It would be initialised as e.g.: 302 * 303 * SOMETHING somevar = {...,ASN1_ITEM_ref(X509),...}; 304 * 305 * and the actual pointer extracted with: 306 * 307 * const ASN1_ITEM *it = ASN1_ITEM_ptr(somevar.iptr); 308 * 309 * Finally an ASN1_ITEM pointer can be extracted from an 310 * appropriate reference with: ASN1_ITEM_rptr(X509). This 311 * would be used when a function takes an ASN1_ITEM * argument. 312 * 313 */ 314 315 # ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION 316 317 /* ASN1_ITEM pointer exported type */ 318 typedef const ASN1_ITEM ASN1_ITEM_EXP; 319 320 /* Macro to obtain ASN1_ITEM pointer from exported type */ 321 # define ASN1_ITEM_ptr(iptr) (iptr) 322 323 /* Macro to include ASN1_ITEM pointer from base type */ 324 # define ASN1_ITEM_ref(iptr) (&(iptr##_it)) 325 326 # define ASN1_ITEM_rptr(ref) (&(ref##_it)) 327 328 # define DECLARE_ASN1_ITEM(name) \ 329 OPENSSL_EXTERN const ASN1_ITEM name##_it; 330 331 # else 332 333 /* 334 * Platforms that can't easily handle shared global variables are declared as 335 * functions returning ASN1_ITEM pointers. 336 */ 337 338 /* ASN1_ITEM pointer exported type */ 339 typedef const ASN1_ITEM *ASN1_ITEM_EXP (void); 340 341 /* Macro to obtain ASN1_ITEM pointer from exported type */ 342 # define ASN1_ITEM_ptr(iptr) (iptr()) 343 344 /* Macro to include ASN1_ITEM pointer from base type */ 345 # define ASN1_ITEM_ref(iptr) (iptr##_it) 346 347 # define ASN1_ITEM_rptr(ref) (ref##_it()) 348 349 # define DECLARE_ASN1_ITEM(name) \ 350 const ASN1_ITEM * name##_it(void); 351 352 # endif 353 354 /* Parameters used by ASN1_STRING_print_ex() */ 355 356 /* 357 * These determine which characters to escape: RFC2253 special characters, 358 * control characters and MSB set characters 359 */ 360 361 # define ASN1_STRFLGS_ESC_2253 1 362 # define ASN1_STRFLGS_ESC_CTRL 2 363 # define ASN1_STRFLGS_ESC_MSB 4 364 365 /* 366 * This flag determines how we do escaping: normally RC2253 backslash only, 367 * set this to use backslash and quote. 368 */ 369 370 # define ASN1_STRFLGS_ESC_QUOTE 8 371 372 /* These three flags are internal use only. */ 373 374 /* Character is a valid PrintableString character */ 375 # define CHARTYPE_PRINTABLESTRING 0x10 376 /* Character needs escaping if it is the first character */ 377 # define CHARTYPE_FIRST_ESC_2253 0x20 378 /* Character needs escaping if it is the last character */ 379 # define CHARTYPE_LAST_ESC_2253 0x40 380 381 /* 382 * NB the internal flags are safely reused below by flags handled at the top 383 * level. 384 */ 385 386 /* 387 * If this is set we convert all character strings to UTF8 first 388 */ 389 390 # define ASN1_STRFLGS_UTF8_CONVERT 0x10 391 392 /* 393 * If this is set we don't attempt to interpret content: just assume all 394 * strings are 1 byte per character. This will produce some pretty odd 395 * looking output! 396 */ 397 398 # define ASN1_STRFLGS_IGNORE_TYPE 0x20 399 400 /* If this is set we include the string type in the output */ 401 # define ASN1_STRFLGS_SHOW_TYPE 0x40 402 403 /* 404 * This determines which strings to display and which to 'dump' (hex dump of 405 * content octets or DER encoding). We can only dump non character strings or 406 * everything. If we don't dump 'unknown' they are interpreted as character 407 * strings with 1 octet per character and are subject to the usual escaping 408 * options. 409 */ 410 411 # define ASN1_STRFLGS_DUMP_ALL 0x80 412 # define ASN1_STRFLGS_DUMP_UNKNOWN 0x100 413 414 /* 415 * These determine what 'dumping' does, we can dump the content octets or the 416 * DER encoding: both use the RFC2253 #XXXXX notation. 417 */ 418 419 # define ASN1_STRFLGS_DUMP_DER 0x200 420 421 /* 422 * This flag specifies that RC2254 escaping shall be performed. 423 */ 424 #define ASN1_STRFLGS_ESC_2254 0x400 425 426 /* 427 * All the string flags consistent with RFC2253, escaping control characters 428 * isn't essential in RFC2253 but it is advisable anyway. 429 */ 430 431 # define ASN1_STRFLGS_RFC2253 (ASN1_STRFLGS_ESC_2253 | \ 432 ASN1_STRFLGS_ESC_CTRL | \ 433 ASN1_STRFLGS_ESC_MSB | \ 434 ASN1_STRFLGS_UTF8_CONVERT | \ 435 ASN1_STRFLGS_DUMP_UNKNOWN | \ 436 ASN1_STRFLGS_DUMP_DER) 437 438 DEFINE_STACK_OF(ASN1_INTEGER) 439 440 DEFINE_STACK_OF(ASN1_GENERALSTRING) 441 442 DEFINE_STACK_OF(ASN1_UTF8STRING) 443 444 typedef struct asn1_type_st { 445 int type; 446 union { 447 char *ptr; 448 ASN1_BOOLEAN boolean; 449 ASN1_STRING *asn1_string; 450 ASN1_OBJECT *object; 451 ASN1_INTEGER *integer; 452 ASN1_ENUMERATED *enumerated; 453 ASN1_BIT_STRING *bit_string; 454 ASN1_OCTET_STRING *octet_string; 455 ASN1_PRINTABLESTRING *printablestring; 456 ASN1_T61STRING *t61string; 457 ASN1_IA5STRING *ia5string; 458 ASN1_GENERALSTRING *generalstring; 459 ASN1_BMPSTRING *bmpstring; 460 ASN1_UNIVERSALSTRING *universalstring; 461 ASN1_UTCTIME *utctime; 462 ASN1_GENERALIZEDTIME *generalizedtime; 463 ASN1_VISIBLESTRING *visiblestring; 464 ASN1_UTF8STRING *utf8string; 465 /* 466 * set and sequence are left complete and still contain the set or 467 * sequence bytes 468 */ 469 ASN1_STRING *set; 470 ASN1_STRING *sequence; 471 ASN1_VALUE *asn1_value; 472 } value; 473 } ASN1_TYPE; 474 475 DEFINE_STACK_OF(ASN1_TYPE) 476 477 typedef STACK_OF(ASN1_TYPE) ASN1_SEQUENCE_ANY; 478 479 DECLARE_ASN1_ENCODE_FUNCTIONS_const(ASN1_SEQUENCE_ANY, ASN1_SEQUENCE_ANY) 480 DECLARE_ASN1_ENCODE_FUNCTIONS_const(ASN1_SEQUENCE_ANY, ASN1_SET_ANY) 481 482 /* This is used to contain a list of bit names */ 483 typedef struct BIT_STRING_BITNAME_st { 484 int bitnum; 485 const char *lname; 486 const char *sname; 487 } BIT_STRING_BITNAME; 488 489 # define B_ASN1_TIME \ 490 B_ASN1_UTCTIME | \ 491 B_ASN1_GENERALIZEDTIME 492 493 # define B_ASN1_PRINTABLE \ 494 B_ASN1_NUMERICSTRING| \ 495 B_ASN1_PRINTABLESTRING| \ 496 B_ASN1_T61STRING| \ 497 B_ASN1_IA5STRING| \ 498 B_ASN1_BIT_STRING| \ 499 B_ASN1_UNIVERSALSTRING|\ 500 B_ASN1_BMPSTRING|\ 501 B_ASN1_UTF8STRING|\ 502 B_ASN1_SEQUENCE|\ 503 B_ASN1_UNKNOWN 504 505 # define B_ASN1_DIRECTORYSTRING \ 506 B_ASN1_PRINTABLESTRING| \ 507 B_ASN1_TELETEXSTRING|\ 508 B_ASN1_BMPSTRING|\ 509 B_ASN1_UNIVERSALSTRING|\ 510 B_ASN1_UTF8STRING 511 512 # define B_ASN1_DISPLAYTEXT \ 513 B_ASN1_IA5STRING| \ 514 B_ASN1_VISIBLESTRING| \ 515 B_ASN1_BMPSTRING|\ 516 B_ASN1_UTF8STRING 517 518 DECLARE_ASN1_FUNCTIONS_fname(ASN1_TYPE, ASN1_ANY, ASN1_TYPE) 519 520 int ASN1_TYPE_get(const ASN1_TYPE *a); 521 void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value); 522 int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value); 523 int ASN1_TYPE_cmp(const ASN1_TYPE *a, const ASN1_TYPE *b); 524 525 ASN1_TYPE *ASN1_TYPE_pack_sequence(const ASN1_ITEM *it, void *s, ASN1_TYPE **t); 526 void *ASN1_TYPE_unpack_sequence(const ASN1_ITEM *it, const ASN1_TYPE *t); 527 528 ASN1_OBJECT *ASN1_OBJECT_new(void); 529 void ASN1_OBJECT_free(ASN1_OBJECT *a); 530 int i2d_ASN1_OBJECT(const ASN1_OBJECT *a, unsigned char **pp); 531 ASN1_OBJECT *d2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp, 532 long length); 533 534 DECLARE_ASN1_ITEM(ASN1_OBJECT) 535 536 DEFINE_STACK_OF(ASN1_OBJECT) 537 538 ASN1_STRING *ASN1_STRING_new(void); 539 void ASN1_STRING_free(ASN1_STRING *a); 540 void ASN1_STRING_clear_free(ASN1_STRING *a); 541 int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str); 542 ASN1_STRING *ASN1_STRING_dup(const ASN1_STRING *a); 543 ASN1_STRING *ASN1_STRING_type_new(int type); 544 int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b); 545 /* 546 * Since this is used to store all sorts of things, via macros, for now, 547 * make its data void * 548 */ 549 int ASN1_STRING_set(ASN1_STRING *str, const void *data, int len); 550 void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len); 551 int ASN1_STRING_length(const ASN1_STRING *x); 552 void ASN1_STRING_length_set(ASN1_STRING *x, int n); 553 int ASN1_STRING_type(const ASN1_STRING *x); 554 DEPRECATEDIN_1_1_0(unsigned char *ASN1_STRING_data(ASN1_STRING *x)) 555 const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *x); 556 557 DECLARE_ASN1_FUNCTIONS(ASN1_BIT_STRING) 558 int ASN1_BIT_STRING_set(ASN1_BIT_STRING *a, unsigned char *d, int length); 559 int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value); 560 int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n); 561 int ASN1_BIT_STRING_check(const ASN1_BIT_STRING *a, 562 const unsigned char *flags, int flags_len); 563 564 int ASN1_BIT_STRING_name_print(BIO *out, ASN1_BIT_STRING *bs, 565 BIT_STRING_BITNAME *tbl, int indent); 566 int ASN1_BIT_STRING_num_asc(const char *name, BIT_STRING_BITNAME *tbl); 567 int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, const char *name, int value, 568 BIT_STRING_BITNAME *tbl); 569 570 DECLARE_ASN1_FUNCTIONS(ASN1_INTEGER) 571 ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp, 572 long length); 573 ASN1_INTEGER *ASN1_INTEGER_dup(const ASN1_INTEGER *x); 574 int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y); 575 576 DECLARE_ASN1_FUNCTIONS(ASN1_ENUMERATED) 577 578 int ASN1_UTCTIME_check(const ASN1_UTCTIME *a); 579 ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t); 580 ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t, 581 int offset_day, long offset_sec); 582 int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str); 583 int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t); 584 585 int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *a); 586 ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s, 587 time_t t); 588 ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s, 589 time_t t, int offset_day, 590 long offset_sec); 591 int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str); 592 593 int ASN1_TIME_diff(int *pday, int *psec, 594 const ASN1_TIME *from, const ASN1_TIME *to); 595 596 DECLARE_ASN1_FUNCTIONS(ASN1_OCTET_STRING) 597 ASN1_OCTET_STRING *ASN1_OCTET_STRING_dup(const ASN1_OCTET_STRING *a); 598 int ASN1_OCTET_STRING_cmp(const ASN1_OCTET_STRING *a, 599 const ASN1_OCTET_STRING *b); 600 int ASN1_OCTET_STRING_set(ASN1_OCTET_STRING *str, const unsigned char *data, 601 int len); 602 603 DECLARE_ASN1_FUNCTIONS(ASN1_VISIBLESTRING) 604 DECLARE_ASN1_FUNCTIONS(ASN1_UNIVERSALSTRING) 605 DECLARE_ASN1_FUNCTIONS(ASN1_UTF8STRING) 606 DECLARE_ASN1_FUNCTIONS(ASN1_NULL) 607 DECLARE_ASN1_FUNCTIONS(ASN1_BMPSTRING) 608 609 int UTF8_getc(const unsigned char *str, int len, unsigned long *val); 610 int UTF8_putc(unsigned char *str, int len, unsigned long value); 611 612 DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, ASN1_PRINTABLE) 613 614 DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DIRECTORYSTRING) 615 DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DISPLAYTEXT) 616 DECLARE_ASN1_FUNCTIONS(ASN1_PRINTABLESTRING) 617 DECLARE_ASN1_FUNCTIONS(ASN1_T61STRING) 618 DECLARE_ASN1_FUNCTIONS(ASN1_IA5STRING) 619 DECLARE_ASN1_FUNCTIONS(ASN1_GENERALSTRING) 620 DECLARE_ASN1_FUNCTIONS(ASN1_UTCTIME) 621 DECLARE_ASN1_FUNCTIONS(ASN1_GENERALIZEDTIME) 622 DECLARE_ASN1_FUNCTIONS(ASN1_TIME) 623 624 DECLARE_ASN1_ITEM(ASN1_OCTET_STRING_NDEF) 625 626 ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s, time_t t); 627 ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s, time_t t, 628 int offset_day, long offset_sec); 629 int ASN1_TIME_check(const ASN1_TIME *t); 630 ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(const ASN1_TIME *t, 631 ASN1_GENERALIZEDTIME **out); 632 int ASN1_TIME_set_string(ASN1_TIME *s, const char *str); 633 int ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str); 634 int ASN1_TIME_to_tm(const ASN1_TIME *s, struct tm *tm); 635 int ASN1_TIME_normalize(ASN1_TIME *s); 636 int ASN1_TIME_cmp_time_t(const ASN1_TIME *s, time_t t); 637 int ASN1_TIME_compare(const ASN1_TIME *a, const ASN1_TIME *b); 638 639 int i2a_ASN1_INTEGER(BIO *bp, const ASN1_INTEGER *a); 640 int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size); 641 int i2a_ASN1_ENUMERATED(BIO *bp, const ASN1_ENUMERATED *a); 642 int a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size); 643 int i2a_ASN1_OBJECT(BIO *bp, const ASN1_OBJECT *a); 644 int a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size); 645 int i2a_ASN1_STRING(BIO *bp, const ASN1_STRING *a, int type); 646 int i2t_ASN1_OBJECT(char *buf, int buf_len, const ASN1_OBJECT *a); 647 648 int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num); 649 ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len, 650 const char *sn, const char *ln); 651 652 int ASN1_INTEGER_get_int64(int64_t *pr, const ASN1_INTEGER *a); 653 int ASN1_INTEGER_set_int64(ASN1_INTEGER *a, int64_t r); 654 int ASN1_INTEGER_get_uint64(uint64_t *pr, const ASN1_INTEGER *a); 655 int ASN1_INTEGER_set_uint64(ASN1_INTEGER *a, uint64_t r); 656 657 int ASN1_INTEGER_set(ASN1_INTEGER *a, long v); 658 long ASN1_INTEGER_get(const ASN1_INTEGER *a); 659 ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai); 660 BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn); 661 662 int ASN1_ENUMERATED_get_int64(int64_t *pr, const ASN1_ENUMERATED *a); 663 int ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED *a, int64_t r); 664 665 666 int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v); 667 long ASN1_ENUMERATED_get(const ASN1_ENUMERATED *a); 668 ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(const BIGNUM *bn, ASN1_ENUMERATED *ai); 669 BIGNUM *ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED *ai, BIGNUM *bn); 670 671 /* General */ 672 /* given a string, return the correct type, max is the maximum length */ 673 int ASN1_PRINTABLE_type(const unsigned char *s, int max); 674 675 unsigned long ASN1_tag2bit(int tag); 676 677 /* SPECIALS */ 678 int ASN1_get_object(const unsigned char **pp, long *plength, int *ptag, 679 int *pclass, long omax); 680 int ASN1_check_infinite_end(unsigned char **p, long len); 681 int ASN1_const_check_infinite_end(const unsigned char **p, long len); 682 void ASN1_put_object(unsigned char **pp, int constructed, int length, 683 int tag, int xclass); 684 int ASN1_put_eoc(unsigned char **pp); 685 int ASN1_object_size(int constructed, int length, int tag); 686 687 /* Used to implement other functions */ 688 void *ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, void *x); 689 690 # define ASN1_dup_of(type,i2d,d2i,x) \ 691 ((type*)ASN1_dup(CHECKED_I2D_OF(type, i2d), \ 692 CHECKED_D2I_OF(type, d2i), \ 693 CHECKED_PTR_OF(type, x))) 694 695 # define ASN1_dup_of_const(type,i2d,d2i,x) \ 696 ((type*)ASN1_dup(CHECKED_I2D_OF(const type, i2d), \ 697 CHECKED_D2I_OF(type, d2i), \ 698 CHECKED_PTR_OF(const type, x))) 699 700 void *ASN1_item_dup(const ASN1_ITEM *it, void *x); 701 702 /* ASN1 alloc/free macros for when a type is only used internally */ 703 704 # define M_ASN1_new_of(type) (type *)ASN1_item_new(ASN1_ITEM_rptr(type)) 705 # define M_ASN1_free_of(x, type) \ 706 ASN1_item_free(CHECKED_PTR_OF(type, x), ASN1_ITEM_rptr(type)) 707 708 # ifndef OPENSSL_NO_STDIO 709 void *ASN1_d2i_fp(void *(*xnew) (void), d2i_of_void *d2i, FILE *in, void **x); 710 711 # define ASN1_d2i_fp_of(type,xnew,d2i,in,x) \ 712 ((type*)ASN1_d2i_fp(CHECKED_NEW_OF(type, xnew), \ 713 CHECKED_D2I_OF(type, d2i), \ 714 in, \ 715 CHECKED_PPTR_OF(type, x))) 716 717 void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x); 718 int ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, void *x); 719 720 # define ASN1_i2d_fp_of(type,i2d,out,x) \ 721 (ASN1_i2d_fp(CHECKED_I2D_OF(type, i2d), \ 722 out, \ 723 CHECKED_PTR_OF(type, x))) 724 725 # define ASN1_i2d_fp_of_const(type,i2d,out,x) \ 726 (ASN1_i2d_fp(CHECKED_I2D_OF(const type, i2d), \ 727 out, \ 728 CHECKED_PTR_OF(const type, x))) 729 730 int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x); 731 int ASN1_STRING_print_ex_fp(FILE *fp, const ASN1_STRING *str, unsigned long flags); 732 # endif 733 734 int ASN1_STRING_to_UTF8(unsigned char **out, const ASN1_STRING *in); 735 736 void *ASN1_d2i_bio(void *(*xnew) (void), d2i_of_void *d2i, BIO *in, void **x); 737 738 # define ASN1_d2i_bio_of(type,xnew,d2i,in,x) \ 739 ((type*)ASN1_d2i_bio( CHECKED_NEW_OF(type, xnew), \ 740 CHECKED_D2I_OF(type, d2i), \ 741 in, \ 742 CHECKED_PPTR_OF(type, x))) 743 744 void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x); 745 int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, unsigned char *x); 746 747 # define ASN1_i2d_bio_of(type,i2d,out,x) \ 748 (ASN1_i2d_bio(CHECKED_I2D_OF(type, i2d), \ 749 out, \ 750 CHECKED_PTR_OF(type, x))) 751 752 # define ASN1_i2d_bio_of_const(type,i2d,out,x) \ 753 (ASN1_i2d_bio(CHECKED_I2D_OF(const type, i2d), \ 754 out, \ 755 CHECKED_PTR_OF(const type, x))) 756 757 int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x); 758 int ASN1_UTCTIME_print(BIO *fp, const ASN1_UTCTIME *a); 759 int ASN1_GENERALIZEDTIME_print(BIO *fp, const ASN1_GENERALIZEDTIME *a); 760 int ASN1_TIME_print(BIO *fp, const ASN1_TIME *a); 761 int ASN1_STRING_print(BIO *bp, const ASN1_STRING *v); 762 int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags); 763 int ASN1_buf_print(BIO *bp, const unsigned char *buf, size_t buflen, int off); 764 int ASN1_bn_print(BIO *bp, const char *number, const BIGNUM *num, 765 unsigned char *buf, int off); 766 int ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent); 767 int ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent, 768 int dump); 769 const char *ASN1_tag2str(int tag); 770 771 /* Used to load and write Netscape format cert */ 772 773 int ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s); 774 775 int ASN1_TYPE_set_octetstring(ASN1_TYPE *a, unsigned char *data, int len); 776 int ASN1_TYPE_get_octetstring(const ASN1_TYPE *a, unsigned char *data, int max_len); 777 int ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num, 778 unsigned char *data, int len); 779 int ASN1_TYPE_get_int_octetstring(const ASN1_TYPE *a, long *num, 780 unsigned char *data, int max_len); 781 782 void *ASN1_item_unpack(const ASN1_STRING *oct, const ASN1_ITEM *it); 783 784 ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it, 785 ASN1_OCTET_STRING **oct); 786 787 void ASN1_STRING_set_default_mask(unsigned long mask); 788 int ASN1_STRING_set_default_mask_asc(const char *p); 789 unsigned long ASN1_STRING_get_default_mask(void); 790 int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len, 791 int inform, unsigned long mask); 792 int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len, 793 int inform, unsigned long mask, 794 long minsize, long maxsize); 795 796 ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out, 797 const unsigned char *in, int inlen, 798 int inform, int nid); 799 ASN1_STRING_TABLE *ASN1_STRING_TABLE_get(int nid); 800 int ASN1_STRING_TABLE_add(int, long, long, unsigned long, unsigned long); 801 void ASN1_STRING_TABLE_cleanup(void); 802 803 /* ASN1 template functions */ 804 805 /* Old API compatible functions */ 806 ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it); 807 void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it); 808 ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **val, const unsigned char **in, 809 long len, const ASN1_ITEM *it); 810 int ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it); 811 int ASN1_item_ndef_i2d(ASN1_VALUE *val, unsigned char **out, 812 const ASN1_ITEM *it); 813 814 void ASN1_add_oid_module(void); 815 void ASN1_add_stable_module(void); 816 817 ASN1_TYPE *ASN1_generate_nconf(const char *str, CONF *nconf); 818 ASN1_TYPE *ASN1_generate_v3(const char *str, X509V3_CTX *cnf); 819 int ASN1_str2mask(const char *str, unsigned long *pmask); 820 821 /* ASN1 Print flags */ 822 823 /* Indicate missing OPTIONAL fields */ 824 # define ASN1_PCTX_FLAGS_SHOW_ABSENT 0x001 825 /* Mark start and end of SEQUENCE */ 826 # define ASN1_PCTX_FLAGS_SHOW_SEQUENCE 0x002 827 /* Mark start and end of SEQUENCE/SET OF */ 828 # define ASN1_PCTX_FLAGS_SHOW_SSOF 0x004 829 /* Show the ASN1 type of primitives */ 830 # define ASN1_PCTX_FLAGS_SHOW_TYPE 0x008 831 /* Don't show ASN1 type of ANY */ 832 # define ASN1_PCTX_FLAGS_NO_ANY_TYPE 0x010 833 /* Don't show ASN1 type of MSTRINGs */ 834 # define ASN1_PCTX_FLAGS_NO_MSTRING_TYPE 0x020 835 /* Don't show field names in SEQUENCE */ 836 # define ASN1_PCTX_FLAGS_NO_FIELD_NAME 0x040 837 /* Show structure names of each SEQUENCE field */ 838 # define ASN1_PCTX_FLAGS_SHOW_FIELD_STRUCT_NAME 0x080 839 /* Don't show structure name even at top level */ 840 # define ASN1_PCTX_FLAGS_NO_STRUCT_NAME 0x100 841 842 int ASN1_item_print(BIO *out, ASN1_VALUE *ifld, int indent, 843 const ASN1_ITEM *it, const ASN1_PCTX *pctx); 844 ASN1_PCTX *ASN1_PCTX_new(void); 845 void ASN1_PCTX_free(ASN1_PCTX *p); 846 unsigned long ASN1_PCTX_get_flags(const ASN1_PCTX *p); 847 void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags); 848 unsigned long ASN1_PCTX_get_nm_flags(const ASN1_PCTX *p); 849 void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags); 850 unsigned long ASN1_PCTX_get_cert_flags(const ASN1_PCTX *p); 851 void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags); 852 unsigned long ASN1_PCTX_get_oid_flags(const ASN1_PCTX *p); 853 void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags); 854 unsigned long ASN1_PCTX_get_str_flags(const ASN1_PCTX *p); 855 void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags); 856 857 ASN1_SCTX *ASN1_SCTX_new(int (*scan_cb) (ASN1_SCTX *ctx)); 858 void ASN1_SCTX_free(ASN1_SCTX *p); 859 const ASN1_ITEM *ASN1_SCTX_get_item(ASN1_SCTX *p); 860 const ASN1_TEMPLATE *ASN1_SCTX_get_template(ASN1_SCTX *p); 861 unsigned long ASN1_SCTX_get_flags(ASN1_SCTX *p); 862 void ASN1_SCTX_set_app_data(ASN1_SCTX *p, void *data); 863 void *ASN1_SCTX_get_app_data(ASN1_SCTX *p); 864 865 const BIO_METHOD *BIO_f_asn1(void); 866 867 BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it); 868 869 int i2d_ASN1_bio_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags, 870 const ASN1_ITEM *it); 871 int PEM_write_bio_ASN1_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags, 872 const char *hdr, const ASN1_ITEM *it); 873 int SMIME_write_ASN1(BIO *bio, ASN1_VALUE *val, BIO *data, int flags, 874 int ctype_nid, int econt_nid, 875 STACK_OF(X509_ALGOR) *mdalgs, const ASN1_ITEM *it); 876 ASN1_VALUE *SMIME_read_ASN1(BIO *bio, BIO **bcont, const ASN1_ITEM *it); 877 int SMIME_crlf_copy(BIO *in, BIO *out, int flags); 878 int SMIME_text(BIO *in, BIO *out); 879 880 const ASN1_ITEM *ASN1_ITEM_lookup(const char *name); 881 const ASN1_ITEM *ASN1_ITEM_get(size_t i); 882 883 # ifdef __cplusplus 884 } 885 # endif 886 #endif 887