1 /* 2 * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the Apache License 2.0 (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 #include <stdio.h> 11 #include "crypto/ctype.h" 12 #include "internal/cryptlib.h" 13 #include <openssl/asn1t.h> 14 #include <openssl/x509.h> 15 #include "crypto/x509.h" 16 #include "crypto/asn1.h" 17 #include "x509_local.h" 18 19 /* 20 * Maximum length of X509_NAME: much larger than anything we should 21 * ever see in practice. 22 */ 23 24 #define X509_NAME_MAX (1024 * 1024) 25 26 static int x509_name_ex_d2i(ASN1_VALUE **val, 27 const unsigned char **in, long len, 28 const ASN1_ITEM *it, 29 int tag, int aclass, char opt, ASN1_TLC *ctx); 30 31 static int x509_name_ex_i2d(const ASN1_VALUE **val, unsigned char **out, 32 const ASN1_ITEM *it, int tag, int aclass); 33 static int x509_name_ex_new(ASN1_VALUE **val, const ASN1_ITEM *it); 34 static void x509_name_ex_free(ASN1_VALUE **val, const ASN1_ITEM *it); 35 36 static int x509_name_encode(X509_NAME *a); 37 static int x509_name_canon(X509_NAME *a); 38 static int asn1_string_canon(ASN1_STRING *out, const ASN1_STRING *in); 39 static int i2d_name_canon(const STACK_OF(STACK_OF_X509_NAME_ENTRY) * intname, 40 unsigned char **in); 41 42 static int x509_name_ex_print(BIO *out, const ASN1_VALUE **pval, 43 int indent, 44 const char *fname, const ASN1_PCTX *pctx); 45 46 ASN1_SEQUENCE(X509_NAME_ENTRY) = { 47 ASN1_SIMPLE(X509_NAME_ENTRY, object, ASN1_OBJECT), 48 ASN1_SIMPLE(X509_NAME_ENTRY, value, ASN1_PRINTABLE) 49 } ASN1_SEQUENCE_END(X509_NAME_ENTRY) 50 51 IMPLEMENT_ASN1_FUNCTIONS(X509_NAME_ENTRY) 52 IMPLEMENT_ASN1_DUP_FUNCTION(X509_NAME_ENTRY) 53 54 /* 55 * For the "Name" type we need a SEQUENCE OF { SET OF X509_NAME_ENTRY } so 56 * declare two template wrappers for this 57 */ 58 59 ASN1_ITEM_TEMPLATE(X509_NAME_ENTRIES) = 60 ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SET_OF, 0, RDNS, X509_NAME_ENTRY) 61 static_ASN1_ITEM_TEMPLATE_END(X509_NAME_ENTRIES) 62 63 ASN1_ITEM_TEMPLATE(X509_NAME_INTERNAL) = 64 ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, Name, X509_NAME_ENTRIES) 65 static_ASN1_ITEM_TEMPLATE_END(X509_NAME_INTERNAL) 66 67 /* 68 * Normally that's where it would end: we'd have two nested STACK structures 69 * representing the ASN1. Unfortunately X509_NAME uses a completely different 70 * form and caches encodings so we have to process the internal form and 71 * convert to the external form. 72 */ 73 74 static const ASN1_EXTERN_FUNCS x509_name_ff = { 75 NULL, 76 x509_name_ex_new, 77 x509_name_ex_free, 78 0, /* Default clear behaviour is OK */ 79 x509_name_ex_d2i, 80 x509_name_ex_i2d, 81 x509_name_ex_print 82 }; 83 84 IMPLEMENT_EXTERN_ASN1(X509_NAME, V_ASN1_SEQUENCE, x509_name_ff) 85 86 IMPLEMENT_ASN1_FUNCTIONS(X509_NAME) 87 88 IMPLEMENT_ASN1_DUP_FUNCTION(X509_NAME) 89 90 static int x509_name_ex_new(ASN1_VALUE **val, const ASN1_ITEM *it) 91 { 92 X509_NAME *ret = OPENSSL_zalloc(sizeof(*ret)); 93 94 if (ret == NULL) 95 goto memerr; 96 if ((ret->entries = sk_X509_NAME_ENTRY_new_null()) == NULL) 97 goto memerr; 98 if ((ret->bytes = BUF_MEM_new()) == NULL) 99 goto memerr; 100 ret->modified = 1; 101 *val = (ASN1_VALUE *)ret; 102 return 1; 103 104 memerr: 105 ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE); 106 if (ret) { 107 sk_X509_NAME_ENTRY_free(ret->entries); 108 OPENSSL_free(ret); 109 } 110 return 0; 111 } 112 113 static void x509_name_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) 114 { 115 X509_NAME *a; 116 117 if (pval == NULL || *pval == NULL) 118 return; 119 a = (X509_NAME *)*pval; 120 121 BUF_MEM_free(a->bytes); 122 sk_X509_NAME_ENTRY_pop_free(a->entries, X509_NAME_ENTRY_free); 123 OPENSSL_free(a->canon_enc); 124 OPENSSL_free(a); 125 *pval = NULL; 126 } 127 128 static void local_sk_X509_NAME_ENTRY_free(STACK_OF(X509_NAME_ENTRY) *ne) 129 { 130 sk_X509_NAME_ENTRY_free(ne); 131 } 132 133 static void local_sk_X509_NAME_ENTRY_pop_free(STACK_OF(X509_NAME_ENTRY) *ne) 134 { 135 sk_X509_NAME_ENTRY_pop_free(ne, X509_NAME_ENTRY_free); 136 } 137 138 static int x509_name_ex_d2i(ASN1_VALUE **val, 139 const unsigned char **in, long len, 140 const ASN1_ITEM *it, int tag, int aclass, 141 char opt, ASN1_TLC *ctx) 142 { 143 const unsigned char *p = *in, *q; 144 union { 145 STACK_OF(STACK_OF_X509_NAME_ENTRY) *s; 146 ASN1_VALUE *a; 147 } intname = { 148 NULL 149 }; 150 union { 151 X509_NAME *x; 152 ASN1_VALUE *a; 153 } nm = { 154 NULL 155 }; 156 int i, j, ret; 157 STACK_OF(X509_NAME_ENTRY) *entries; 158 X509_NAME_ENTRY *entry; 159 160 if (len > X509_NAME_MAX) 161 len = X509_NAME_MAX; 162 q = p; 163 164 /* Get internal representation of Name */ 165 ret = ASN1_item_ex_d2i(&intname.a, 166 &p, len, ASN1_ITEM_rptr(X509_NAME_INTERNAL), 167 tag, aclass, opt, ctx); 168 169 if (ret <= 0) 170 return ret; 171 172 if (*val) 173 x509_name_ex_free(val, NULL); 174 if (!x509_name_ex_new(&nm.a, NULL)) 175 goto err; 176 /* We've decoded it: now cache encoding */ 177 if (!BUF_MEM_grow(nm.x->bytes, p - q)) 178 goto err; 179 memcpy(nm.x->bytes->data, q, p - q); 180 181 /* Convert internal representation to X509_NAME structure */ 182 for (i = 0; i < sk_STACK_OF_X509_NAME_ENTRY_num(intname.s); i++) { 183 entries = sk_STACK_OF_X509_NAME_ENTRY_value(intname.s, i); 184 for (j = 0; j < sk_X509_NAME_ENTRY_num(entries); j++) { 185 entry = sk_X509_NAME_ENTRY_value(entries, j); 186 entry->set = i; 187 if (!sk_X509_NAME_ENTRY_push(nm.x->entries, entry)) 188 goto err; 189 (void)sk_X509_NAME_ENTRY_set(entries, j, NULL); 190 } 191 } 192 ret = x509_name_canon(nm.x); 193 if (!ret) 194 goto err; 195 sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname.s, 196 local_sk_X509_NAME_ENTRY_free); 197 nm.x->modified = 0; 198 *val = nm.a; 199 *in = p; 200 return ret; 201 202 err: 203 if (nm.x != NULL) 204 X509_NAME_free(nm.x); 205 sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname.s, 206 local_sk_X509_NAME_ENTRY_pop_free); 207 ERR_raise(ERR_LIB_ASN1, ERR_R_NESTED_ASN1_ERROR); 208 return 0; 209 } 210 211 static int x509_name_ex_i2d(const ASN1_VALUE **val, unsigned char **out, 212 const ASN1_ITEM *it, int tag, int aclass) 213 { 214 int ret; 215 X509_NAME *a = (X509_NAME *)*val; 216 217 if (a->modified) { 218 ret = x509_name_encode(a); 219 if (ret < 0) 220 return ret; 221 ret = x509_name_canon(a); 222 if (!ret) 223 return -1; 224 } 225 ret = a->bytes->length; 226 if (out != NULL) { 227 memcpy(*out, a->bytes->data, ret); 228 *out += ret; 229 } 230 return ret; 231 } 232 233 static int x509_name_encode(X509_NAME *a) 234 { 235 union { 236 STACK_OF(STACK_OF_X509_NAME_ENTRY) *s; 237 const ASN1_VALUE *a; 238 } intname = { 239 NULL 240 }; 241 int len; 242 unsigned char *p; 243 STACK_OF(X509_NAME_ENTRY) *entries = NULL; 244 X509_NAME_ENTRY *entry; 245 int i, set = -1; 246 247 intname.s = sk_STACK_OF_X509_NAME_ENTRY_new_null(); 248 if (!intname.s) 249 goto memerr; 250 for (i = 0; i < sk_X509_NAME_ENTRY_num(a->entries); i++) { 251 entry = sk_X509_NAME_ENTRY_value(a->entries, i); 252 if (entry->set != set) { 253 entries = sk_X509_NAME_ENTRY_new_null(); 254 if (!entries) 255 goto memerr; 256 if (!sk_STACK_OF_X509_NAME_ENTRY_push(intname.s, entries)) { 257 sk_X509_NAME_ENTRY_free(entries); 258 goto memerr; 259 } 260 set = entry->set; 261 } 262 if (!sk_X509_NAME_ENTRY_push(entries, entry)) 263 goto memerr; 264 } 265 len = ASN1_item_ex_i2d(&intname.a, NULL, 266 ASN1_ITEM_rptr(X509_NAME_INTERNAL), -1, -1); 267 if (!BUF_MEM_grow(a->bytes, len)) 268 goto memerr; 269 p = (unsigned char *)a->bytes->data; 270 ASN1_item_ex_i2d(&intname.a, 271 &p, ASN1_ITEM_rptr(X509_NAME_INTERNAL), -1, -1); 272 sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname.s, 273 local_sk_X509_NAME_ENTRY_free); 274 a->modified = 0; 275 return len; 276 memerr: 277 sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname.s, 278 local_sk_X509_NAME_ENTRY_free); 279 ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE); 280 return -1; 281 } 282 283 static int x509_name_ex_print(BIO *out, const ASN1_VALUE **pval, 284 int indent, 285 const char *fname, const ASN1_PCTX *pctx) 286 { 287 if (X509_NAME_print_ex(out, (const X509_NAME *)*pval, 288 indent, pctx->nm_flags) <= 0) 289 return 0; 290 return 2; 291 } 292 293 /* 294 * This function generates the canonical encoding of the Name structure. In 295 * it all strings are converted to UTF8, leading, trailing and multiple 296 * spaces collapsed, converted to lower case and the leading SEQUENCE header 297 * removed. In future we could also normalize the UTF8 too. By doing this 298 * comparison of Name structures can be rapidly performed by just using 299 * memcmp() of the canonical encoding. By omitting the leading SEQUENCE name 300 * constraints of type dirName can also be checked with a simple memcmp(). 301 * NOTE: For empty X509_NAME (NULL-DN), canon_enclen == 0 && canon_enc == NULL 302 */ 303 304 static int x509_name_canon(X509_NAME *a) 305 { 306 unsigned char *p; 307 STACK_OF(STACK_OF_X509_NAME_ENTRY) *intname; 308 STACK_OF(X509_NAME_ENTRY) *entries = NULL; 309 X509_NAME_ENTRY *entry, *tmpentry = NULL; 310 int i, set = -1, ret = 0, len; 311 312 OPENSSL_free(a->canon_enc); 313 a->canon_enc = NULL; 314 /* Special case: empty X509_NAME => null encoding */ 315 if (sk_X509_NAME_ENTRY_num(a->entries) == 0) { 316 a->canon_enclen = 0; 317 return 1; 318 } 319 intname = sk_STACK_OF_X509_NAME_ENTRY_new_null(); 320 if (intname == NULL) { 321 ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE); 322 goto err; 323 } 324 for (i = 0; i < sk_X509_NAME_ENTRY_num(a->entries); i++) { 325 entry = sk_X509_NAME_ENTRY_value(a->entries, i); 326 if (entry->set != set) { 327 entries = sk_X509_NAME_ENTRY_new_null(); 328 if (entries == NULL) 329 goto err; 330 if (!sk_STACK_OF_X509_NAME_ENTRY_push(intname, entries)) { 331 sk_X509_NAME_ENTRY_free(entries); 332 ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE); 333 goto err; 334 } 335 set = entry->set; 336 } 337 tmpentry = X509_NAME_ENTRY_new(); 338 if (tmpentry == NULL) { 339 ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE); 340 goto err; 341 } 342 tmpentry->object = OBJ_dup(entry->object); 343 if (tmpentry->object == NULL) { 344 ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE); 345 goto err; 346 } 347 if (!asn1_string_canon(tmpentry->value, entry->value)) 348 goto err; 349 if (!sk_X509_NAME_ENTRY_push(entries, tmpentry)) { 350 ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE); 351 goto err; 352 } 353 tmpentry = NULL; 354 } 355 356 /* Finally generate encoding */ 357 len = i2d_name_canon(intname, NULL); 358 if (len < 0) 359 goto err; 360 a->canon_enclen = len; 361 362 p = OPENSSL_malloc(a->canon_enclen); 363 if (p == NULL) { 364 ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE); 365 goto err; 366 } 367 368 a->canon_enc = p; 369 370 i2d_name_canon(intname, &p); 371 372 ret = 1; 373 374 err: 375 X509_NAME_ENTRY_free(tmpentry); 376 sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname, 377 local_sk_X509_NAME_ENTRY_pop_free); 378 return ret; 379 } 380 381 /* Bitmap of all the types of string that will be canonicalized. */ 382 383 #define ASN1_MASK_CANON \ 384 (B_ASN1_UTF8STRING | B_ASN1_BMPSTRING | B_ASN1_UNIVERSALSTRING \ 385 | B_ASN1_PRINTABLESTRING | B_ASN1_T61STRING | B_ASN1_IA5STRING \ 386 | B_ASN1_VISIBLESTRING) 387 388 static int asn1_string_canon(ASN1_STRING *out, const ASN1_STRING *in) 389 { 390 unsigned char *to, *from; 391 int len, i; 392 393 /* If type not in bitmask just copy string across */ 394 if (!(ASN1_tag2bit(in->type) & ASN1_MASK_CANON)) { 395 if (!ASN1_STRING_copy(out, in)) 396 return 0; 397 return 1; 398 } 399 400 out->type = V_ASN1_UTF8STRING; 401 out->length = ASN1_STRING_to_UTF8(&out->data, in); 402 if (out->length == -1) 403 return 0; 404 405 to = out->data; 406 from = to; 407 408 len = out->length; 409 410 /* 411 * Convert string in place to canonical form. Ultimately we may need to 412 * handle a wider range of characters but for now ignore anything with 413 * MSB set and rely on the ossl_isspace() to fail on bad characters without 414 * needing isascii or range checks as well. 415 */ 416 417 /* Ignore leading spaces */ 418 while (len > 0 && ossl_isspace(*from)) { 419 from++; 420 len--; 421 } 422 423 to = from + len; 424 425 /* Ignore trailing spaces */ 426 while (len > 0 && ossl_isspace(to[-1])) { 427 to--; 428 len--; 429 } 430 431 to = out->data; 432 433 i = 0; 434 while (i < len) { 435 /* If not ASCII set just copy across */ 436 if (!ossl_isascii(*from)) { 437 *to++ = *from++; 438 i++; 439 } 440 /* Collapse multiple spaces */ 441 else if (ossl_isspace(*from)) { 442 /* Copy one space across */ 443 *to++ = ' '; 444 /* 445 * Ignore subsequent spaces. Note: don't need to check len here 446 * because we know the last character is a non-space so we can't 447 * overflow. 448 */ 449 do { 450 from++; 451 i++; 452 } 453 while (ossl_isspace(*from)); 454 } else { 455 *to++ = ossl_tolower(*from); 456 from++; 457 i++; 458 } 459 } 460 461 out->length = to - out->data; 462 463 return 1; 464 465 } 466 467 static int i2d_name_canon(const STACK_OF(STACK_OF_X509_NAME_ENTRY) * _intname, 468 unsigned char **in) 469 { 470 int i, len, ltmp; 471 const ASN1_VALUE *v; 472 STACK_OF(ASN1_VALUE) *intname = (STACK_OF(ASN1_VALUE) *)_intname; 473 474 len = 0; 475 for (i = 0; i < sk_ASN1_VALUE_num(intname); i++) { 476 v = sk_ASN1_VALUE_value(intname, i); 477 ltmp = ASN1_item_ex_i2d(&v, in, 478 ASN1_ITEM_rptr(X509_NAME_ENTRIES), -1, -1); 479 if (ltmp < 0 || len > INT_MAX - ltmp) 480 return -1; 481 len += ltmp; 482 } 483 return len; 484 } 485 486 int X509_NAME_set(X509_NAME **xn, const X509_NAME *name) 487 { 488 X509_NAME *name_copy; 489 490 if (*xn == name) 491 return *xn != NULL; 492 if ((name_copy = X509_NAME_dup(name)) == NULL) 493 return 0; 494 X509_NAME_free(*xn); 495 *xn = name_copy; 496 return 1; 497 } 498 499 int X509_NAME_print(BIO *bp, const X509_NAME *name, int obase) 500 { 501 char *s, *c, *b; 502 int i; 503 504 b = X509_NAME_oneline(name, NULL, 0); 505 if (b == NULL) 506 return 0; 507 if (*b == '\0') { 508 OPENSSL_free(b); 509 return 1; 510 } 511 s = b + 1; /* skip the first slash */ 512 513 c = s; 514 for (;;) { 515 if (((*s == '/') && 516 (ossl_isupper(s[1]) && ((s[2] == '=') || 517 (ossl_isupper(s[2]) && (s[3] == '=')) 518 ))) || (*s == '\0')) 519 { 520 i = s - c; 521 if (BIO_write(bp, c, i) != i) 522 goto err; 523 c = s + 1; /* skip following slash */ 524 if (*s != '\0') { 525 if (BIO_write(bp, ", ", 2) != 2) 526 goto err; 527 } 528 } 529 if (*s == '\0') 530 break; 531 s++; 532 } 533 534 OPENSSL_free(b); 535 return 1; 536 err: 537 ERR_raise(ERR_LIB_X509, ERR_R_BUF_LIB); 538 OPENSSL_free(b); 539 return 0; 540 } 541 542 int X509_NAME_get0_der(const X509_NAME *nm, const unsigned char **pder, 543 size_t *pderlen) 544 { 545 /* Make sure encoding is valid */ 546 if (i2d_X509_NAME(nm, NULL) <= 0) 547 return 0; 548 if (pder != NULL) 549 *pder = (unsigned char *)nm->bytes->data; 550 if (pderlen != NULL) 551 *pderlen = nm->bytes->length; 552 return 1; 553 } 554