1 /* 2 * X.509v3 certificate parsing and processing (RFC 3280 profile) 3 * Copyright (c) 2006-2007, Jouni Malinen <j@w1.fi> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License version 2 as 7 * published by the Free Software Foundation. 8 * 9 * Alternatively, this software may be distributed under the terms of BSD 10 * license. 11 * 12 * See README and COPYING for more details. 13 */ 14 15 #include "includes.h" 16 17 #include "common.h" 18 #include "crypto/crypto.h" 19 #include "asn1.h" 20 #include "x509v3.h" 21 22 23 static void x509_free_name(struct x509_name *name) 24 { 25 size_t i; 26 27 for (i = 0; i < name->num_attr; i++) { 28 os_free(name->attr[i].value); 29 name->attr[i].value = NULL; 30 name->attr[i].type = X509_NAME_ATTR_NOT_USED; 31 } 32 name->num_attr = 0; 33 os_free(name->email); 34 name->email = NULL; 35 36 os_free(name->alt_email); 37 os_free(name->dns); 38 os_free(name->uri); 39 os_free(name->ip); 40 name->alt_email = name->dns = name->uri = NULL; 41 name->ip = NULL; 42 name->ip_len = 0; 43 os_memset(&name->rid, 0, sizeof(name->rid)); 44 } 45 46 47 /** 48 * x509_certificate_free - Free an X.509 certificate 49 * @cert: Certificate to be freed 50 */ 51 void x509_certificate_free(struct x509_certificate *cert) 52 { 53 if (cert == NULL) 54 return; 55 if (cert->next) { 56 wpa_printf(MSG_DEBUG, "X509: x509_certificate_free: cer=%p " 57 "was still on a list (next=%p)\n", 58 cert, cert->next); 59 } 60 x509_free_name(&cert->issuer); 61 x509_free_name(&cert->subject); 62 os_free(cert->public_key); 63 os_free(cert->sign_value); 64 os_free(cert); 65 } 66 67 68 /** 69 * x509_certificate_free - Free an X.509 certificate chain 70 * @cert: Pointer to the first certificate in the chain 71 */ 72 void x509_certificate_chain_free(struct x509_certificate *cert) 73 { 74 struct x509_certificate *next; 75 76 while (cert) { 77 next = cert->next; 78 cert->next = NULL; 79 x509_certificate_free(cert); 80 cert = next; 81 } 82 } 83 84 85 static int x509_whitespace(char c) 86 { 87 return c == ' ' || c == '\t'; 88 } 89 90 91 static void x509_str_strip_whitespace(char *a) 92 { 93 char *ipos, *opos; 94 int remove_whitespace = 1; 95 96 ipos = opos = a; 97 98 while (*ipos) { 99 if (remove_whitespace && x509_whitespace(*ipos)) 100 ipos++; 101 else { 102 remove_whitespace = x509_whitespace(*ipos); 103 *opos++ = *ipos++; 104 } 105 } 106 107 *opos-- = '\0'; 108 if (opos > a && x509_whitespace(*opos)) 109 *opos = '\0'; 110 } 111 112 113 static int x509_str_compare(const char *a, const char *b) 114 { 115 char *aa, *bb; 116 int ret; 117 118 if (!a && b) 119 return -1; 120 if (a && !b) 121 return 1; 122 if (!a && !b) 123 return 0; 124 125 aa = os_strdup(a); 126 bb = os_strdup(b); 127 128 if (aa == NULL || bb == NULL) { 129 os_free(aa); 130 os_free(bb); 131 return os_strcasecmp(a, b); 132 } 133 134 x509_str_strip_whitespace(aa); 135 x509_str_strip_whitespace(bb); 136 137 ret = os_strcasecmp(aa, bb); 138 139 os_free(aa); 140 os_free(bb); 141 142 return ret; 143 } 144 145 146 /** 147 * x509_name_compare - Compare X.509 certificate names 148 * @a: Certificate name 149 * @b: Certificate name 150 * Returns: <0, 0, or >0 based on whether a is less than, equal to, or 151 * greater than b 152 */ 153 int x509_name_compare(struct x509_name *a, struct x509_name *b) 154 { 155 int res; 156 size_t i; 157 158 if (!a && b) 159 return -1; 160 if (a && !b) 161 return 1; 162 if (!a && !b) 163 return 0; 164 if (a->num_attr < b->num_attr) 165 return -1; 166 if (a->num_attr > b->num_attr) 167 return 1; 168 169 for (i = 0; i < a->num_attr; i++) { 170 if (a->attr[i].type < b->attr[i].type) 171 return -1; 172 if (a->attr[i].type > b->attr[i].type) 173 return -1; 174 res = x509_str_compare(a->attr[i].value, b->attr[i].value); 175 if (res) 176 return res; 177 } 178 res = x509_str_compare(a->email, b->email); 179 if (res) 180 return res; 181 182 return 0; 183 } 184 185 186 static int x509_parse_algorithm_identifier( 187 const u8 *buf, size_t len, 188 struct x509_algorithm_identifier *id, const u8 **next) 189 { 190 struct asn1_hdr hdr; 191 const u8 *pos, *end; 192 193 /* 194 * AlgorithmIdentifier ::= SEQUENCE { 195 * algorithm OBJECT IDENTIFIER, 196 * parameters ANY DEFINED BY algorithm OPTIONAL 197 * } 198 */ 199 200 if (asn1_get_next(buf, len, &hdr) < 0 || 201 hdr.class != ASN1_CLASS_UNIVERSAL || 202 hdr.tag != ASN1_TAG_SEQUENCE) { 203 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE " 204 "(AlgorithmIdentifier) - found class %d tag 0x%x", 205 hdr.class, hdr.tag); 206 return -1; 207 } 208 pos = hdr.payload; 209 end = pos + hdr.length; 210 211 if (end > buf + len) 212 return -1; 213 214 *next = end; 215 216 if (asn1_get_oid(pos, end - pos, &id->oid, &pos)) 217 return -1; 218 219 /* TODO: optional parameters */ 220 221 return 0; 222 } 223 224 225 static int x509_parse_public_key(const u8 *buf, size_t len, 226 struct x509_certificate *cert, 227 const u8 **next) 228 { 229 struct asn1_hdr hdr; 230 const u8 *pos, *end; 231 232 /* 233 * SubjectPublicKeyInfo ::= SEQUENCE { 234 * algorithm AlgorithmIdentifier, 235 * subjectPublicKey BIT STRING 236 * } 237 */ 238 239 pos = buf; 240 end = buf + len; 241 242 if (asn1_get_next(pos, end - pos, &hdr) < 0 || 243 hdr.class != ASN1_CLASS_UNIVERSAL || 244 hdr.tag != ASN1_TAG_SEQUENCE) { 245 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE " 246 "(SubjectPublicKeyInfo) - found class %d tag 0x%x", 247 hdr.class, hdr.tag); 248 return -1; 249 } 250 pos = hdr.payload; 251 252 if (pos + hdr.length > end) 253 return -1; 254 end = pos + hdr.length; 255 *next = end; 256 257 if (x509_parse_algorithm_identifier(pos, end - pos, 258 &cert->public_key_alg, &pos)) 259 return -1; 260 261 if (asn1_get_next(pos, end - pos, &hdr) < 0 || 262 hdr.class != ASN1_CLASS_UNIVERSAL || 263 hdr.tag != ASN1_TAG_BITSTRING) { 264 wpa_printf(MSG_DEBUG, "X509: Expected BITSTRING " 265 "(subjectPublicKey) - found class %d tag 0x%x", 266 hdr.class, hdr.tag); 267 return -1; 268 } 269 if (hdr.length < 1) 270 return -1; 271 pos = hdr.payload; 272 if (*pos) { 273 wpa_printf(MSG_DEBUG, "X509: BITSTRING - %d unused bits", 274 *pos); 275 /* 276 * TODO: should this be rejected? X.509 certificates are 277 * unlikely to use such a construction. Now we would end up 278 * including the extra bits in the buffer which may also be 279 * ok. 280 */ 281 } 282 os_free(cert->public_key); 283 cert->public_key = os_malloc(hdr.length - 1); 284 if (cert->public_key == NULL) { 285 wpa_printf(MSG_DEBUG, "X509: Failed to allocate memory for " 286 "public key"); 287 return -1; 288 } 289 os_memcpy(cert->public_key, pos + 1, hdr.length - 1); 290 cert->public_key_len = hdr.length - 1; 291 wpa_hexdump(MSG_MSGDUMP, "X509: subjectPublicKey", 292 cert->public_key, cert->public_key_len); 293 294 return 0; 295 } 296 297 298 static int x509_parse_name(const u8 *buf, size_t len, struct x509_name *name, 299 const u8 **next) 300 { 301 struct asn1_hdr hdr; 302 const u8 *pos, *end, *set_pos, *set_end, *seq_pos, *seq_end; 303 struct asn1_oid oid; 304 char *val; 305 306 /* 307 * Name ::= CHOICE { RDNSequence } 308 * RDNSequence ::= SEQUENCE OF RelativeDistinguishedName 309 * RelativeDistinguishedName ::= SET OF AttributeTypeAndValue 310 * AttributeTypeAndValue ::= SEQUENCE { 311 * type AttributeType, 312 * value AttributeValue 313 * } 314 * AttributeType ::= OBJECT IDENTIFIER 315 * AttributeValue ::= ANY DEFINED BY AttributeType 316 */ 317 318 if (asn1_get_next(buf, len, &hdr) < 0 || 319 hdr.class != ASN1_CLASS_UNIVERSAL || 320 hdr.tag != ASN1_TAG_SEQUENCE) { 321 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE " 322 "(Name / RDNSequencer) - found class %d tag 0x%x", 323 hdr.class, hdr.tag); 324 return -1; 325 } 326 pos = hdr.payload; 327 328 if (pos + hdr.length > buf + len) 329 return -1; 330 331 end = *next = pos + hdr.length; 332 333 while (pos < end) { 334 enum x509_name_attr_type type; 335 336 if (asn1_get_next(pos, end - pos, &hdr) < 0 || 337 hdr.class != ASN1_CLASS_UNIVERSAL || 338 hdr.tag != ASN1_TAG_SET) { 339 wpa_printf(MSG_DEBUG, "X509: Expected SET " 340 "(RelativeDistinguishedName) - found class " 341 "%d tag 0x%x", hdr.class, hdr.tag); 342 x509_free_name(name); 343 return -1; 344 } 345 346 set_pos = hdr.payload; 347 pos = set_end = hdr.payload + hdr.length; 348 349 if (asn1_get_next(set_pos, set_end - set_pos, &hdr) < 0 || 350 hdr.class != ASN1_CLASS_UNIVERSAL || 351 hdr.tag != ASN1_TAG_SEQUENCE) { 352 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE " 353 "(AttributeTypeAndValue) - found class %d " 354 "tag 0x%x", hdr.class, hdr.tag); 355 x509_free_name(name); 356 return -1; 357 } 358 359 seq_pos = hdr.payload; 360 seq_end = hdr.payload + hdr.length; 361 362 if (asn1_get_oid(seq_pos, seq_end - seq_pos, &oid, &seq_pos)) { 363 x509_free_name(name); 364 return -1; 365 } 366 367 if (asn1_get_next(seq_pos, seq_end - seq_pos, &hdr) < 0 || 368 hdr.class != ASN1_CLASS_UNIVERSAL) { 369 wpa_printf(MSG_DEBUG, "X509: Failed to parse " 370 "AttributeValue"); 371 x509_free_name(name); 372 return -1; 373 } 374 375 /* RFC 3280: 376 * MUST: country, organization, organizational-unit, 377 * distinguished name qualifier, state or province name, 378 * common name, serial number. 379 * SHOULD: locality, title, surname, given name, initials, 380 * pseudonym, generation qualifier. 381 * MUST: domainComponent (RFC 2247). 382 */ 383 type = X509_NAME_ATTR_NOT_USED; 384 if (oid.len == 4 && 385 oid.oid[0] == 2 && oid.oid[1] == 5 && oid.oid[2] == 4) { 386 /* id-at ::= 2.5.4 */ 387 switch (oid.oid[3]) { 388 case 3: 389 /* commonName */ 390 type = X509_NAME_ATTR_CN; 391 break; 392 case 6: 393 /* countryName */ 394 type = X509_NAME_ATTR_C; 395 break; 396 case 7: 397 /* localityName */ 398 type = X509_NAME_ATTR_L; 399 break; 400 case 8: 401 /* stateOrProvinceName */ 402 type = X509_NAME_ATTR_ST; 403 break; 404 case 10: 405 /* organizationName */ 406 type = X509_NAME_ATTR_O; 407 break; 408 case 11: 409 /* organizationalUnitName */ 410 type = X509_NAME_ATTR_OU; 411 break; 412 } 413 } else if (oid.len == 7 && 414 oid.oid[0] == 1 && oid.oid[1] == 2 && 415 oid.oid[2] == 840 && oid.oid[3] == 113549 && 416 oid.oid[4] == 1 && oid.oid[5] == 9 && 417 oid.oid[6] == 1) { 418 /* 1.2.840.113549.1.9.1 - e-mailAddress */ 419 os_free(name->email); 420 name->email = os_malloc(hdr.length + 1); 421 if (name->email == NULL) { 422 x509_free_name(name); 423 return -1; 424 } 425 os_memcpy(name->email, hdr.payload, hdr.length); 426 name->email[hdr.length] = '\0'; 427 continue; 428 } else if (oid.len == 7 && 429 oid.oid[0] == 0 && oid.oid[1] == 9 && 430 oid.oid[2] == 2342 && oid.oid[3] == 19200300 && 431 oid.oid[4] == 100 && oid.oid[5] == 1 && 432 oid.oid[6] == 25) { 433 /* 0.9.2342.19200300.100.1.25 - domainComponent */ 434 type = X509_NAME_ATTR_DC; 435 } 436 437 if (type == X509_NAME_ATTR_NOT_USED) { 438 wpa_hexdump(MSG_DEBUG, "X509: Unrecognized OID", 439 (u8 *) oid.oid, 440 oid.len * sizeof(oid.oid[0])); 441 wpa_hexdump_ascii(MSG_MSGDUMP, "X509: Attribute Data", 442 hdr.payload, hdr.length); 443 continue; 444 } 445 446 if (name->num_attr == X509_MAX_NAME_ATTRIBUTES) { 447 wpa_printf(MSG_INFO, "X509: Too many Name attributes"); 448 x509_free_name(name); 449 return -1; 450 } 451 452 val = os_malloc(hdr.length + 1); 453 if (val == NULL) { 454 x509_free_name(name); 455 return -1; 456 } 457 os_memcpy(val, hdr.payload, hdr.length); 458 val[hdr.length] = '\0'; 459 if (os_strlen(val) != hdr.length) { 460 wpa_printf(MSG_INFO, "X509: Reject certificate with " 461 "embedded NUL byte in a string (%s[NUL])", 462 val); 463 x509_free_name(name); 464 return -1; 465 } 466 467 name->attr[name->num_attr].type = type; 468 name->attr[name->num_attr].value = val; 469 name->num_attr++; 470 } 471 472 return 0; 473 } 474 475 476 static char * x509_name_attr_str(enum x509_name_attr_type type) 477 { 478 switch (type) { 479 case X509_NAME_ATTR_NOT_USED: 480 return "[N/A]"; 481 case X509_NAME_ATTR_DC: 482 return "DC"; 483 case X509_NAME_ATTR_CN: 484 return "CN"; 485 case X509_NAME_ATTR_C: 486 return "C"; 487 case X509_NAME_ATTR_L: 488 return "L"; 489 case X509_NAME_ATTR_ST: 490 return "ST"; 491 case X509_NAME_ATTR_O: 492 return "O"; 493 case X509_NAME_ATTR_OU: 494 return "OU"; 495 } 496 return "?"; 497 } 498 499 500 /** 501 * x509_name_string - Convert an X.509 certificate name into a string 502 * @name: Name to convert 503 * @buf: Buffer for the string 504 * @len: Maximum buffer length 505 */ 506 void x509_name_string(struct x509_name *name, char *buf, size_t len) 507 { 508 char *pos, *end; 509 int ret; 510 size_t i; 511 512 if (len == 0) 513 return; 514 515 pos = buf; 516 end = buf + len; 517 518 for (i = 0; i < name->num_attr; i++) { 519 ret = os_snprintf(pos, end - pos, "%s=%s, ", 520 x509_name_attr_str(name->attr[i].type), 521 name->attr[i].value); 522 if (ret < 0 || ret >= end - pos) 523 goto done; 524 pos += ret; 525 } 526 527 if (pos > buf + 1 && pos[-1] == ' ' && pos[-2] == ',') { 528 pos--; 529 *pos = '\0'; 530 pos--; 531 *pos = '\0'; 532 } 533 534 if (name->email) { 535 ret = os_snprintf(pos, end - pos, "/emailAddress=%s", 536 name->email); 537 if (ret < 0 || ret >= end - pos) 538 goto done; 539 pos += ret; 540 } 541 542 done: 543 end[-1] = '\0'; 544 } 545 546 547 static int x509_parse_time(const u8 *buf, size_t len, u8 asn1_tag, 548 os_time_t *val) 549 { 550 const char *pos; 551 int year, month, day, hour, min, sec; 552 553 /* 554 * Time ::= CHOICE { 555 * utcTime UTCTime, 556 * generalTime GeneralizedTime 557 * } 558 * 559 * UTCTime: YYMMDDHHMMSSZ 560 * GeneralizedTime: YYYYMMDDHHMMSSZ 561 */ 562 563 pos = (const char *) buf; 564 565 switch (asn1_tag) { 566 case ASN1_TAG_UTCTIME: 567 if (len != 13 || buf[12] != 'Z') { 568 wpa_hexdump_ascii(MSG_DEBUG, "X509: Unrecognized " 569 "UTCTime format", buf, len); 570 return -1; 571 } 572 if (sscanf(pos, "%02d", &year) != 1) { 573 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse " 574 "UTCTime year", buf, len); 575 return -1; 576 } 577 if (year < 50) 578 year += 2000; 579 else 580 year += 1900; 581 pos += 2; 582 break; 583 case ASN1_TAG_GENERALIZEDTIME: 584 if (len != 15 || buf[14] != 'Z') { 585 wpa_hexdump_ascii(MSG_DEBUG, "X509: Unrecognized " 586 "GeneralizedTime format", buf, len); 587 return -1; 588 } 589 if (sscanf(pos, "%04d", &year) != 1) { 590 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse " 591 "GeneralizedTime year", buf, len); 592 return -1; 593 } 594 pos += 4; 595 break; 596 default: 597 wpa_printf(MSG_DEBUG, "X509: Expected UTCTime or " 598 "GeneralizedTime - found tag 0x%x", asn1_tag); 599 return -1; 600 } 601 602 if (sscanf(pos, "%02d", &month) != 1) { 603 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time " 604 "(month)", buf, len); 605 return -1; 606 } 607 pos += 2; 608 609 if (sscanf(pos, "%02d", &day) != 1) { 610 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time " 611 "(day)", buf, len); 612 return -1; 613 } 614 pos += 2; 615 616 if (sscanf(pos, "%02d", &hour) != 1) { 617 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time " 618 "(hour)", buf, len); 619 return -1; 620 } 621 pos += 2; 622 623 if (sscanf(pos, "%02d", &min) != 1) { 624 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time " 625 "(min)", buf, len); 626 return -1; 627 } 628 pos += 2; 629 630 if (sscanf(pos, "%02d", &sec) != 1) { 631 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time " 632 "(sec)", buf, len); 633 return -1; 634 } 635 636 if (os_mktime(year, month, day, hour, min, sec, val) < 0) { 637 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to convert Time", 638 buf, len); 639 if (year < 1970) { 640 /* 641 * At least some test certificates have been configured 642 * to use dates prior to 1970. Set the date to 643 * beginning of 1970 to handle these case. 644 */ 645 wpa_printf(MSG_DEBUG, "X509: Year=%d before epoch - " 646 "assume epoch as the time", year); 647 *val = 0; 648 return 0; 649 } 650 return -1; 651 } 652 653 return 0; 654 } 655 656 657 static int x509_parse_validity(const u8 *buf, size_t len, 658 struct x509_certificate *cert, const u8 **next) 659 { 660 struct asn1_hdr hdr; 661 const u8 *pos; 662 size_t plen; 663 664 /* 665 * Validity ::= SEQUENCE { 666 * notBefore Time, 667 * notAfter Time 668 * } 669 * 670 * RFC 3280, 4.1.2.5: 671 * CAs conforming to this profile MUST always encode certificate 672 * validity dates through the year 2049 as UTCTime; certificate 673 * validity dates in 2050 or later MUST be encoded as GeneralizedTime. 674 */ 675 676 if (asn1_get_next(buf, len, &hdr) < 0 || 677 hdr.class != ASN1_CLASS_UNIVERSAL || 678 hdr.tag != ASN1_TAG_SEQUENCE) { 679 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE " 680 "(Validity) - found class %d tag 0x%x", 681 hdr.class, hdr.tag); 682 return -1; 683 } 684 pos = hdr.payload; 685 plen = hdr.length; 686 687 if (pos + plen > buf + len) 688 return -1; 689 690 *next = pos + plen; 691 692 if (asn1_get_next(pos, plen, &hdr) < 0 || 693 hdr.class != ASN1_CLASS_UNIVERSAL || 694 x509_parse_time(hdr.payload, hdr.length, hdr.tag, 695 &cert->not_before) < 0) { 696 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse notBefore " 697 "Time", hdr.payload, hdr.length); 698 return -1; 699 } 700 701 pos = hdr.payload + hdr.length; 702 plen = *next - pos; 703 704 if (asn1_get_next(pos, plen, &hdr) < 0 || 705 hdr.class != ASN1_CLASS_UNIVERSAL || 706 x509_parse_time(hdr.payload, hdr.length, hdr.tag, 707 &cert->not_after) < 0) { 708 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse notAfter " 709 "Time", hdr.payload, hdr.length); 710 return -1; 711 } 712 713 wpa_printf(MSG_MSGDUMP, "X509: Validity: notBefore: %lu notAfter: %lu", 714 (unsigned long) cert->not_before, 715 (unsigned long) cert->not_after); 716 717 return 0; 718 } 719 720 721 static int x509_id_ce_oid(struct asn1_oid *oid) 722 { 723 /* id-ce arc from X.509 for standard X.509v3 extensions */ 724 return oid->len >= 4 && 725 oid->oid[0] == 2 /* joint-iso-ccitt */ && 726 oid->oid[1] == 5 /* ds */ && 727 oid->oid[2] == 29 /* id-ce */; 728 } 729 730 731 static int x509_parse_ext_key_usage(struct x509_certificate *cert, 732 const u8 *pos, size_t len) 733 { 734 struct asn1_hdr hdr; 735 736 /* 737 * KeyUsage ::= BIT STRING { 738 * digitalSignature (0), 739 * nonRepudiation (1), 740 * keyEncipherment (2), 741 * dataEncipherment (3), 742 * keyAgreement (4), 743 * keyCertSign (5), 744 * cRLSign (6), 745 * encipherOnly (7), 746 * decipherOnly (8) } 747 */ 748 749 if (asn1_get_next(pos, len, &hdr) < 0 || 750 hdr.class != ASN1_CLASS_UNIVERSAL || 751 hdr.tag != ASN1_TAG_BITSTRING || 752 hdr.length < 1) { 753 wpa_printf(MSG_DEBUG, "X509: Expected BIT STRING in " 754 "KeyUsage; found %d tag 0x%x len %d", 755 hdr.class, hdr.tag, hdr.length); 756 return -1; 757 } 758 759 cert->extensions_present |= X509_EXT_KEY_USAGE; 760 cert->key_usage = asn1_bit_string_to_long(hdr.payload, hdr.length); 761 762 wpa_printf(MSG_DEBUG, "X509: KeyUsage 0x%lx", cert->key_usage); 763 764 return 0; 765 } 766 767 768 static int x509_parse_ext_basic_constraints(struct x509_certificate *cert, 769 const u8 *pos, size_t len) 770 { 771 struct asn1_hdr hdr; 772 unsigned long value; 773 size_t left; 774 775 /* 776 * BasicConstraints ::= SEQUENCE { 777 * cA BOOLEAN DEFAULT FALSE, 778 * pathLenConstraint INTEGER (0..MAX) OPTIONAL } 779 */ 780 781 if (asn1_get_next(pos, len, &hdr) < 0 || 782 hdr.class != ASN1_CLASS_UNIVERSAL || 783 hdr.tag != ASN1_TAG_SEQUENCE) { 784 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE in " 785 "BasicConstraints; found %d tag 0x%x", 786 hdr.class, hdr.tag); 787 return -1; 788 } 789 790 cert->extensions_present |= X509_EXT_BASIC_CONSTRAINTS; 791 792 if (hdr.length == 0) 793 return 0; 794 795 if (asn1_get_next(hdr.payload, hdr.length, &hdr) < 0 || 796 hdr.class != ASN1_CLASS_UNIVERSAL) { 797 wpa_printf(MSG_DEBUG, "X509: Failed to parse " 798 "BasicConstraints"); 799 return -1; 800 } 801 802 if (hdr.tag == ASN1_TAG_BOOLEAN) { 803 if (hdr.length != 1) { 804 wpa_printf(MSG_DEBUG, "X509: Unexpected " 805 "Boolean length (%u) in BasicConstraints", 806 hdr.length); 807 return -1; 808 } 809 cert->ca = hdr.payload[0]; 810 811 if (hdr.payload + hdr.length == pos + len) { 812 wpa_printf(MSG_DEBUG, "X509: BasicConstraints - cA=%d", 813 cert->ca); 814 return 0; 815 } 816 817 if (asn1_get_next(hdr.payload + hdr.length, len - hdr.length, 818 &hdr) < 0 || 819 hdr.class != ASN1_CLASS_UNIVERSAL) { 820 wpa_printf(MSG_DEBUG, "X509: Failed to parse " 821 "BasicConstraints"); 822 return -1; 823 } 824 } 825 826 if (hdr.tag != ASN1_TAG_INTEGER) { 827 wpa_printf(MSG_DEBUG, "X509: Expected INTEGER in " 828 "BasicConstraints; found class %d tag 0x%x", 829 hdr.class, hdr.tag); 830 return -1; 831 } 832 833 pos = hdr.payload; 834 left = hdr.length; 835 value = 0; 836 while (left) { 837 value <<= 8; 838 value |= *pos++; 839 left--; 840 } 841 842 cert->path_len_constraint = value; 843 cert->extensions_present |= X509_EXT_PATH_LEN_CONSTRAINT; 844 845 wpa_printf(MSG_DEBUG, "X509: BasicConstraints - cA=%d " 846 "pathLenConstraint=%lu", 847 cert->ca, cert->path_len_constraint); 848 849 return 0; 850 } 851 852 853 static int x509_parse_alt_name_rfc8222(struct x509_name *name, 854 const u8 *pos, size_t len) 855 { 856 /* rfc822Name IA5String */ 857 wpa_hexdump_ascii(MSG_MSGDUMP, "X509: altName - rfc822Name", pos, len); 858 os_free(name->alt_email); 859 name->alt_email = os_zalloc(len + 1); 860 if (name->alt_email == NULL) 861 return -1; 862 os_memcpy(name->alt_email, pos, len); 863 if (os_strlen(name->alt_email) != len) { 864 wpa_printf(MSG_INFO, "X509: Reject certificate with " 865 "embedded NUL byte in rfc822Name (%s[NUL])", 866 name->alt_email); 867 os_free(name->alt_email); 868 name->alt_email = NULL; 869 return -1; 870 } 871 return 0; 872 } 873 874 875 static int x509_parse_alt_name_dns(struct x509_name *name, 876 const u8 *pos, size_t len) 877 { 878 /* dNSName IA5String */ 879 wpa_hexdump_ascii(MSG_MSGDUMP, "X509: altName - dNSName", pos, len); 880 os_free(name->dns); 881 name->dns = os_zalloc(len + 1); 882 if (name->dns == NULL) 883 return -1; 884 os_memcpy(name->dns, pos, len); 885 if (os_strlen(name->dns) != len) { 886 wpa_printf(MSG_INFO, "X509: Reject certificate with " 887 "embedded NUL byte in dNSName (%s[NUL])", 888 name->dns); 889 os_free(name->dns); 890 name->dns = NULL; 891 return -1; 892 } 893 return 0; 894 } 895 896 897 static int x509_parse_alt_name_uri(struct x509_name *name, 898 const u8 *pos, size_t len) 899 { 900 /* uniformResourceIdentifier IA5String */ 901 wpa_hexdump_ascii(MSG_MSGDUMP, 902 "X509: altName - uniformResourceIdentifier", 903 pos, len); 904 os_free(name->uri); 905 name->uri = os_zalloc(len + 1); 906 if (name->uri == NULL) 907 return -1; 908 os_memcpy(name->uri, pos, len); 909 if (os_strlen(name->uri) != len) { 910 wpa_printf(MSG_INFO, "X509: Reject certificate with " 911 "embedded NUL byte in uniformResourceIdentifier " 912 "(%s[NUL])", name->uri); 913 os_free(name->uri); 914 name->uri = NULL; 915 return -1; 916 } 917 return 0; 918 } 919 920 921 static int x509_parse_alt_name_ip(struct x509_name *name, 922 const u8 *pos, size_t len) 923 { 924 /* iPAddress OCTET STRING */ 925 wpa_hexdump(MSG_MSGDUMP, "X509: altName - iPAddress", pos, len); 926 os_free(name->ip); 927 name->ip = os_malloc(len); 928 if (name->ip == NULL) 929 return -1; 930 os_memcpy(name->ip, pos, len); 931 name->ip_len = len; 932 return 0; 933 } 934 935 936 static int x509_parse_alt_name_rid(struct x509_name *name, 937 const u8 *pos, size_t len) 938 { 939 char buf[80]; 940 941 /* registeredID OBJECT IDENTIFIER */ 942 if (asn1_parse_oid(pos, len, &name->rid) < 0) 943 return -1; 944 945 asn1_oid_to_str(&name->rid, buf, sizeof(buf)); 946 wpa_printf(MSG_MSGDUMP, "X509: altName - registeredID: %s", buf); 947 948 return 0; 949 } 950 951 952 static int x509_parse_ext_alt_name(struct x509_name *name, 953 const u8 *pos, size_t len) 954 { 955 struct asn1_hdr hdr; 956 const u8 *p, *end; 957 958 /* 959 * GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName 960 * 961 * GeneralName ::= CHOICE { 962 * otherName [0] OtherName, 963 * rfc822Name [1] IA5String, 964 * dNSName [2] IA5String, 965 * x400Address [3] ORAddress, 966 * directoryName [4] Name, 967 * ediPartyName [5] EDIPartyName, 968 * uniformResourceIdentifier [6] IA5String, 969 * iPAddress [7] OCTET STRING, 970 * registeredID [8] OBJECT IDENTIFIER } 971 * 972 * OtherName ::= SEQUENCE { 973 * type-id OBJECT IDENTIFIER, 974 * value [0] EXPLICIT ANY DEFINED BY type-id } 975 * 976 * EDIPartyName ::= SEQUENCE { 977 * nameAssigner [0] DirectoryString OPTIONAL, 978 * partyName [1] DirectoryString } 979 */ 980 981 for (p = pos, end = pos + len; p < end; p = hdr.payload + hdr.length) { 982 int res; 983 984 if (asn1_get_next(p, end - p, &hdr) < 0) { 985 wpa_printf(MSG_DEBUG, "X509: Failed to parse " 986 "SubjectAltName item"); 987 return -1; 988 } 989 990 if (hdr.class != ASN1_CLASS_CONTEXT_SPECIFIC) 991 continue; 992 993 switch (hdr.tag) { 994 case 1: 995 res = x509_parse_alt_name_rfc8222(name, hdr.payload, 996 hdr.length); 997 break; 998 case 2: 999 res = x509_parse_alt_name_dns(name, hdr.payload, 1000 hdr.length); 1001 break; 1002 case 6: 1003 res = x509_parse_alt_name_uri(name, hdr.payload, 1004 hdr.length); 1005 break; 1006 case 7: 1007 res = x509_parse_alt_name_ip(name, hdr.payload, 1008 hdr.length); 1009 break; 1010 case 8: 1011 res = x509_parse_alt_name_rid(name, hdr.payload, 1012 hdr.length); 1013 break; 1014 case 0: /* TODO: otherName */ 1015 case 3: /* TODO: x500Address */ 1016 case 4: /* TODO: directoryName */ 1017 case 5: /* TODO: ediPartyName */ 1018 default: 1019 res = 0; 1020 break; 1021 } 1022 if (res < 0) 1023 return res; 1024 } 1025 1026 return 0; 1027 } 1028 1029 1030 static int x509_parse_ext_subject_alt_name(struct x509_certificate *cert, 1031 const u8 *pos, size_t len) 1032 { 1033 struct asn1_hdr hdr; 1034 1035 /* SubjectAltName ::= GeneralNames */ 1036 1037 if (asn1_get_next(pos, len, &hdr) < 0 || 1038 hdr.class != ASN1_CLASS_UNIVERSAL || 1039 hdr.tag != ASN1_TAG_SEQUENCE) { 1040 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE in " 1041 "SubjectAltName; found %d tag 0x%x", 1042 hdr.class, hdr.tag); 1043 return -1; 1044 } 1045 1046 wpa_printf(MSG_DEBUG, "X509: SubjectAltName"); 1047 cert->extensions_present |= X509_EXT_SUBJECT_ALT_NAME; 1048 1049 if (hdr.length == 0) 1050 return 0; 1051 1052 return x509_parse_ext_alt_name(&cert->subject, hdr.payload, 1053 hdr.length); 1054 } 1055 1056 1057 static int x509_parse_ext_issuer_alt_name(struct x509_certificate *cert, 1058 const u8 *pos, size_t len) 1059 { 1060 struct asn1_hdr hdr; 1061 1062 /* IssuerAltName ::= GeneralNames */ 1063 1064 if (asn1_get_next(pos, len, &hdr) < 0 || 1065 hdr.class != ASN1_CLASS_UNIVERSAL || 1066 hdr.tag != ASN1_TAG_SEQUENCE) { 1067 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE in " 1068 "IssuerAltName; found %d tag 0x%x", 1069 hdr.class, hdr.tag); 1070 return -1; 1071 } 1072 1073 wpa_printf(MSG_DEBUG, "X509: IssuerAltName"); 1074 cert->extensions_present |= X509_EXT_ISSUER_ALT_NAME; 1075 1076 if (hdr.length == 0) 1077 return 0; 1078 1079 return x509_parse_ext_alt_name(&cert->issuer, hdr.payload, 1080 hdr.length); 1081 } 1082 1083 1084 static int x509_parse_extension_data(struct x509_certificate *cert, 1085 struct asn1_oid *oid, 1086 const u8 *pos, size_t len) 1087 { 1088 if (!x509_id_ce_oid(oid)) 1089 return 1; 1090 1091 /* TODO: add other extensions required by RFC 3280, Ch 4.2: 1092 * certificate policies (section 4.2.1.5) 1093 * name constraints (section 4.2.1.11) 1094 * policy constraints (section 4.2.1.12) 1095 * extended key usage (section 4.2.1.13) 1096 * inhibit any-policy (section 4.2.1.15) 1097 */ 1098 switch (oid->oid[3]) { 1099 case 15: /* id-ce-keyUsage */ 1100 return x509_parse_ext_key_usage(cert, pos, len); 1101 case 17: /* id-ce-subjectAltName */ 1102 return x509_parse_ext_subject_alt_name(cert, pos, len); 1103 case 18: /* id-ce-issuerAltName */ 1104 return x509_parse_ext_issuer_alt_name(cert, pos, len); 1105 case 19: /* id-ce-basicConstraints */ 1106 return x509_parse_ext_basic_constraints(cert, pos, len); 1107 default: 1108 return 1; 1109 } 1110 } 1111 1112 1113 static int x509_parse_extension(struct x509_certificate *cert, 1114 const u8 *pos, size_t len, const u8 **next) 1115 { 1116 const u8 *end; 1117 struct asn1_hdr hdr; 1118 struct asn1_oid oid; 1119 int critical_ext = 0, res; 1120 char buf[80]; 1121 1122 /* 1123 * Extension ::= SEQUENCE { 1124 * extnID OBJECT IDENTIFIER, 1125 * critical BOOLEAN DEFAULT FALSE, 1126 * extnValue OCTET STRING 1127 * } 1128 */ 1129 1130 if (asn1_get_next(pos, len, &hdr) < 0 || 1131 hdr.class != ASN1_CLASS_UNIVERSAL || 1132 hdr.tag != ASN1_TAG_SEQUENCE) { 1133 wpa_printf(MSG_DEBUG, "X509: Unexpected ASN.1 header in " 1134 "Extensions: class %d tag 0x%x; expected SEQUENCE", 1135 hdr.class, hdr.tag); 1136 return -1; 1137 } 1138 pos = hdr.payload; 1139 *next = end = pos + hdr.length; 1140 1141 if (asn1_get_oid(pos, end - pos, &oid, &pos) < 0) { 1142 wpa_printf(MSG_DEBUG, "X509: Unexpected ASN.1 data for " 1143 "Extension (expected OID)"); 1144 return -1; 1145 } 1146 1147 if (asn1_get_next(pos, end - pos, &hdr) < 0 || 1148 hdr.class != ASN1_CLASS_UNIVERSAL || 1149 (hdr.tag != ASN1_TAG_BOOLEAN && 1150 hdr.tag != ASN1_TAG_OCTETSTRING)) { 1151 wpa_printf(MSG_DEBUG, "X509: Unexpected ASN.1 header in " 1152 "Extensions: class %d tag 0x%x; expected BOOLEAN " 1153 "or OCTET STRING", hdr.class, hdr.tag); 1154 return -1; 1155 } 1156 1157 if (hdr.tag == ASN1_TAG_BOOLEAN) { 1158 if (hdr.length != 1) { 1159 wpa_printf(MSG_DEBUG, "X509: Unexpected " 1160 "Boolean length (%u)", hdr.length); 1161 return -1; 1162 } 1163 critical_ext = hdr.payload[0]; 1164 pos = hdr.payload; 1165 if (asn1_get_next(pos, end - pos, &hdr) < 0 || 1166 (hdr.class != ASN1_CLASS_UNIVERSAL && 1167 hdr.class != ASN1_CLASS_PRIVATE) || 1168 hdr.tag != ASN1_TAG_OCTETSTRING) { 1169 wpa_printf(MSG_DEBUG, "X509: Unexpected ASN.1 header " 1170 "in Extensions: class %d tag 0x%x; " 1171 "expected OCTET STRING", 1172 hdr.class, hdr.tag); 1173 return -1; 1174 } 1175 } 1176 1177 asn1_oid_to_str(&oid, buf, sizeof(buf)); 1178 wpa_printf(MSG_DEBUG, "X509: Extension: extnID=%s critical=%d", 1179 buf, critical_ext); 1180 wpa_hexdump(MSG_MSGDUMP, "X509: extnValue", hdr.payload, hdr.length); 1181 1182 res = x509_parse_extension_data(cert, &oid, hdr.payload, hdr.length); 1183 if (res < 0) 1184 return res; 1185 if (res == 1 && critical_ext) { 1186 wpa_printf(MSG_INFO, "X509: Unknown critical extension %s", 1187 buf); 1188 return -1; 1189 } 1190 1191 return 0; 1192 } 1193 1194 1195 static int x509_parse_extensions(struct x509_certificate *cert, 1196 const u8 *pos, size_t len) 1197 { 1198 const u8 *end; 1199 struct asn1_hdr hdr; 1200 1201 /* Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension */ 1202 1203 if (asn1_get_next(pos, len, &hdr) < 0 || 1204 hdr.class != ASN1_CLASS_UNIVERSAL || 1205 hdr.tag != ASN1_TAG_SEQUENCE) { 1206 wpa_printf(MSG_DEBUG, "X509: Unexpected ASN.1 data " 1207 "for Extensions: class %d tag 0x%x; " 1208 "expected SEQUENCE", hdr.class, hdr.tag); 1209 return -1; 1210 } 1211 1212 pos = hdr.payload; 1213 end = pos + hdr.length; 1214 1215 while (pos < end) { 1216 if (x509_parse_extension(cert, pos, end - pos, &pos) 1217 < 0) 1218 return -1; 1219 } 1220 1221 return 0; 1222 } 1223 1224 1225 static int x509_parse_tbs_certificate(const u8 *buf, size_t len, 1226 struct x509_certificate *cert, 1227 const u8 **next) 1228 { 1229 struct asn1_hdr hdr; 1230 const u8 *pos, *end; 1231 size_t left; 1232 char sbuf[128]; 1233 unsigned long value; 1234 1235 /* tbsCertificate TBSCertificate ::= SEQUENCE */ 1236 if (asn1_get_next(buf, len, &hdr) < 0 || 1237 hdr.class != ASN1_CLASS_UNIVERSAL || 1238 hdr.tag != ASN1_TAG_SEQUENCE) { 1239 wpa_printf(MSG_DEBUG, "X509: tbsCertificate did not start " 1240 "with a valid SEQUENCE - found class %d tag 0x%x", 1241 hdr.class, hdr.tag); 1242 return -1; 1243 } 1244 pos = hdr.payload; 1245 end = *next = pos + hdr.length; 1246 1247 /* 1248 * version [0] EXPLICIT Version DEFAULT v1 1249 * Version ::= INTEGER { v1(0), v2(1), v3(2) } 1250 */ 1251 if (asn1_get_next(pos, end - pos, &hdr) < 0) 1252 return -1; 1253 pos = hdr.payload; 1254 1255 if (hdr.class == ASN1_CLASS_CONTEXT_SPECIFIC) { 1256 if (asn1_get_next(pos, end - pos, &hdr) < 0) 1257 return -1; 1258 1259 if (hdr.class != ASN1_CLASS_UNIVERSAL || 1260 hdr.tag != ASN1_TAG_INTEGER) { 1261 wpa_printf(MSG_DEBUG, "X509: No INTEGER tag found for " 1262 "version field - found class %d tag 0x%x", 1263 hdr.class, hdr.tag); 1264 return -1; 1265 } 1266 if (hdr.length != 1) { 1267 wpa_printf(MSG_DEBUG, "X509: Unexpected version field " 1268 "length %u (expected 1)", hdr.length); 1269 return -1; 1270 } 1271 pos = hdr.payload; 1272 left = hdr.length; 1273 value = 0; 1274 while (left) { 1275 value <<= 8; 1276 value |= *pos++; 1277 left--; 1278 } 1279 1280 cert->version = value; 1281 if (cert->version != X509_CERT_V1 && 1282 cert->version != X509_CERT_V2 && 1283 cert->version != X509_CERT_V3) { 1284 wpa_printf(MSG_DEBUG, "X509: Unsupported version %d", 1285 cert->version + 1); 1286 return -1; 1287 } 1288 1289 if (asn1_get_next(pos, end - pos, &hdr) < 0) 1290 return -1; 1291 } else 1292 cert->version = X509_CERT_V1; 1293 wpa_printf(MSG_MSGDUMP, "X509: Version X.509v%d", cert->version + 1); 1294 1295 /* serialNumber CertificateSerialNumber ::= INTEGER */ 1296 if (hdr.class != ASN1_CLASS_UNIVERSAL || 1297 hdr.tag != ASN1_TAG_INTEGER) { 1298 wpa_printf(MSG_DEBUG, "X509: No INTEGER tag found for " 1299 "serialNumber; class=%d tag=0x%x", 1300 hdr.class, hdr.tag); 1301 return -1; 1302 } 1303 1304 pos = hdr.payload; 1305 left = hdr.length; 1306 while (left) { 1307 cert->serial_number <<= 8; 1308 cert->serial_number |= *pos++; 1309 left--; 1310 } 1311 wpa_printf(MSG_MSGDUMP, "X509: serialNumber %lu", cert->serial_number); 1312 1313 /* signature AlgorithmIdentifier */ 1314 if (x509_parse_algorithm_identifier(pos, end - pos, &cert->signature, 1315 &pos)) 1316 return -1; 1317 1318 /* issuer Name */ 1319 if (x509_parse_name(pos, end - pos, &cert->issuer, &pos)) 1320 return -1; 1321 x509_name_string(&cert->issuer, sbuf, sizeof(sbuf)); 1322 wpa_printf(MSG_MSGDUMP, "X509: issuer %s", sbuf); 1323 1324 /* validity Validity */ 1325 if (x509_parse_validity(pos, end - pos, cert, &pos)) 1326 return -1; 1327 1328 /* subject Name */ 1329 if (x509_parse_name(pos, end - pos, &cert->subject, &pos)) 1330 return -1; 1331 x509_name_string(&cert->subject, sbuf, sizeof(sbuf)); 1332 wpa_printf(MSG_MSGDUMP, "X509: subject %s", sbuf); 1333 1334 /* subjectPublicKeyInfo SubjectPublicKeyInfo */ 1335 if (x509_parse_public_key(pos, end - pos, cert, &pos)) 1336 return -1; 1337 1338 if (pos == end) 1339 return 0; 1340 1341 if (cert->version == X509_CERT_V1) 1342 return 0; 1343 1344 if (asn1_get_next(pos, end - pos, &hdr) < 0 || 1345 hdr.class != ASN1_CLASS_CONTEXT_SPECIFIC) { 1346 wpa_printf(MSG_DEBUG, "X509: Expected Context-Specific" 1347 " tag to parse optional tbsCertificate " 1348 "field(s); parsed class %d tag 0x%x", 1349 hdr.class, hdr.tag); 1350 return -1; 1351 } 1352 1353 if (hdr.tag == 1) { 1354 /* issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL */ 1355 wpa_printf(MSG_DEBUG, "X509: issuerUniqueID"); 1356 /* TODO: parse UniqueIdentifier ::= BIT STRING */ 1357 1358 if (hdr.payload + hdr.length == end) 1359 return 0; 1360 1361 if (asn1_get_next(pos, end - pos, &hdr) < 0 || 1362 hdr.class != ASN1_CLASS_CONTEXT_SPECIFIC) { 1363 wpa_printf(MSG_DEBUG, "X509: Expected Context-Specific" 1364 " tag to parse optional tbsCertificate " 1365 "field(s); parsed class %d tag 0x%x", 1366 hdr.class, hdr.tag); 1367 return -1; 1368 } 1369 } 1370 1371 if (hdr.tag == 2) { 1372 /* subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL */ 1373 wpa_printf(MSG_DEBUG, "X509: subjectUniqueID"); 1374 /* TODO: parse UniqueIdentifier ::= BIT STRING */ 1375 1376 if (hdr.payload + hdr.length == end) 1377 return 0; 1378 1379 if (asn1_get_next(pos, end - pos, &hdr) < 0 || 1380 hdr.class != ASN1_CLASS_CONTEXT_SPECIFIC) { 1381 wpa_printf(MSG_DEBUG, "X509: Expected Context-Specific" 1382 " tag to parse optional tbsCertificate " 1383 "field(s); parsed class %d tag 0x%x", 1384 hdr.class, hdr.tag); 1385 return -1; 1386 } 1387 } 1388 1389 if (hdr.tag != 3) { 1390 wpa_printf(MSG_DEBUG, "X509: Ignored unexpected " 1391 "Context-Specific tag %d in optional " 1392 "tbsCertificate fields", hdr.tag); 1393 return 0; 1394 } 1395 1396 /* extensions [3] EXPLICIT Extensions OPTIONAL */ 1397 1398 if (cert->version != X509_CERT_V3) { 1399 wpa_printf(MSG_DEBUG, "X509: X.509%d certificate and " 1400 "Extensions data which are only allowed for " 1401 "version 3", cert->version + 1); 1402 return -1; 1403 } 1404 1405 if (x509_parse_extensions(cert, hdr.payload, hdr.length) < 0) 1406 return -1; 1407 1408 pos = hdr.payload + hdr.length; 1409 if (pos < end) { 1410 wpa_hexdump(MSG_DEBUG, 1411 "X509: Ignored extra tbsCertificate data", 1412 pos, end - pos); 1413 } 1414 1415 return 0; 1416 } 1417 1418 1419 static int x509_rsadsi_oid(struct asn1_oid *oid) 1420 { 1421 return oid->len >= 4 && 1422 oid->oid[0] == 1 /* iso */ && 1423 oid->oid[1] == 2 /* member-body */ && 1424 oid->oid[2] == 840 /* us */ && 1425 oid->oid[3] == 113549 /* rsadsi */; 1426 } 1427 1428 1429 static int x509_pkcs_oid(struct asn1_oid *oid) 1430 { 1431 return oid->len >= 5 && 1432 x509_rsadsi_oid(oid) && 1433 oid->oid[4] == 1 /* pkcs */; 1434 } 1435 1436 1437 static int x509_digest_oid(struct asn1_oid *oid) 1438 { 1439 return oid->len >= 5 && 1440 x509_rsadsi_oid(oid) && 1441 oid->oid[4] == 2 /* digestAlgorithm */; 1442 } 1443 1444 1445 static int x509_sha1_oid(struct asn1_oid *oid) 1446 { 1447 return oid->len == 6 && 1448 oid->oid[0] == 1 /* iso */ && 1449 oid->oid[1] == 3 /* identified-organization */ && 1450 oid->oid[2] == 14 /* oiw */ && 1451 oid->oid[3] == 3 /* secsig */ && 1452 oid->oid[4] == 2 /* algorithms */ && 1453 oid->oid[5] == 26 /* id-sha1 */; 1454 } 1455 1456 1457 static int x509_sha256_oid(struct asn1_oid *oid) 1458 { 1459 return oid->len == 9 && 1460 oid->oid[0] == 2 /* joint-iso-itu-t */ && 1461 oid->oid[1] == 16 /* country */ && 1462 oid->oid[2] == 840 /* us */ && 1463 oid->oid[3] == 1 /* organization */ && 1464 oid->oid[4] == 101 /* gov */ && 1465 oid->oid[5] == 3 /* csor */ && 1466 oid->oid[6] == 4 /* nistAlgorithm */ && 1467 oid->oid[7] == 2 /* hashAlgs */ && 1468 oid->oid[8] == 1 /* sha256 */; 1469 } 1470 1471 1472 /** 1473 * x509_certificate_parse - Parse a X.509 certificate in DER format 1474 * @buf: Pointer to the X.509 certificate in DER format 1475 * @len: Buffer length 1476 * Returns: Pointer to the parsed certificate or %NULL on failure 1477 * 1478 * Caller is responsible for freeing the returned certificate by calling 1479 * x509_certificate_free(). 1480 */ 1481 struct x509_certificate * x509_certificate_parse(const u8 *buf, size_t len) 1482 { 1483 struct asn1_hdr hdr; 1484 const u8 *pos, *end, *hash_start; 1485 struct x509_certificate *cert; 1486 1487 cert = os_zalloc(sizeof(*cert) + len); 1488 if (cert == NULL) 1489 return NULL; 1490 os_memcpy(cert + 1, buf, len); 1491 cert->cert_start = (u8 *) (cert + 1); 1492 cert->cert_len = len; 1493 1494 pos = buf; 1495 end = buf + len; 1496 1497 /* RFC 3280 - X.509 v3 certificate / ASN.1 DER */ 1498 1499 /* Certificate ::= SEQUENCE */ 1500 if (asn1_get_next(pos, len, &hdr) < 0 || 1501 hdr.class != ASN1_CLASS_UNIVERSAL || 1502 hdr.tag != ASN1_TAG_SEQUENCE) { 1503 wpa_printf(MSG_DEBUG, "X509: Certificate did not start with " 1504 "a valid SEQUENCE - found class %d tag 0x%x", 1505 hdr.class, hdr.tag); 1506 x509_certificate_free(cert); 1507 return NULL; 1508 } 1509 pos = hdr.payload; 1510 1511 if (pos + hdr.length > end) { 1512 x509_certificate_free(cert); 1513 return NULL; 1514 } 1515 1516 if (pos + hdr.length < end) { 1517 wpa_hexdump(MSG_MSGDUMP, "X509: Ignoring extra data after DER " 1518 "encoded certificate", 1519 pos + hdr.length, end - pos + hdr.length); 1520 end = pos + hdr.length; 1521 } 1522 1523 hash_start = pos; 1524 cert->tbs_cert_start = cert->cert_start + (hash_start - buf); 1525 if (x509_parse_tbs_certificate(pos, end - pos, cert, &pos)) { 1526 x509_certificate_free(cert); 1527 return NULL; 1528 } 1529 cert->tbs_cert_len = pos - hash_start; 1530 1531 /* signatureAlgorithm AlgorithmIdentifier */ 1532 if (x509_parse_algorithm_identifier(pos, end - pos, 1533 &cert->signature_alg, &pos)) { 1534 x509_certificate_free(cert); 1535 return NULL; 1536 } 1537 1538 /* signatureValue BIT STRING */ 1539 if (asn1_get_next(pos, end - pos, &hdr) < 0 || 1540 hdr.class != ASN1_CLASS_UNIVERSAL || 1541 hdr.tag != ASN1_TAG_BITSTRING) { 1542 wpa_printf(MSG_DEBUG, "X509: Expected BITSTRING " 1543 "(signatureValue) - found class %d tag 0x%x", 1544 hdr.class, hdr.tag); 1545 x509_certificate_free(cert); 1546 return NULL; 1547 } 1548 if (hdr.length < 1) { 1549 x509_certificate_free(cert); 1550 return NULL; 1551 } 1552 pos = hdr.payload; 1553 if (*pos) { 1554 wpa_printf(MSG_DEBUG, "X509: BITSTRING - %d unused bits", 1555 *pos); 1556 /* PKCS #1 v1.5 10.2.1: 1557 * It is an error if the length in bits of the signature S is 1558 * not a multiple of eight. 1559 */ 1560 x509_certificate_free(cert); 1561 return NULL; 1562 } 1563 os_free(cert->sign_value); 1564 cert->sign_value = os_malloc(hdr.length - 1); 1565 if (cert->sign_value == NULL) { 1566 wpa_printf(MSG_DEBUG, "X509: Failed to allocate memory for " 1567 "signatureValue"); 1568 x509_certificate_free(cert); 1569 return NULL; 1570 } 1571 os_memcpy(cert->sign_value, pos + 1, hdr.length - 1); 1572 cert->sign_value_len = hdr.length - 1; 1573 wpa_hexdump(MSG_MSGDUMP, "X509: signature", 1574 cert->sign_value, cert->sign_value_len); 1575 1576 return cert; 1577 } 1578 1579 1580 /** 1581 * x509_certificate_check_signature - Verify certificate signature 1582 * @issuer: Issuer certificate 1583 * @cert: Certificate to be verified 1584 * Returns: 0 if cert has a valid signature that was signed by the issuer, 1585 * -1 if not 1586 */ 1587 int x509_certificate_check_signature(struct x509_certificate *issuer, 1588 struct x509_certificate *cert) 1589 { 1590 struct crypto_public_key *pk; 1591 u8 *data; 1592 const u8 *pos, *end, *next, *da_end; 1593 size_t data_len; 1594 struct asn1_hdr hdr; 1595 struct asn1_oid oid; 1596 u8 hash[32]; 1597 size_t hash_len; 1598 1599 if (!x509_pkcs_oid(&cert->signature.oid) || 1600 cert->signature.oid.len != 7 || 1601 cert->signature.oid.oid[5] != 1 /* pkcs-1 */) { 1602 wpa_printf(MSG_DEBUG, "X509: Unrecognized signature " 1603 "algorithm"); 1604 return -1; 1605 } 1606 1607 pk = crypto_public_key_import(issuer->public_key, 1608 issuer->public_key_len); 1609 if (pk == NULL) 1610 return -1; 1611 1612 data_len = cert->sign_value_len; 1613 data = os_malloc(data_len); 1614 if (data == NULL) { 1615 crypto_public_key_free(pk); 1616 return -1; 1617 } 1618 1619 if (crypto_public_key_decrypt_pkcs1(pk, cert->sign_value, 1620 cert->sign_value_len, data, 1621 &data_len) < 0) { 1622 wpa_printf(MSG_DEBUG, "X509: Failed to decrypt signature"); 1623 crypto_public_key_free(pk); 1624 os_free(data); 1625 return -1; 1626 } 1627 crypto_public_key_free(pk); 1628 1629 wpa_hexdump(MSG_MSGDUMP, "X509: Signature data D", data, data_len); 1630 1631 /* 1632 * PKCS #1 v1.5, 10.1.2: 1633 * 1634 * DigestInfo ::= SEQUENCE { 1635 * digestAlgorithm DigestAlgorithmIdentifier, 1636 * digest Digest 1637 * } 1638 * 1639 * DigestAlgorithmIdentifier ::= AlgorithmIdentifier 1640 * 1641 * Digest ::= OCTET STRING 1642 * 1643 */ 1644 if (asn1_get_next(data, data_len, &hdr) < 0 || 1645 hdr.class != ASN1_CLASS_UNIVERSAL || 1646 hdr.tag != ASN1_TAG_SEQUENCE) { 1647 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE " 1648 "(DigestInfo) - found class %d tag 0x%x", 1649 hdr.class, hdr.tag); 1650 os_free(data); 1651 return -1; 1652 } 1653 1654 pos = hdr.payload; 1655 end = pos + hdr.length; 1656 1657 /* 1658 * X.509: 1659 * AlgorithmIdentifier ::= SEQUENCE { 1660 * algorithm OBJECT IDENTIFIER, 1661 * parameters ANY DEFINED BY algorithm OPTIONAL 1662 * } 1663 */ 1664 1665 if (asn1_get_next(pos, end - pos, &hdr) < 0 || 1666 hdr.class != ASN1_CLASS_UNIVERSAL || 1667 hdr.tag != ASN1_TAG_SEQUENCE) { 1668 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE " 1669 "(AlgorithmIdentifier) - found class %d tag 0x%x", 1670 hdr.class, hdr.tag); 1671 os_free(data); 1672 return -1; 1673 } 1674 da_end = hdr.payload + hdr.length; 1675 1676 if (asn1_get_oid(hdr.payload, hdr.length, &oid, &next)) { 1677 wpa_printf(MSG_DEBUG, "X509: Failed to parse digestAlgorithm"); 1678 os_free(data); 1679 return -1; 1680 } 1681 1682 if (x509_sha1_oid(&oid)) { 1683 if (cert->signature.oid.oid[6] != 1684 5 /* sha-1WithRSAEncryption */) { 1685 wpa_printf(MSG_DEBUG, "X509: digestAlgorithm SHA1 " 1686 "does not match with certificate " 1687 "signatureAlgorithm (%lu)", 1688 cert->signature.oid.oid[6]); 1689 os_free(data); 1690 return -1; 1691 } 1692 goto skip_digest_oid; 1693 } 1694 1695 if (x509_sha256_oid(&oid)) { 1696 if (cert->signature.oid.oid[6] != 1697 11 /* sha2561WithRSAEncryption */) { 1698 wpa_printf(MSG_DEBUG, "X509: digestAlgorithm SHA256 " 1699 "does not match with certificate " 1700 "signatureAlgorithm (%lu)", 1701 cert->signature.oid.oid[6]); 1702 os_free(data); 1703 return -1; 1704 } 1705 goto skip_digest_oid; 1706 } 1707 1708 if (!x509_digest_oid(&oid)) { 1709 wpa_printf(MSG_DEBUG, "X509: Unrecognized digestAlgorithm"); 1710 os_free(data); 1711 return -1; 1712 } 1713 switch (oid.oid[5]) { 1714 case 5: /* md5 */ 1715 if (cert->signature.oid.oid[6] != 4 /* md5WithRSAEncryption */) 1716 { 1717 wpa_printf(MSG_DEBUG, "X509: digestAlgorithm MD5 does " 1718 "not match with certificate " 1719 "signatureAlgorithm (%lu)", 1720 cert->signature.oid.oid[6]); 1721 os_free(data); 1722 return -1; 1723 } 1724 break; 1725 case 2: /* md2 */ 1726 case 4: /* md4 */ 1727 default: 1728 wpa_printf(MSG_DEBUG, "X509: Unsupported digestAlgorithm " 1729 "(%lu)", oid.oid[5]); 1730 os_free(data); 1731 return -1; 1732 } 1733 1734 skip_digest_oid: 1735 /* Digest ::= OCTET STRING */ 1736 pos = da_end; 1737 end = data + data_len; 1738 1739 if (asn1_get_next(pos, end - pos, &hdr) < 0 || 1740 hdr.class != ASN1_CLASS_UNIVERSAL || 1741 hdr.tag != ASN1_TAG_OCTETSTRING) { 1742 wpa_printf(MSG_DEBUG, "X509: Expected OCTETSTRING " 1743 "(Digest) - found class %d tag 0x%x", 1744 hdr.class, hdr.tag); 1745 os_free(data); 1746 return -1; 1747 } 1748 wpa_hexdump(MSG_MSGDUMP, "X509: Decrypted Digest", 1749 hdr.payload, hdr.length); 1750 1751 switch (cert->signature.oid.oid[6]) { 1752 case 4: /* md5WithRSAEncryption */ 1753 md5_vector(1, &cert->tbs_cert_start, &cert->tbs_cert_len, 1754 hash); 1755 hash_len = 16; 1756 wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (MD5)", 1757 hash, hash_len); 1758 break; 1759 case 5: /* sha-1WithRSAEncryption */ 1760 sha1_vector(1, &cert->tbs_cert_start, &cert->tbs_cert_len, 1761 hash); 1762 hash_len = 20; 1763 wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (SHA1)", 1764 hash, hash_len); 1765 break; 1766 case 11: /* sha256WithRSAEncryption */ 1767 sha256_vector(1, &cert->tbs_cert_start, &cert->tbs_cert_len, 1768 hash); 1769 hash_len = 32; 1770 wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (SHA256)", 1771 hash, hash_len); 1772 break; 1773 case 2: /* md2WithRSAEncryption */ 1774 case 12: /* sha384WithRSAEncryption */ 1775 case 13: /* sha512WithRSAEncryption */ 1776 default: 1777 wpa_printf(MSG_INFO, "X509: Unsupported certificate signature " 1778 "algorithm (%lu)", cert->signature.oid.oid[6]); 1779 os_free(data); 1780 return -1; 1781 } 1782 1783 if (hdr.length != hash_len || 1784 os_memcmp(hdr.payload, hash, hdr.length) != 0) { 1785 wpa_printf(MSG_INFO, "X509: Certificate Digest does not match " 1786 "with calculated tbsCertificate hash"); 1787 os_free(data); 1788 return -1; 1789 } 1790 1791 os_free(data); 1792 1793 wpa_printf(MSG_DEBUG, "X509: Certificate Digest matches with " 1794 "calculated tbsCertificate hash"); 1795 1796 return 0; 1797 } 1798 1799 1800 static int x509_valid_issuer(const struct x509_certificate *cert) 1801 { 1802 if ((cert->extensions_present & X509_EXT_BASIC_CONSTRAINTS) && 1803 !cert->ca) { 1804 wpa_printf(MSG_DEBUG, "X509: Non-CA certificate used as an " 1805 "issuer"); 1806 return -1; 1807 } 1808 1809 if (cert->version == X509_CERT_V3 && 1810 !(cert->extensions_present & X509_EXT_BASIC_CONSTRAINTS)) { 1811 wpa_printf(MSG_DEBUG, "X509: v3 CA certificate did not " 1812 "include BasicConstraints extension"); 1813 return -1; 1814 } 1815 1816 if ((cert->extensions_present & X509_EXT_KEY_USAGE) && 1817 !(cert->key_usage & X509_KEY_USAGE_KEY_CERT_SIGN)) { 1818 wpa_printf(MSG_DEBUG, "X509: Issuer certificate did not have " 1819 "keyCertSign bit in Key Usage"); 1820 return -1; 1821 } 1822 1823 return 0; 1824 } 1825 1826 1827 /** 1828 * x509_certificate_chain_validate - Validate X.509 certificate chain 1829 * @trusted: List of trusted certificates 1830 * @chain: Certificate chain to be validated (first chain must be issued by 1831 * signed by the second certificate in the chain and so on) 1832 * @reason: Buffer for returning failure reason (X509_VALIDATE_*) 1833 * Returns: 0 if chain is valid, -1 if not 1834 */ 1835 int x509_certificate_chain_validate(struct x509_certificate *trusted, 1836 struct x509_certificate *chain, 1837 int *reason) 1838 { 1839 long unsigned idx; 1840 int chain_trusted = 0; 1841 struct x509_certificate *cert, *trust; 1842 char buf[128]; 1843 struct os_time now; 1844 1845 *reason = X509_VALIDATE_OK; 1846 1847 wpa_printf(MSG_DEBUG, "X509: Validate certificate chain"); 1848 os_get_time(&now); 1849 1850 for (cert = chain, idx = 0; cert; cert = cert->next, idx++) { 1851 x509_name_string(&cert->subject, buf, sizeof(buf)); 1852 wpa_printf(MSG_DEBUG, "X509: %lu: %s", idx, buf); 1853 1854 if (chain_trusted) 1855 continue; 1856 1857 if ((unsigned long) now.sec < 1858 (unsigned long) cert->not_before || 1859 (unsigned long) now.sec > 1860 (unsigned long) cert->not_after) { 1861 wpa_printf(MSG_INFO, "X509: Certificate not valid " 1862 "(now=%lu not_before=%lu not_after=%lu)", 1863 now.sec, cert->not_before, cert->not_after); 1864 *reason = X509_VALIDATE_CERTIFICATE_EXPIRED; 1865 return -1; 1866 } 1867 1868 if (cert->next) { 1869 if (x509_name_compare(&cert->issuer, 1870 &cert->next->subject) != 0) { 1871 wpa_printf(MSG_DEBUG, "X509: Certificate " 1872 "chain issuer name mismatch"); 1873 x509_name_string(&cert->issuer, buf, 1874 sizeof(buf)); 1875 wpa_printf(MSG_DEBUG, "X509: cert issuer: %s", 1876 buf); 1877 x509_name_string(&cert->next->subject, buf, 1878 sizeof(buf)); 1879 wpa_printf(MSG_DEBUG, "X509: next cert " 1880 "subject: %s", buf); 1881 *reason = X509_VALIDATE_CERTIFICATE_UNKNOWN; 1882 return -1; 1883 } 1884 1885 if (x509_valid_issuer(cert->next) < 0) { 1886 *reason = X509_VALIDATE_BAD_CERTIFICATE; 1887 return -1; 1888 } 1889 1890 if ((cert->next->extensions_present & 1891 X509_EXT_PATH_LEN_CONSTRAINT) && 1892 idx > cert->next->path_len_constraint) { 1893 wpa_printf(MSG_DEBUG, "X509: pathLenConstraint" 1894 " not met (idx=%lu issuer " 1895 "pathLenConstraint=%lu)", idx, 1896 cert->next->path_len_constraint); 1897 *reason = X509_VALIDATE_BAD_CERTIFICATE; 1898 return -1; 1899 } 1900 1901 if (x509_certificate_check_signature(cert->next, cert) 1902 < 0) { 1903 wpa_printf(MSG_DEBUG, "X509: Invalid " 1904 "certificate signature within " 1905 "chain"); 1906 *reason = X509_VALIDATE_BAD_CERTIFICATE; 1907 return -1; 1908 } 1909 } 1910 1911 for (trust = trusted; trust; trust = trust->next) { 1912 if (x509_name_compare(&cert->issuer, &trust->subject) 1913 == 0) 1914 break; 1915 } 1916 1917 if (trust) { 1918 wpa_printf(MSG_DEBUG, "X509: Found issuer from the " 1919 "list of trusted certificates"); 1920 if (x509_valid_issuer(trust) < 0) { 1921 *reason = X509_VALIDATE_BAD_CERTIFICATE; 1922 return -1; 1923 } 1924 1925 if (x509_certificate_check_signature(trust, cert) < 0) 1926 { 1927 wpa_printf(MSG_DEBUG, "X509: Invalid " 1928 "certificate signature"); 1929 *reason = X509_VALIDATE_BAD_CERTIFICATE; 1930 return -1; 1931 } 1932 1933 wpa_printf(MSG_DEBUG, "X509: Trusted certificate " 1934 "found to complete the chain"); 1935 chain_trusted = 1; 1936 } 1937 } 1938 1939 if (!chain_trusted) { 1940 wpa_printf(MSG_DEBUG, "X509: Did not find any of the issuers " 1941 "from the list of trusted certificates"); 1942 if (trusted) { 1943 *reason = X509_VALIDATE_UNKNOWN_CA; 1944 return -1; 1945 } 1946 wpa_printf(MSG_DEBUG, "X509: Certificate chain validation " 1947 "disabled - ignore unknown CA issue"); 1948 } 1949 1950 wpa_printf(MSG_DEBUG, "X509: Certificate chain valid"); 1951 1952 return 0; 1953 } 1954 1955 1956 /** 1957 * x509_certificate_get_subject - Get a certificate based on Subject name 1958 * @chain: Certificate chain to search through 1959 * @name: Subject name to search for 1960 * Returns: Pointer to the certificate with the given Subject name or 1961 * %NULL on failure 1962 */ 1963 struct x509_certificate * 1964 x509_certificate_get_subject(struct x509_certificate *chain, 1965 struct x509_name *name) 1966 { 1967 struct x509_certificate *cert; 1968 1969 for (cert = chain; cert; cert = cert->next) { 1970 if (x509_name_compare(&cert->subject, name) == 0) 1971 return cert; 1972 } 1973 return NULL; 1974 } 1975 1976 1977 /** 1978 * x509_certificate_self_signed - Is the certificate self-signed? 1979 * @cert: Certificate 1980 * Returns: 1 if certificate is self-signed, 0 if not 1981 */ 1982 int x509_certificate_self_signed(struct x509_certificate *cert) 1983 { 1984 return x509_name_compare(&cert->issuer, &cert->subject) == 0; 1985 } 1986