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