1 /* 2 * X.509v3 certificate parsing and processing (RFC 3280 profile) 3 * Copyright (c) 2006-2015, Jouni Malinen <j@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_malloc(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 os_memcpy(cert->public_key, pos + 1, hdr.length - 1); 284 cert->public_key_len = hdr.length - 1; 285 wpa_hexdump(MSG_MSGDUMP, "X509: subjectPublicKey", 286 cert->public_key, cert->public_key_len); 287 288 return 0; 289 } 290 291 292 int x509_parse_name(const u8 *buf, size_t len, struct x509_name *name, 293 const u8 **next) 294 { 295 struct asn1_hdr hdr; 296 const u8 *pos, *end, *set_pos, *set_end, *seq_pos, *seq_end; 297 struct asn1_oid oid; 298 char *val; 299 300 /* 301 * Name ::= CHOICE { RDNSequence } 302 * RDNSequence ::= SEQUENCE OF RelativeDistinguishedName 303 * RelativeDistinguishedName ::= SET OF AttributeTypeAndValue 304 * AttributeTypeAndValue ::= SEQUENCE { 305 * type AttributeType, 306 * value AttributeValue 307 * } 308 * AttributeType ::= OBJECT IDENTIFIER 309 * AttributeValue ::= ANY DEFINED BY AttributeType 310 */ 311 312 if (asn1_get_next(buf, len, &hdr) < 0 || 313 hdr.class != ASN1_CLASS_UNIVERSAL || 314 hdr.tag != ASN1_TAG_SEQUENCE) { 315 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE " 316 "(Name / RDNSequencer) - found class %d tag 0x%x", 317 hdr.class, hdr.tag); 318 return -1; 319 } 320 pos = hdr.payload; 321 322 if (hdr.length > buf + len - pos) 323 return -1; 324 325 end = *next = pos + hdr.length; 326 327 while (pos < end) { 328 enum x509_name_attr_type type; 329 330 if (asn1_get_next(pos, end - pos, &hdr) < 0 || 331 hdr.class != ASN1_CLASS_UNIVERSAL || 332 hdr.tag != ASN1_TAG_SET) { 333 wpa_printf(MSG_DEBUG, "X509: Expected SET " 334 "(RelativeDistinguishedName) - found class " 335 "%d tag 0x%x", hdr.class, hdr.tag); 336 x509_free_name(name); 337 return -1; 338 } 339 340 set_pos = hdr.payload; 341 pos = set_end = hdr.payload + hdr.length; 342 343 if (asn1_get_next(set_pos, set_end - set_pos, &hdr) < 0 || 344 hdr.class != ASN1_CLASS_UNIVERSAL || 345 hdr.tag != ASN1_TAG_SEQUENCE) { 346 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE " 347 "(AttributeTypeAndValue) - found class %d " 348 "tag 0x%x", hdr.class, hdr.tag); 349 x509_free_name(name); 350 return -1; 351 } 352 353 seq_pos = hdr.payload; 354 seq_end = hdr.payload + hdr.length; 355 356 if (asn1_get_oid(seq_pos, seq_end - seq_pos, &oid, &seq_pos)) { 357 x509_free_name(name); 358 return -1; 359 } 360 361 if (asn1_get_next(seq_pos, seq_end - seq_pos, &hdr) < 0 || 362 hdr.class != ASN1_CLASS_UNIVERSAL) { 363 wpa_printf(MSG_DEBUG, "X509: Failed to parse " 364 "AttributeValue"); 365 x509_free_name(name); 366 return -1; 367 } 368 369 /* RFC 3280: 370 * MUST: country, organization, organizational-unit, 371 * distinguished name qualifier, state or province name, 372 * common name, serial number. 373 * SHOULD: locality, title, surname, given name, initials, 374 * pseudonym, generation qualifier. 375 * MUST: domainComponent (RFC 2247). 376 */ 377 type = X509_NAME_ATTR_NOT_USED; 378 if (oid.len == 4 && 379 oid.oid[0] == 2 && oid.oid[1] == 5 && oid.oid[2] == 4) { 380 /* id-at ::= 2.5.4 */ 381 switch (oid.oid[3]) { 382 case 3: 383 /* commonName */ 384 type = X509_NAME_ATTR_CN; 385 break; 386 case 6: 387 /* countryName */ 388 type = X509_NAME_ATTR_C; 389 break; 390 case 7: 391 /* localityName */ 392 type = X509_NAME_ATTR_L; 393 break; 394 case 8: 395 /* stateOrProvinceName */ 396 type = X509_NAME_ATTR_ST; 397 break; 398 case 10: 399 /* organizationName */ 400 type = X509_NAME_ATTR_O; 401 break; 402 case 11: 403 /* organizationalUnitName */ 404 type = X509_NAME_ATTR_OU; 405 break; 406 } 407 } else if (oid.len == 7 && 408 oid.oid[0] == 1 && oid.oid[1] == 2 && 409 oid.oid[2] == 840 && oid.oid[3] == 113549 && 410 oid.oid[4] == 1 && oid.oid[5] == 9 && 411 oid.oid[6] == 1) { 412 /* 1.2.840.113549.1.9.1 - e-mailAddress */ 413 os_free(name->email); 414 name->email = os_malloc(hdr.length + 1); 415 if (name->email == NULL) { 416 x509_free_name(name); 417 return -1; 418 } 419 os_memcpy(name->email, hdr.payload, hdr.length); 420 name->email[hdr.length] = '\0'; 421 continue; 422 } else if (oid.len == 7 && 423 oid.oid[0] == 0 && oid.oid[1] == 9 && 424 oid.oid[2] == 2342 && oid.oid[3] == 19200300 && 425 oid.oid[4] == 100 && oid.oid[5] == 1 && 426 oid.oid[6] == 25) { 427 /* 0.9.2342.19200300.100.1.25 - domainComponent */ 428 type = X509_NAME_ATTR_DC; 429 } 430 431 if (type == X509_NAME_ATTR_NOT_USED) { 432 wpa_hexdump(MSG_DEBUG, "X509: Unrecognized OID", 433 (u8 *) oid.oid, 434 oid.len * sizeof(oid.oid[0])); 435 wpa_hexdump_ascii(MSG_MSGDUMP, "X509: Attribute Data", 436 hdr.payload, hdr.length); 437 continue; 438 } 439 440 if (name->num_attr == X509_MAX_NAME_ATTRIBUTES) { 441 wpa_printf(MSG_INFO, "X509: Too many Name attributes"); 442 x509_free_name(name); 443 return -1; 444 } 445 446 val = dup_binstr(hdr.payload, hdr.length); 447 if (val == NULL) { 448 x509_free_name(name); 449 return -1; 450 } 451 if (os_strlen(val) != hdr.length) { 452 wpa_printf(MSG_INFO, "X509: Reject certificate with " 453 "embedded NUL byte in a string (%s[NUL])", 454 val); 455 os_free(val); 456 x509_free_name(name); 457 return -1; 458 } 459 460 name->attr[name->num_attr].type = type; 461 name->attr[name->num_attr].value = val; 462 name->num_attr++; 463 } 464 465 return 0; 466 } 467 468 469 static char * x509_name_attr_str(enum x509_name_attr_type type) 470 { 471 switch (type) { 472 case X509_NAME_ATTR_NOT_USED: 473 return "[N/A]"; 474 case X509_NAME_ATTR_DC: 475 return "DC"; 476 case X509_NAME_ATTR_CN: 477 return "CN"; 478 case X509_NAME_ATTR_C: 479 return "C"; 480 case X509_NAME_ATTR_L: 481 return "L"; 482 case X509_NAME_ATTR_ST: 483 return "ST"; 484 case X509_NAME_ATTR_O: 485 return "O"; 486 case X509_NAME_ATTR_OU: 487 return "OU"; 488 } 489 return "?"; 490 } 491 492 493 /** 494 * x509_name_string - Convert an X.509 certificate name into a string 495 * @name: Name to convert 496 * @buf: Buffer for the string 497 * @len: Maximum buffer length 498 */ 499 void x509_name_string(struct x509_name *name, char *buf, size_t len) 500 { 501 char *pos, *end; 502 int ret; 503 size_t i; 504 505 if (len == 0) 506 return; 507 508 pos = buf; 509 end = buf + len; 510 511 for (i = 0; i < name->num_attr; i++) { 512 ret = os_snprintf(pos, end - pos, "%s=%s, ", 513 x509_name_attr_str(name->attr[i].type), 514 name->attr[i].value); 515 if (os_snprintf_error(end - pos, ret)) 516 goto done; 517 pos += ret; 518 } 519 520 if (pos > buf + 1 && pos[-1] == ' ' && pos[-2] == ',') { 521 pos--; 522 *pos = '\0'; 523 pos--; 524 *pos = '\0'; 525 } 526 527 if (name->email) { 528 ret = os_snprintf(pos, end - pos, "/emailAddress=%s", 529 name->email); 530 if (os_snprintf_error(end - pos, ret)) 531 goto done; 532 pos += ret; 533 } 534 535 done: 536 end[-1] = '\0'; 537 } 538 539 540 int x509_parse_time(const u8 *buf, size_t len, u8 asn1_tag, os_time_t *val) 541 { 542 const char *pos; 543 int year, month, day, hour, min, sec; 544 545 /* 546 * Time ::= CHOICE { 547 * utcTime UTCTime, 548 * generalTime GeneralizedTime 549 * } 550 * 551 * UTCTime: YYMMDDHHMMSSZ 552 * GeneralizedTime: YYYYMMDDHHMMSSZ 553 */ 554 555 pos = (const char *) buf; 556 557 switch (asn1_tag) { 558 case ASN1_TAG_UTCTIME: 559 if (len != 13 || buf[12] != 'Z') { 560 wpa_hexdump_ascii(MSG_DEBUG, "X509: Unrecognized " 561 "UTCTime format", buf, len); 562 return -1; 563 } 564 if (sscanf(pos, "%02d", &year) != 1) { 565 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse " 566 "UTCTime year", buf, len); 567 return -1; 568 } 569 if (year < 50) 570 year += 2000; 571 else 572 year += 1900; 573 pos += 2; 574 break; 575 case ASN1_TAG_GENERALIZEDTIME: 576 if (len != 15 || buf[14] != 'Z') { 577 wpa_hexdump_ascii(MSG_DEBUG, "X509: Unrecognized " 578 "GeneralizedTime format", buf, len); 579 return -1; 580 } 581 if (sscanf(pos, "%04d", &year) != 1) { 582 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse " 583 "GeneralizedTime year", buf, len); 584 return -1; 585 } 586 pos += 4; 587 break; 588 default: 589 wpa_printf(MSG_DEBUG, "X509: Expected UTCTime or " 590 "GeneralizedTime - found tag 0x%x", asn1_tag); 591 return -1; 592 } 593 594 if (sscanf(pos, "%02d", &month) != 1) { 595 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time " 596 "(month)", buf, len); 597 return -1; 598 } 599 pos += 2; 600 601 if (sscanf(pos, "%02d", &day) != 1) { 602 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time " 603 "(day)", buf, len); 604 return -1; 605 } 606 pos += 2; 607 608 if (sscanf(pos, "%02d", &hour) != 1) { 609 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time " 610 "(hour)", buf, len); 611 return -1; 612 } 613 pos += 2; 614 615 if (sscanf(pos, "%02d", &min) != 1) { 616 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time " 617 "(min)", buf, len); 618 return -1; 619 } 620 pos += 2; 621 622 if (sscanf(pos, "%02d", &sec) != 1) { 623 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse Time " 624 "(sec)", buf, len); 625 return -1; 626 } 627 628 if (os_mktime(year, month, day, hour, min, sec, val) < 0) { 629 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to convert Time", 630 buf, len); 631 if (year < 1970) { 632 /* 633 * At least some test certificates have been configured 634 * to use dates prior to 1970. Set the date to 635 * beginning of 1970 to handle these case. 636 */ 637 wpa_printf(MSG_DEBUG, "X509: Year=%d before epoch - " 638 "assume epoch as the time", year); 639 *val = 0; 640 return 0; 641 } 642 return -1; 643 } 644 645 return 0; 646 } 647 648 649 static int x509_parse_validity(const u8 *buf, size_t len, 650 struct x509_certificate *cert, const u8 **next) 651 { 652 struct asn1_hdr hdr; 653 const u8 *pos; 654 size_t plen; 655 656 /* 657 * Validity ::= SEQUENCE { 658 * notBefore Time, 659 * notAfter Time 660 * } 661 * 662 * RFC 3280, 4.1.2.5: 663 * CAs conforming to this profile MUST always encode certificate 664 * validity dates through the year 2049 as UTCTime; certificate 665 * validity dates in 2050 or later MUST be encoded as GeneralizedTime. 666 */ 667 668 if (asn1_get_next(buf, len, &hdr) < 0 || 669 hdr.class != ASN1_CLASS_UNIVERSAL || 670 hdr.tag != ASN1_TAG_SEQUENCE) { 671 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE " 672 "(Validity) - found class %d tag 0x%x", 673 hdr.class, hdr.tag); 674 return -1; 675 } 676 pos = hdr.payload; 677 plen = hdr.length; 678 679 if (plen > (size_t) (buf + len - pos)) 680 return -1; 681 682 *next = pos + plen; 683 684 if (asn1_get_next(pos, plen, &hdr) < 0 || 685 hdr.class != ASN1_CLASS_UNIVERSAL || 686 x509_parse_time(hdr.payload, hdr.length, hdr.tag, 687 &cert->not_before) < 0) { 688 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse notBefore " 689 "Time", hdr.payload, hdr.length); 690 return -1; 691 } 692 693 pos = hdr.payload + hdr.length; 694 plen = *next - pos; 695 696 if (asn1_get_next(pos, plen, &hdr) < 0 || 697 hdr.class != ASN1_CLASS_UNIVERSAL || 698 x509_parse_time(hdr.payload, hdr.length, hdr.tag, 699 &cert->not_after) < 0) { 700 wpa_hexdump_ascii(MSG_DEBUG, "X509: Failed to parse notAfter " 701 "Time", hdr.payload, hdr.length); 702 return -1; 703 } 704 705 wpa_printf(MSG_MSGDUMP, "X509: Validity: notBefore: %lu notAfter: %lu", 706 (unsigned long) cert->not_before, 707 (unsigned long) cert->not_after); 708 709 return 0; 710 } 711 712 713 static int x509_id_ce_oid(struct asn1_oid *oid) 714 { 715 /* id-ce arc from X.509 for standard X.509v3 extensions */ 716 return oid->len >= 4 && 717 oid->oid[0] == 2 /* joint-iso-ccitt */ && 718 oid->oid[1] == 5 /* ds */ && 719 oid->oid[2] == 29 /* id-ce */; 720 } 721 722 723 static int x509_any_ext_key_usage_oid(struct asn1_oid *oid) 724 { 725 return oid->len == 6 && 726 x509_id_ce_oid(oid) && 727 oid->oid[3] == 37 /* extKeyUsage */ && 728 oid->oid[4] == 0 /* anyExtendedKeyUsage */; 729 } 730 731 732 static int x509_parse_ext_key_usage(struct x509_certificate *cert, 733 const u8 *pos, size_t len) 734 { 735 struct asn1_hdr hdr; 736 737 /* 738 * KeyUsage ::= BIT STRING { 739 * digitalSignature (0), 740 * nonRepudiation (1), 741 * keyEncipherment (2), 742 * dataEncipherment (3), 743 * keyAgreement (4), 744 * keyCertSign (5), 745 * cRLSign (6), 746 * encipherOnly (7), 747 * decipherOnly (8) } 748 */ 749 750 if (asn1_get_next(pos, len, &hdr) < 0 || 751 hdr.class != ASN1_CLASS_UNIVERSAL || 752 hdr.tag != ASN1_TAG_BITSTRING || 753 hdr.length < 1) { 754 wpa_printf(MSG_DEBUG, "X509: Expected BIT STRING in " 755 "KeyUsage; found %d tag 0x%x len %d", 756 hdr.class, hdr.tag, hdr.length); 757 return -1; 758 } 759 760 cert->extensions_present |= X509_EXT_KEY_USAGE; 761 cert->key_usage = asn1_bit_string_to_long(hdr.payload, hdr.length); 762 763 wpa_printf(MSG_DEBUG, "X509: KeyUsage 0x%lx", cert->key_usage); 764 765 return 0; 766 } 767 768 769 static int x509_parse_ext_basic_constraints(struct x509_certificate *cert, 770 const u8 *pos, size_t len) 771 { 772 struct asn1_hdr hdr; 773 unsigned long value; 774 size_t left; 775 776 /* 777 * BasicConstraints ::= SEQUENCE { 778 * cA BOOLEAN DEFAULT FALSE, 779 * pathLenConstraint INTEGER (0..MAX) OPTIONAL } 780 */ 781 782 if (asn1_get_next(pos, len, &hdr) < 0 || 783 hdr.class != ASN1_CLASS_UNIVERSAL || 784 hdr.tag != ASN1_TAG_SEQUENCE) { 785 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE in " 786 "BasicConstraints; found %d tag 0x%x", 787 hdr.class, hdr.tag); 788 return -1; 789 } 790 791 cert->extensions_present |= X509_EXT_BASIC_CONSTRAINTS; 792 793 if (hdr.length == 0) 794 return 0; 795 796 if (asn1_get_next(hdr.payload, hdr.length, &hdr) < 0 || 797 hdr.class != ASN1_CLASS_UNIVERSAL) { 798 wpa_printf(MSG_DEBUG, "X509: Failed to parse " 799 "BasicConstraints"); 800 return -1; 801 } 802 803 if (hdr.tag == ASN1_TAG_BOOLEAN) { 804 if (hdr.length != 1) { 805 wpa_printf(MSG_DEBUG, "X509: Unexpected " 806 "Boolean length (%u) in BasicConstraints", 807 hdr.length); 808 return -1; 809 } 810 cert->ca = hdr.payload[0]; 811 812 if (hdr.length == pos + len - hdr.payload) { 813 wpa_printf(MSG_DEBUG, "X509: BasicConstraints - cA=%d", 814 cert->ca); 815 return 0; 816 } 817 818 if (asn1_get_next(hdr.payload + hdr.length, len - hdr.length, 819 &hdr) < 0 || 820 hdr.class != ASN1_CLASS_UNIVERSAL) { 821 wpa_printf(MSG_DEBUG, "X509: Failed to parse " 822 "BasicConstraints"); 823 return -1; 824 } 825 } 826 827 if (hdr.tag != ASN1_TAG_INTEGER) { 828 wpa_printf(MSG_DEBUG, "X509: Expected INTEGER in " 829 "BasicConstraints; found class %d tag 0x%x", 830 hdr.class, hdr.tag); 831 return -1; 832 } 833 834 pos = hdr.payload; 835 left = hdr.length; 836 value = 0; 837 while (left) { 838 value <<= 8; 839 value |= *pos++; 840 left--; 841 } 842 843 cert->path_len_constraint = value; 844 cert->extensions_present |= X509_EXT_PATH_LEN_CONSTRAINT; 845 846 wpa_printf(MSG_DEBUG, "X509: BasicConstraints - cA=%d " 847 "pathLenConstraint=%lu", 848 cert->ca, cert->path_len_constraint); 849 850 return 0; 851 } 852 853 854 static int x509_parse_alt_name_rfc8222(struct x509_name *name, 855 const u8 *pos, size_t len) 856 { 857 /* rfc822Name IA5String */ 858 wpa_hexdump_ascii(MSG_MSGDUMP, "X509: altName - rfc822Name", pos, len); 859 os_free(name->alt_email); 860 name->alt_email = os_zalloc(len + 1); 861 if (name->alt_email == NULL) 862 return -1; 863 os_memcpy(name->alt_email, pos, len); 864 if (os_strlen(name->alt_email) != len) { 865 wpa_printf(MSG_INFO, "X509: Reject certificate with " 866 "embedded NUL byte in rfc822Name (%s[NUL])", 867 name->alt_email); 868 os_free(name->alt_email); 869 name->alt_email = NULL; 870 return -1; 871 } 872 return 0; 873 } 874 875 876 static int x509_parse_alt_name_dns(struct x509_name *name, 877 const u8 *pos, size_t len) 878 { 879 /* dNSName IA5String */ 880 wpa_hexdump_ascii(MSG_MSGDUMP, "X509: altName - dNSName", pos, len); 881 os_free(name->dns); 882 name->dns = os_zalloc(len + 1); 883 if (name->dns == NULL) 884 return -1; 885 os_memcpy(name->dns, pos, len); 886 if (os_strlen(name->dns) != len) { 887 wpa_printf(MSG_INFO, "X509: Reject certificate with " 888 "embedded NUL byte in dNSName (%s[NUL])", 889 name->dns); 890 os_free(name->dns); 891 name->dns = NULL; 892 return -1; 893 } 894 return 0; 895 } 896 897 898 static int x509_parse_alt_name_uri(struct x509_name *name, 899 const u8 *pos, size_t len) 900 { 901 /* uniformResourceIdentifier IA5String */ 902 wpa_hexdump_ascii(MSG_MSGDUMP, 903 "X509: altName - uniformResourceIdentifier", 904 pos, len); 905 os_free(name->uri); 906 name->uri = os_zalloc(len + 1); 907 if (name->uri == NULL) 908 return -1; 909 os_memcpy(name->uri, pos, len); 910 if (os_strlen(name->uri) != len) { 911 wpa_printf(MSG_INFO, "X509: Reject certificate with " 912 "embedded NUL byte in uniformResourceIdentifier " 913 "(%s[NUL])", name->uri); 914 os_free(name->uri); 915 name->uri = NULL; 916 return -1; 917 } 918 return 0; 919 } 920 921 922 static int x509_parse_alt_name_ip(struct x509_name *name, 923 const u8 *pos, size_t len) 924 { 925 /* iPAddress OCTET STRING */ 926 wpa_hexdump(MSG_MSGDUMP, "X509: altName - iPAddress", pos, len); 927 os_free(name->ip); 928 name->ip = os_malloc(len); 929 if (name->ip == NULL) 930 return -1; 931 os_memcpy(name->ip, pos, len); 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_malloc(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 os_memcpy(cert->sign_value, pos + 1, hdr.length - 1); 1711 cert->sign_value_len = hdr.length - 1; 1712 wpa_hexdump(MSG_MSGDUMP, "X509: signature", 1713 cert->sign_value, cert->sign_value_len); 1714 1715 return cert; 1716 } 1717 1718 1719 /** 1720 * x509_certificate_check_signature - Verify certificate signature 1721 * @issuer: Issuer certificate 1722 * @cert: Certificate to be verified 1723 * Returns: 0 if cert has a valid signature that was signed by the issuer, 1724 * -1 if not 1725 */ 1726 int x509_certificate_check_signature(struct x509_certificate *issuer, 1727 struct x509_certificate *cert) 1728 { 1729 return x509_check_signature(issuer, &cert->signature, 1730 cert->sign_value, cert->sign_value_len, 1731 cert->tbs_cert_start, cert->tbs_cert_len); 1732 } 1733 1734 1735 int x509_check_signature(struct x509_certificate *issuer, 1736 struct x509_algorithm_identifier *signature, 1737 const u8 *sign_value, size_t sign_value_len, 1738 const u8 *signed_data, size_t signed_data_len) 1739 { 1740 struct crypto_public_key *pk; 1741 u8 *data; 1742 const u8 *pos, *end, *next, *da_end; 1743 size_t data_len; 1744 struct asn1_hdr hdr; 1745 struct asn1_oid oid; 1746 u8 hash[64]; 1747 size_t hash_len; 1748 const u8 *addr[1] = { signed_data }; 1749 size_t len[1] = { signed_data_len }; 1750 1751 if (!x509_pkcs_oid(&signature->oid) || 1752 signature->oid.len != 7 || 1753 signature->oid.oid[5] != 1 /* pkcs-1 */) { 1754 wpa_printf(MSG_DEBUG, "X509: Unrecognized signature " 1755 "algorithm"); 1756 return -1; 1757 } 1758 1759 pk = crypto_public_key_import(issuer->public_key, 1760 issuer->public_key_len); 1761 if (pk == NULL) 1762 return -1; 1763 1764 data_len = sign_value_len; 1765 data = os_malloc(data_len); 1766 if (data == NULL) { 1767 crypto_public_key_free(pk); 1768 return -1; 1769 } 1770 1771 if (crypto_public_key_decrypt_pkcs1(pk, sign_value, 1772 sign_value_len, data, 1773 &data_len) < 0) { 1774 wpa_printf(MSG_DEBUG, "X509: Failed to decrypt signature"); 1775 crypto_public_key_free(pk); 1776 os_free(data); 1777 return -1; 1778 } 1779 crypto_public_key_free(pk); 1780 1781 wpa_hexdump(MSG_MSGDUMP, "X509: Signature data D", data, data_len); 1782 1783 /* 1784 * PKCS #1 v1.5, 10.1.2: 1785 * 1786 * DigestInfo ::= SEQUENCE { 1787 * digestAlgorithm DigestAlgorithmIdentifier, 1788 * digest Digest 1789 * } 1790 * 1791 * DigestAlgorithmIdentifier ::= AlgorithmIdentifier 1792 * 1793 * Digest ::= OCTET STRING 1794 * 1795 */ 1796 if (asn1_get_next(data, data_len, &hdr) < 0 || 1797 hdr.class != ASN1_CLASS_UNIVERSAL || 1798 hdr.tag != ASN1_TAG_SEQUENCE) { 1799 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE " 1800 "(DigestInfo) - found class %d tag 0x%x", 1801 hdr.class, hdr.tag); 1802 os_free(data); 1803 return -1; 1804 } 1805 1806 pos = hdr.payload; 1807 end = pos + hdr.length; 1808 1809 /* 1810 * X.509: 1811 * AlgorithmIdentifier ::= SEQUENCE { 1812 * algorithm OBJECT IDENTIFIER, 1813 * parameters ANY DEFINED BY algorithm OPTIONAL 1814 * } 1815 */ 1816 1817 if (asn1_get_next(pos, end - pos, &hdr) < 0 || 1818 hdr.class != ASN1_CLASS_UNIVERSAL || 1819 hdr.tag != ASN1_TAG_SEQUENCE) { 1820 wpa_printf(MSG_DEBUG, "X509: Expected SEQUENCE " 1821 "(AlgorithmIdentifier) - found class %d tag 0x%x", 1822 hdr.class, hdr.tag); 1823 os_free(data); 1824 return -1; 1825 } 1826 da_end = hdr.payload + hdr.length; 1827 1828 if (asn1_get_oid(hdr.payload, hdr.length, &oid, &next)) { 1829 wpa_printf(MSG_DEBUG, "X509: Failed to parse digestAlgorithm"); 1830 os_free(data); 1831 return -1; 1832 } 1833 1834 if (x509_sha1_oid(&oid)) { 1835 if (signature->oid.oid[6] != 5 /* sha-1WithRSAEncryption */) { 1836 wpa_printf(MSG_DEBUG, "X509: digestAlgorithm SHA1 " 1837 "does not match with certificate " 1838 "signatureAlgorithm (%lu)", 1839 signature->oid.oid[6]); 1840 os_free(data); 1841 return -1; 1842 } 1843 goto skip_digest_oid; 1844 } 1845 1846 if (x509_sha256_oid(&oid)) { 1847 if (signature->oid.oid[6] != 1848 11 /* sha2561WithRSAEncryption */) { 1849 wpa_printf(MSG_DEBUG, "X509: digestAlgorithm SHA256 " 1850 "does not match with certificate " 1851 "signatureAlgorithm (%lu)", 1852 signature->oid.oid[6]); 1853 os_free(data); 1854 return -1; 1855 } 1856 goto skip_digest_oid; 1857 } 1858 1859 if (x509_sha384_oid(&oid)) { 1860 if (signature->oid.oid[6] != 12 /* sha384WithRSAEncryption */) { 1861 wpa_printf(MSG_DEBUG, "X509: digestAlgorithm SHA384 " 1862 "does not match with certificate " 1863 "signatureAlgorithm (%lu)", 1864 signature->oid.oid[6]); 1865 os_free(data); 1866 return -1; 1867 } 1868 goto skip_digest_oid; 1869 } 1870 1871 if (x509_sha512_oid(&oid)) { 1872 if (signature->oid.oid[6] != 13 /* sha512WithRSAEncryption */) { 1873 wpa_printf(MSG_DEBUG, "X509: digestAlgorithm SHA512 " 1874 "does not match with certificate " 1875 "signatureAlgorithm (%lu)", 1876 signature->oid.oid[6]); 1877 os_free(data); 1878 return -1; 1879 } 1880 goto skip_digest_oid; 1881 } 1882 1883 if (!x509_digest_oid(&oid)) { 1884 wpa_printf(MSG_DEBUG, "X509: Unrecognized digestAlgorithm"); 1885 os_free(data); 1886 return -1; 1887 } 1888 switch (oid.oid[5]) { 1889 case 5: /* md5 */ 1890 if (signature->oid.oid[6] != 4 /* md5WithRSAEncryption */) { 1891 wpa_printf(MSG_DEBUG, "X509: digestAlgorithm MD5 does " 1892 "not match with certificate " 1893 "signatureAlgorithm (%lu)", 1894 signature->oid.oid[6]); 1895 os_free(data); 1896 return -1; 1897 } 1898 break; 1899 case 2: /* md2 */ 1900 case 4: /* md4 */ 1901 default: 1902 wpa_printf(MSG_DEBUG, "X509: Unsupported digestAlgorithm " 1903 "(%lu)", oid.oid[5]); 1904 os_free(data); 1905 return -1; 1906 } 1907 1908 skip_digest_oid: 1909 /* Digest ::= OCTET STRING */ 1910 pos = da_end; 1911 end = data + data_len; 1912 1913 if (asn1_get_next(pos, end - pos, &hdr) < 0 || 1914 hdr.class != ASN1_CLASS_UNIVERSAL || 1915 hdr.tag != ASN1_TAG_OCTETSTRING) { 1916 wpa_printf(MSG_DEBUG, "X509: Expected OCTETSTRING " 1917 "(Digest) - found class %d tag 0x%x", 1918 hdr.class, hdr.tag); 1919 os_free(data); 1920 return -1; 1921 } 1922 wpa_hexdump(MSG_MSGDUMP, "X509: Decrypted Digest", 1923 hdr.payload, hdr.length); 1924 1925 switch (signature->oid.oid[6]) { 1926 case 4: /* md5WithRSAEncryption */ 1927 md5_vector(1, addr, len, hash); 1928 hash_len = 16; 1929 wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (MD5)", 1930 hash, hash_len); 1931 break; 1932 case 5: /* sha-1WithRSAEncryption */ 1933 sha1_vector(1, addr, len, hash); 1934 hash_len = 20; 1935 wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (SHA1)", 1936 hash, hash_len); 1937 break; 1938 case 11: /* sha256WithRSAEncryption */ 1939 sha256_vector(1, addr, len, hash); 1940 hash_len = 32; 1941 wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (SHA256)", 1942 hash, hash_len); 1943 break; 1944 case 12: /* sha384WithRSAEncryption */ 1945 sha384_vector(1, addr, len, hash); 1946 hash_len = 48; 1947 wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (SHA384)", 1948 hash, hash_len); 1949 break; 1950 case 13: /* sha512WithRSAEncryption */ 1951 sha512_vector(1, addr, len, hash); 1952 hash_len = 64; 1953 wpa_hexdump(MSG_MSGDUMP, "X509: Certificate hash (SHA512)", 1954 hash, hash_len); 1955 break; 1956 case 2: /* md2WithRSAEncryption */ 1957 default: 1958 wpa_printf(MSG_INFO, "X509: Unsupported certificate signature " 1959 "algorithm (%lu)", signature->oid.oid[6]); 1960 os_free(data); 1961 return -1; 1962 } 1963 1964 if (hdr.length != hash_len || 1965 os_memcmp_const(hdr.payload, hash, hdr.length) != 0) { 1966 wpa_printf(MSG_INFO, "X509: Certificate Digest does not match " 1967 "with calculated tbsCertificate hash"); 1968 os_free(data); 1969 return -1; 1970 } 1971 1972 if (hdr.payload + hdr.length < data + data_len) { 1973 wpa_hexdump(MSG_INFO, 1974 "X509: Extra data after certificate signature hash", 1975 hdr.payload + hdr.length, 1976 data + data_len - hdr.payload - hdr.length); 1977 os_free(data); 1978 return -1; 1979 } 1980 1981 os_free(data); 1982 1983 wpa_printf(MSG_DEBUG, "X509: Certificate Digest matches with " 1984 "calculated tbsCertificate hash"); 1985 1986 return 0; 1987 } 1988 1989 1990 static int x509_valid_issuer(const struct x509_certificate *cert) 1991 { 1992 if ((cert->extensions_present & X509_EXT_BASIC_CONSTRAINTS) && 1993 !cert->ca) { 1994 wpa_printf(MSG_DEBUG, "X509: Non-CA certificate used as an " 1995 "issuer"); 1996 return -1; 1997 } 1998 1999 if (cert->version == X509_CERT_V3 && 2000 !(cert->extensions_present & X509_EXT_BASIC_CONSTRAINTS)) { 2001 wpa_printf(MSG_DEBUG, "X509: v3 CA certificate did not " 2002 "include BasicConstraints extension"); 2003 return -1; 2004 } 2005 2006 if ((cert->extensions_present & X509_EXT_KEY_USAGE) && 2007 !(cert->key_usage & X509_KEY_USAGE_KEY_CERT_SIGN)) { 2008 wpa_printf(MSG_DEBUG, "X509: Issuer certificate did not have " 2009 "keyCertSign bit in Key Usage"); 2010 return -1; 2011 } 2012 2013 return 0; 2014 } 2015 2016 2017 /** 2018 * x509_certificate_chain_validate - Validate X.509 certificate chain 2019 * @trusted: List of trusted certificates 2020 * @chain: Certificate chain to be validated (first chain must be issued by 2021 * signed by the second certificate in the chain and so on) 2022 * @reason: Buffer for returning failure reason (X509_VALIDATE_*) 2023 * Returns: 0 if chain is valid, -1 if not 2024 */ 2025 int x509_certificate_chain_validate(struct x509_certificate *trusted, 2026 struct x509_certificate *chain, 2027 int *reason, int disable_time_checks) 2028 { 2029 long unsigned idx; 2030 int chain_trusted = 0; 2031 struct x509_certificate *cert, *trust; 2032 char buf[128]; 2033 struct os_time now; 2034 2035 *reason = X509_VALIDATE_OK; 2036 2037 wpa_printf(MSG_DEBUG, "X509: Validate certificate chain"); 2038 os_get_time(&now); 2039 2040 for (cert = chain, idx = 0; cert; cert = cert->next, idx++) { 2041 cert->issuer_trusted = 0; 2042 x509_name_string(&cert->subject, buf, sizeof(buf)); 2043 wpa_printf(MSG_DEBUG, "X509: %lu: %s", idx, buf); 2044 2045 if (chain_trusted) 2046 continue; 2047 2048 if (!disable_time_checks && 2049 ((unsigned long) now.sec < 2050 (unsigned long) cert->not_before || 2051 (unsigned long) now.sec > 2052 (unsigned long) cert->not_after)) { 2053 wpa_printf(MSG_INFO, "X509: Certificate not valid " 2054 "(now=%lu not_before=%lu not_after=%lu)", 2055 now.sec, cert->not_before, cert->not_after); 2056 *reason = X509_VALIDATE_CERTIFICATE_EXPIRED; 2057 return -1; 2058 } 2059 2060 if (cert->next) { 2061 if (x509_name_compare(&cert->issuer, 2062 &cert->next->subject) != 0) { 2063 wpa_printf(MSG_DEBUG, "X509: Certificate " 2064 "chain issuer name mismatch"); 2065 x509_name_string(&cert->issuer, buf, 2066 sizeof(buf)); 2067 wpa_printf(MSG_DEBUG, "X509: cert issuer: %s", 2068 buf); 2069 x509_name_string(&cert->next->subject, buf, 2070 sizeof(buf)); 2071 wpa_printf(MSG_DEBUG, "X509: next cert " 2072 "subject: %s", buf); 2073 *reason = X509_VALIDATE_CERTIFICATE_UNKNOWN; 2074 return -1; 2075 } 2076 2077 if (x509_valid_issuer(cert->next) < 0) { 2078 *reason = X509_VALIDATE_BAD_CERTIFICATE; 2079 return -1; 2080 } 2081 2082 if ((cert->next->extensions_present & 2083 X509_EXT_PATH_LEN_CONSTRAINT) && 2084 idx > cert->next->path_len_constraint) { 2085 wpa_printf(MSG_DEBUG, "X509: pathLenConstraint" 2086 " not met (idx=%lu issuer " 2087 "pathLenConstraint=%lu)", idx, 2088 cert->next->path_len_constraint); 2089 *reason = X509_VALIDATE_BAD_CERTIFICATE; 2090 return -1; 2091 } 2092 2093 if (x509_certificate_check_signature(cert->next, cert) 2094 < 0) { 2095 wpa_printf(MSG_DEBUG, "X509: Invalid " 2096 "certificate signature within " 2097 "chain"); 2098 *reason = X509_VALIDATE_BAD_CERTIFICATE; 2099 return -1; 2100 } 2101 } 2102 2103 for (trust = trusted; trust; trust = trust->next) { 2104 if (x509_name_compare(&cert->issuer, &trust->subject) 2105 == 0) 2106 break; 2107 } 2108 2109 if (trust) { 2110 wpa_printf(MSG_DEBUG, "X509: Found issuer from the " 2111 "list of trusted certificates"); 2112 if (x509_valid_issuer(trust) < 0) { 2113 *reason = X509_VALIDATE_BAD_CERTIFICATE; 2114 return -1; 2115 } 2116 2117 if (x509_certificate_check_signature(trust, cert) < 0) 2118 { 2119 wpa_printf(MSG_DEBUG, "X509: Invalid " 2120 "certificate signature"); 2121 *reason = X509_VALIDATE_BAD_CERTIFICATE; 2122 return -1; 2123 } 2124 2125 wpa_printf(MSG_DEBUG, "X509: Trusted certificate " 2126 "found to complete the chain"); 2127 cert->issuer_trusted = 1; 2128 chain_trusted = 1; 2129 } 2130 } 2131 2132 if (!chain_trusted) { 2133 wpa_printf(MSG_DEBUG, "X509: Did not find any of the issuers " 2134 "from the list of trusted certificates"); 2135 if (trusted) { 2136 *reason = X509_VALIDATE_UNKNOWN_CA; 2137 return -1; 2138 } 2139 wpa_printf(MSG_DEBUG, "X509: Certificate chain validation " 2140 "disabled - ignore unknown CA issue"); 2141 } 2142 2143 wpa_printf(MSG_DEBUG, "X509: Certificate chain valid"); 2144 2145 return 0; 2146 } 2147 2148 2149 /** 2150 * x509_certificate_get_subject - Get a certificate based on Subject name 2151 * @chain: Certificate chain to search through 2152 * @name: Subject name to search for 2153 * Returns: Pointer to the certificate with the given Subject name or 2154 * %NULL on failure 2155 */ 2156 struct x509_certificate * 2157 x509_certificate_get_subject(struct x509_certificate *chain, 2158 struct x509_name *name) 2159 { 2160 struct x509_certificate *cert; 2161 2162 for (cert = chain; cert; cert = cert->next) { 2163 if (x509_name_compare(&cert->subject, name) == 0) 2164 return cert; 2165 } 2166 return NULL; 2167 } 2168 2169 2170 /** 2171 * x509_certificate_self_signed - Is the certificate self-signed? 2172 * @cert: Certificate 2173 * Returns: 1 if certificate is self-signed, 0 if not 2174 */ 2175 int x509_certificate_self_signed(struct x509_certificate *cert) 2176 { 2177 return x509_name_compare(&cert->issuer, &cert->subject) == 0; 2178 } 2179