1 /* 2 * SSL/TLS interface functions for OpenSSL - BoringSSL OCSP 3 * Copyright (c) 2004-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 <openssl/ssl.h> 12 #include <openssl/err.h> 13 #include <openssl/x509v3.h> 14 #ifdef OPENSSL_IS_BORINGSSL 15 #include <openssl/asn1.h> 16 #include <openssl/asn1t.h> 17 #endif /* OPENSSL_IS_BORINGSSL */ 18 19 #include "common.h" 20 #include "tls_openssl.h" 21 22 23 #ifdef OPENSSL_IS_BORINGSSL 24 25 static void tls_show_errors(int level, const char *func, const char *txt) 26 { 27 unsigned long err; 28 29 wpa_printf(level, "OpenSSL: %s - %s %s", 30 func, txt, ERR_error_string(ERR_get_error(), NULL)); 31 32 while ((err = ERR_get_error())) { 33 wpa_printf(MSG_INFO, "OpenSSL: pending error: %s", 34 ERR_error_string(err, NULL)); 35 } 36 } 37 38 39 /* 40 * CertID ::= SEQUENCE { 41 * hashAlgorithm AlgorithmIdentifier, 42 * issuerNameHash OCTET STRING, -- Hash of Issuer's DN 43 * issuerKeyHash OCTET STRING, -- Hash of Issuer's public key 44 * serialNumber CertificateSerialNumber } 45 */ 46 typedef struct { 47 X509_ALGOR *hashAlgorithm; 48 ASN1_OCTET_STRING *issuerNameHash; 49 ASN1_OCTET_STRING *issuerKeyHash; 50 ASN1_INTEGER *serialNumber; 51 } CertID; 52 53 /* 54 * ResponseBytes ::= SEQUENCE { 55 * responseType OBJECT IDENTIFIER, 56 * response OCTET STRING } 57 */ 58 typedef struct { 59 ASN1_OBJECT *responseType; 60 ASN1_OCTET_STRING *response; 61 } ResponseBytes; 62 63 /* 64 * OCSPResponse ::= SEQUENCE { 65 * responseStatus OCSPResponseStatus, 66 * responseBytes [0] EXPLICIT ResponseBytes OPTIONAL } 67 */ 68 typedef struct { 69 ASN1_ENUMERATED *responseStatus; 70 ResponseBytes *responseBytes; 71 } OCSPResponse; 72 73 ASN1_SEQUENCE(ResponseBytes) = { 74 ASN1_SIMPLE(ResponseBytes, responseType, ASN1_OBJECT), 75 ASN1_SIMPLE(ResponseBytes, response, ASN1_OCTET_STRING) 76 } ASN1_SEQUENCE_END(ResponseBytes); 77 78 ASN1_SEQUENCE(OCSPResponse) = { 79 ASN1_SIMPLE(OCSPResponse, responseStatus, ASN1_ENUMERATED), 80 ASN1_EXP_OPT(OCSPResponse, responseBytes, ResponseBytes, 0) 81 } ASN1_SEQUENCE_END(OCSPResponse); 82 83 IMPLEMENT_ASN1_FUNCTIONS(OCSPResponse); 84 85 /* 86 * ResponderID ::= CHOICE { 87 * byName [1] Name, 88 * byKey [2] KeyHash } 89 */ 90 typedef struct { 91 int type; 92 union { 93 X509_NAME *byName; 94 ASN1_OCTET_STRING *byKey; 95 } value; 96 } ResponderID; 97 98 /* 99 * RevokedInfo ::= SEQUENCE { 100 * revocationTime GeneralizedTime, 101 * revocationReason [0] EXPLICIT CRLReason OPTIONAL } 102 */ 103 typedef struct { 104 ASN1_GENERALIZEDTIME *revocationTime; 105 ASN1_ENUMERATED *revocationReason; 106 } RevokedInfo; 107 108 /* 109 * CertStatus ::= CHOICE { 110 * good [0] IMPLICIT NULL, 111 * revoked [1] IMPLICIT RevokedInfo, 112 * unknown [2] IMPLICIT UnknownInfo } 113 */ 114 typedef struct { 115 int type; 116 union { 117 ASN1_NULL *good; 118 RevokedInfo *revoked; 119 ASN1_NULL *unknown; 120 } value; 121 } CertStatus; 122 123 /* 124 * SingleResponse ::= SEQUENCE { 125 * certID CertID, 126 * certStatus CertStatus, 127 * thisUpdate GeneralizedTime, 128 * nextUpdate [0] EXPLICIT GeneralizedTime OPTIONAL, 129 * singleExtensions [1] EXPLICIT Extensions OPTIONAL } 130 */ 131 typedef struct { 132 CertID *certID; 133 CertStatus *certStatus; 134 ASN1_GENERALIZEDTIME *thisUpdate; 135 ASN1_GENERALIZEDTIME *nextUpdate; 136 STACK_OF(X509_EXTENSION) *singleExtensions; 137 } SingleResponse; 138 139 /* 140 * ResponseData ::= SEQUENCE { 141 * version [0] EXPLICIT Version DEFAULT v1, 142 * responderID ResponderID, 143 * producedAt GeneralizedTime, 144 * responses SEQUENCE OF SingleResponse, 145 * responseExtensions [1] EXPLICIT Extensions OPTIONAL } 146 */ 147 typedef struct { 148 ASN1_INTEGER *version; 149 ResponderID *responderID; 150 ASN1_GENERALIZEDTIME *producedAt; 151 STACK_OF(SingleResponse) *responses; 152 STACK_OF(X509_EXTENSION) *responseExtensions; 153 } ResponseData; 154 155 /* 156 * BasicOCSPResponse ::= SEQUENCE { 157 * tbsResponseData ResponseData, 158 * signatureAlgorithm AlgorithmIdentifier, 159 * signature BIT STRING, 160 * certs [0] EXPLICIT SEQUENCE OF Certificate OPTIONAL } 161 */ 162 typedef struct { 163 ResponseData *tbsResponseData; 164 X509_ALGOR *signatureAlgorithm; 165 ASN1_BIT_STRING *signature; 166 STACK_OF(X509) *certs; 167 } BasicOCSPResponse; 168 169 ASN1_SEQUENCE(CertID) = { 170 ASN1_SIMPLE(CertID, hashAlgorithm, X509_ALGOR), 171 ASN1_SIMPLE(CertID, issuerNameHash, ASN1_OCTET_STRING), 172 ASN1_SIMPLE(CertID, issuerKeyHash, ASN1_OCTET_STRING), 173 ASN1_SIMPLE(CertID, serialNumber, ASN1_INTEGER) 174 } ASN1_SEQUENCE_END(CertID); 175 176 ASN1_CHOICE(ResponderID) = { 177 ASN1_EXP(ResponderID, value.byName, X509_NAME, 1), 178 ASN1_EXP(ResponderID, value.byKey, ASN1_OCTET_STRING, 2) 179 } ASN1_CHOICE_END(ResponderID); 180 181 ASN1_SEQUENCE(RevokedInfo) = { 182 ASN1_SIMPLE(RevokedInfo, revocationTime, ASN1_GENERALIZEDTIME), 183 ASN1_EXP_OPT(RevokedInfo, revocationReason, ASN1_ENUMERATED, 0) 184 } ASN1_SEQUENCE_END(RevokedInfo); 185 186 ASN1_CHOICE(CertStatus) = { 187 ASN1_IMP(CertStatus, value.good, ASN1_NULL, 0), 188 ASN1_IMP(CertStatus, value.revoked, RevokedInfo, 1), 189 ASN1_IMP(CertStatus, value.unknown, ASN1_NULL, 2) 190 } ASN1_CHOICE_END(CertStatus); 191 192 ASN1_SEQUENCE(SingleResponse) = { 193 ASN1_SIMPLE(SingleResponse, certID, CertID), 194 ASN1_SIMPLE(SingleResponse, certStatus, CertStatus), 195 ASN1_SIMPLE(SingleResponse, thisUpdate, ASN1_GENERALIZEDTIME), 196 ASN1_EXP_OPT(SingleResponse, nextUpdate, ASN1_GENERALIZEDTIME, 0), 197 ASN1_EXP_SEQUENCE_OF_OPT(SingleResponse, singleExtensions, 198 X509_EXTENSION, 1) 199 } ASN1_SEQUENCE_END(SingleResponse); 200 201 ASN1_SEQUENCE(ResponseData) = { 202 ASN1_EXP_OPT(ResponseData, version, ASN1_INTEGER, 0), 203 ASN1_SIMPLE(ResponseData, responderID, ResponderID), 204 ASN1_SIMPLE(ResponseData, producedAt, ASN1_GENERALIZEDTIME), 205 ASN1_SEQUENCE_OF(ResponseData, responses, SingleResponse), 206 ASN1_EXP_SEQUENCE_OF_OPT(ResponseData, responseExtensions, 207 X509_EXTENSION, 1) 208 } ASN1_SEQUENCE_END(ResponseData); 209 210 ASN1_SEQUENCE(BasicOCSPResponse) = { 211 ASN1_SIMPLE(BasicOCSPResponse, tbsResponseData, ResponseData), 212 ASN1_SIMPLE(BasicOCSPResponse, signatureAlgorithm, X509_ALGOR), 213 ASN1_SIMPLE(BasicOCSPResponse, signature, ASN1_BIT_STRING), 214 ASN1_EXP_SEQUENCE_OF_OPT(BasicOCSPResponse, certs, X509, 0) 215 } ASN1_SEQUENCE_END(BasicOCSPResponse); 216 217 IMPLEMENT_ASN1_FUNCTIONS(BasicOCSPResponse); 218 219 #define sk_SingleResponse_num(sk) \ 220 sk_num(CHECKED_CAST(_STACK *, STACK_OF(SingleResponse) *, sk)) 221 222 #define sk_SingleResponse_value(sk, i) \ 223 ((SingleResponse *) \ 224 sk_value(CHECKED_CAST(_STACK *, STACK_OF(SingleResponse) *, sk), (i))) 225 226 227 static char * mem_bio_to_str(BIO *out) 228 { 229 char *txt; 230 size_t rlen; 231 int res; 232 233 rlen = BIO_ctrl_pending(out); 234 txt = os_malloc(rlen + 1); 235 if (!txt) { 236 BIO_free(out); 237 return NULL; 238 } 239 240 res = BIO_read(out, txt, rlen); 241 BIO_free(out); 242 if (res < 0) { 243 os_free(txt); 244 return NULL; 245 } 246 247 txt[res] = '\0'; 248 return txt; 249 } 250 251 252 static char * generalizedtime_str(ASN1_GENERALIZEDTIME *t) 253 { 254 BIO *out; 255 256 out = BIO_new(BIO_s_mem()); 257 if (!out) 258 return NULL; 259 260 if (!ASN1_GENERALIZEDTIME_print(out, t)) { 261 BIO_free(out); 262 return NULL; 263 } 264 265 return mem_bio_to_str(out); 266 } 267 268 269 static char * responderid_str(ResponderID *rid) 270 { 271 BIO *out; 272 273 out = BIO_new(BIO_s_mem()); 274 if (!out) 275 return NULL; 276 277 switch (rid->type) { 278 case 0: 279 X509_NAME_print_ex(out, rid->value.byName, 0, XN_FLAG_ONELINE); 280 break; 281 case 1: 282 i2a_ASN1_STRING(out, rid->value.byKey, V_ASN1_OCTET_STRING); 283 break; 284 default: 285 BIO_free(out); 286 return NULL; 287 } 288 289 return mem_bio_to_str(out); 290 } 291 292 293 static char * octet_string_str(ASN1_OCTET_STRING *o) 294 { 295 BIO *out; 296 297 out = BIO_new(BIO_s_mem()); 298 if (!out) 299 return NULL; 300 301 i2a_ASN1_STRING(out, o, V_ASN1_OCTET_STRING); 302 return mem_bio_to_str(out); 303 } 304 305 306 static char * integer_str(ASN1_INTEGER *i) 307 { 308 BIO *out; 309 310 out = BIO_new(BIO_s_mem()); 311 if (!out) 312 return NULL; 313 314 i2a_ASN1_INTEGER(out, i); 315 return mem_bio_to_str(out); 316 } 317 318 319 static char * algor_str(X509_ALGOR *alg) 320 { 321 BIO *out; 322 323 out = BIO_new(BIO_s_mem()); 324 if (!out) 325 return NULL; 326 327 i2a_ASN1_OBJECT(out, alg->algorithm); 328 return mem_bio_to_str(out); 329 } 330 331 332 static char * extensions_str(const char *title, STACK_OF(X509_EXTENSION) *ext) 333 { 334 BIO *out; 335 336 if (!ext) 337 return NULL; 338 339 out = BIO_new(BIO_s_mem()); 340 if (!out) 341 return NULL; 342 343 if (!X509V3_extensions_print(out, title, ext, 0, 0)) { 344 BIO_free(out); 345 return NULL; 346 } 347 return mem_bio_to_str(out); 348 } 349 350 351 static int ocsp_resp_valid(ASN1_GENERALIZEDTIME *thisupd, 352 ASN1_GENERALIZEDTIME *nextupd) 353 { 354 time_t now, tmp; 355 356 if (!ASN1_GENERALIZEDTIME_check(thisupd)) { 357 wpa_printf(MSG_DEBUG, 358 "OpenSSL: Invalid OCSP response thisUpdate"); 359 return 0; 360 } 361 362 time(&now); 363 tmp = now + 5 * 60; /* allow five minute clock difference */ 364 if (X509_cmp_time(thisupd, &tmp) > 0) { 365 wpa_printf(MSG_DEBUG, "OpenSSL: OCSP response not yet valid"); 366 return 0; 367 } 368 369 if (!nextupd) 370 return 1; /* OK - no limit on response age */ 371 372 if (!ASN1_GENERALIZEDTIME_check(nextupd)) { 373 wpa_printf(MSG_DEBUG, 374 "OpenSSL: Invalid OCSP response nextUpdate"); 375 return 0; 376 } 377 378 tmp = now - 5 * 60; /* allow five minute clock difference */ 379 if (X509_cmp_time(nextupd, &tmp) < 0) { 380 wpa_printf(MSG_DEBUG, "OpenSSL: OCSP response expired"); 381 return 0; 382 } 383 384 if (ASN1_STRING_cmp(nextupd, thisupd) < 0) { 385 wpa_printf(MSG_DEBUG, 386 "OpenSSL: OCSP response nextUpdate before thisUpdate"); 387 return 0; 388 } 389 390 /* Both thisUpdate and nextUpdate are valid */ 391 return -1; 392 } 393 394 395 static int issuer_match(X509 *cert, X509 *issuer, CertID *certid) 396 { 397 X509_NAME *iname; 398 ASN1_BIT_STRING *ikey; 399 const EVP_MD *dgst; 400 unsigned int len; 401 unsigned char md[EVP_MAX_MD_SIZE]; 402 ASN1_OCTET_STRING *hash; 403 char *txt; 404 405 dgst = EVP_get_digestbyobj(certid->hashAlgorithm->algorithm); 406 if (!dgst) { 407 wpa_printf(MSG_DEBUG, 408 "OpenSSL: Could not find matching hash algorithm for OCSP"); 409 return -1; 410 } 411 412 iname = X509_get_issuer_name(cert); 413 if (!X509_NAME_digest(iname, dgst, md, &len)) 414 return -1; 415 hash = ASN1_OCTET_STRING_new(); 416 if (!hash) 417 return -1; 418 if (!ASN1_OCTET_STRING_set(hash, md, len)) { 419 ASN1_OCTET_STRING_free(hash); 420 return -1; 421 } 422 423 txt = octet_string_str(hash); 424 if (txt) { 425 wpa_printf(MSG_DEBUG, "OpenSSL: calculated issuerNameHash: %s", 426 txt); 427 os_free(txt); 428 } 429 430 if (ASN1_OCTET_STRING_cmp(certid->issuerNameHash, hash)) { 431 ASN1_OCTET_STRING_free(hash); 432 return -1; 433 } 434 435 ikey = X509_get0_pubkey_bitstr(issuer); 436 if (!ikey || 437 !EVP_Digest(ikey->data, ikey->length, md, &len, dgst, NULL) || 438 !ASN1_OCTET_STRING_set(hash, md, len)) { 439 ASN1_OCTET_STRING_free(hash); 440 return -1; 441 } 442 443 txt = octet_string_str(hash); 444 if (txt) { 445 wpa_printf(MSG_DEBUG, "OpenSSL: calculated issuerKeyHash: %s", 446 txt); 447 os_free(txt); 448 } 449 450 if (ASN1_OCTET_STRING_cmp(certid->issuerKeyHash, hash)) { 451 ASN1_OCTET_STRING_free(hash); 452 return -1; 453 } 454 455 ASN1_OCTET_STRING_free(hash); 456 return 0; 457 } 458 459 460 static X509 * ocsp_find_signer(STACK_OF(X509) *certs, ResponderID *rid) 461 { 462 unsigned int i; 463 unsigned char hash[SHA_DIGEST_LENGTH]; 464 465 if (rid->type == 0) { 466 /* byName */ 467 return X509_find_by_subject(certs, rid->value.byName); 468 } 469 470 /* byKey */ 471 if (rid->value.byKey->length != SHA_DIGEST_LENGTH) 472 return NULL; 473 for (i = 0; i < sk_X509_num(certs); i++) { 474 X509 *x = sk_X509_value(certs, i); 475 476 X509_pubkey_digest(x, EVP_sha1(), hash, NULL); 477 if (os_memcmp(rid->value.byKey->data, hash, 478 SHA_DIGEST_LENGTH) == 0) 479 return x; 480 } 481 482 return NULL; 483 } 484 485 486 enum ocsp_result check_ocsp_resp(SSL_CTX *ssl_ctx, SSL *ssl, X509 *cert, 487 X509 *issuer, X509 *issuer_issuer) 488 { 489 const uint8_t *resp_data; 490 size_t resp_len; 491 OCSPResponse *resp; 492 int status; 493 ResponseBytes *bytes; 494 const u8 *basic_data; 495 size_t basic_len; 496 BasicOCSPResponse *basic; 497 ResponseData *rd; 498 char *txt; 499 int i, num; 500 unsigned int j, num_resp; 501 SingleResponse *matching_resp = NULL, *cmp_sresp; 502 enum ocsp_result result = OCSP_INVALID; 503 X509_STORE *store; 504 STACK_OF(X509) *untrusted = NULL, *certs = NULL, *chain = NULL; 505 X509_STORE_CTX ctx; 506 X509 *signer, *tmp_cert; 507 int signer_trusted = 0; 508 EVP_PKEY *skey; 509 int ret; 510 char buf[256]; 511 512 txt = integer_str(X509_get_serialNumber(cert)); 513 if (txt) { 514 wpa_printf(MSG_DEBUG, 515 "OpenSSL: Searching OCSP response for peer certificate serialNumber: %s", txt); 516 os_free(txt); 517 } 518 519 SSL_get0_ocsp_response(ssl, &resp_data, &resp_len); 520 if (resp_data == NULL || resp_len == 0) { 521 wpa_printf(MSG_DEBUG, "OpenSSL: No OCSP response received"); 522 return OCSP_NO_RESPONSE; 523 } 524 525 wpa_hexdump(MSG_DEBUG, "OpenSSL: OCSP response", resp_data, resp_len); 526 527 resp = d2i_OCSPResponse(NULL, &resp_data, resp_len); 528 if (!resp) { 529 wpa_printf(MSG_INFO, "OpenSSL: Failed to parse OCSPResponse"); 530 return OCSP_INVALID; 531 } 532 533 status = ASN1_ENUMERATED_get(resp->responseStatus); 534 if (status != 0) { 535 wpa_printf(MSG_INFO, "OpenSSL: OCSP responder error %d", 536 status); 537 return OCSP_INVALID; 538 } 539 540 bytes = resp->responseBytes; 541 542 if (!bytes || 543 OBJ_obj2nid(bytes->responseType) != NID_id_pkix_OCSP_basic) { 544 wpa_printf(MSG_INFO, 545 "OpenSSL: Could not find BasicOCSPResponse"); 546 return OCSP_INVALID; 547 } 548 549 basic_data = ASN1_STRING_data(bytes->response); 550 basic_len = ASN1_STRING_length(bytes->response); 551 wpa_hexdump(MSG_DEBUG, "OpenSSL: BasicOCSPResponse", 552 basic_data, basic_len); 553 554 basic = d2i_BasicOCSPResponse(NULL, &basic_data, basic_len); 555 if (!basic) { 556 wpa_printf(MSG_INFO, 557 "OpenSSL: Could not parse BasicOCSPResponse"); 558 OCSPResponse_free(resp); 559 return OCSP_INVALID; 560 } 561 562 rd = basic->tbsResponseData; 563 564 if (basic->certs) { 565 untrusted = sk_X509_dup(basic->certs); 566 if (!untrusted) 567 goto fail; 568 569 num = sk_X509_num(basic->certs); 570 for (i = 0; i < num; i++) { 571 X509 *extra_cert; 572 573 extra_cert = sk_X509_value(basic->certs, i); 574 X509_NAME_oneline(X509_get_subject_name(extra_cert), 575 buf, sizeof(buf)); 576 wpa_printf(MSG_DEBUG, 577 "OpenSSL: BasicOCSPResponse cert %s", buf); 578 579 if (!sk_X509_push(untrusted, extra_cert)) { 580 wpa_printf(MSG_DEBUG, 581 "OpenSSL: Could not add certificate to the untrusted stack"); 582 } 583 } 584 } 585 586 store = SSL_CTX_get_cert_store(ssl_ctx); 587 if (issuer) { 588 if (X509_STORE_add_cert(store, issuer) != 1) { 589 tls_show_errors(MSG_INFO, __func__, 590 "OpenSSL: Could not add issuer to certificate store"); 591 } 592 certs = sk_X509_new_null(); 593 if (certs) { 594 tmp_cert = X509_dup(issuer); 595 if (tmp_cert && !sk_X509_push(certs, tmp_cert)) { 596 tls_show_errors( 597 MSG_INFO, __func__, 598 "OpenSSL: Could not add issuer to OCSP responder trust store"); 599 X509_free(tmp_cert); 600 sk_X509_free(certs); 601 certs = NULL; 602 } 603 if (certs && issuer_issuer) { 604 tmp_cert = X509_dup(issuer_issuer); 605 if (tmp_cert && 606 !sk_X509_push(certs, tmp_cert)) { 607 tls_show_errors( 608 MSG_INFO, __func__, 609 "OpenSSL: Could not add issuer's issuer to OCSP responder trust store"); 610 X509_free(tmp_cert); 611 } 612 } 613 } 614 } 615 616 signer = ocsp_find_signer(certs, rd->responderID); 617 if (!signer) 618 signer = ocsp_find_signer(untrusted, rd->responderID); 619 else 620 signer_trusted = 1; 621 if (!signer) { 622 wpa_printf(MSG_DEBUG, 623 "OpenSSL: Could not find OCSP signer certificate"); 624 goto fail; 625 } 626 627 skey = X509_get_pubkey(signer); 628 if (!skey) { 629 wpa_printf(MSG_DEBUG, 630 "OpenSSL: Could not get OCSP signer public key"); 631 goto fail; 632 } 633 if (ASN1_item_verify(ASN1_ITEM_rptr(ResponseData), 634 basic->signatureAlgorithm, basic->signature, 635 basic->tbsResponseData, skey) <= 0) { 636 wpa_printf(MSG_DEBUG, 637 "OpenSSL: BasicOCSPResponse signature is invalid"); 638 goto fail; 639 } 640 641 X509_NAME_oneline(X509_get_subject_name(signer), buf, sizeof(buf)); 642 wpa_printf(MSG_DEBUG, 643 "OpenSSL: Found OCSP signer certificate %s and verified BasicOCSPResponse signature", 644 buf); 645 646 if (!X509_STORE_CTX_init(&ctx, store, signer, untrusted)) 647 goto fail; 648 X509_STORE_CTX_set_purpose(&ctx, X509_PURPOSE_OCSP_HELPER); 649 ret = X509_verify_cert(&ctx); 650 chain = X509_STORE_CTX_get1_chain(&ctx); 651 X509_STORE_CTX_cleanup(&ctx); 652 if (ret <= 0) { 653 wpa_printf(MSG_DEBUG, 654 "OpenSSL: Could not validate OCSP signer certificate"); 655 goto fail; 656 } 657 658 if (!chain || sk_X509_num(chain) <= 0) { 659 wpa_printf(MSG_DEBUG, "OpenSSL: No OCSP signer chain found"); 660 goto fail; 661 } 662 663 if (!signer_trusted) { 664 X509_check_purpose(signer, -1, 0); 665 if ((signer->ex_flags & EXFLAG_XKUSAGE) && 666 (signer->ex_xkusage & XKU_OCSP_SIGN)) { 667 wpa_printf(MSG_DEBUG, 668 "OpenSSL: OCSP signer certificate delegation OK"); 669 } else { 670 tmp_cert = sk_X509_value(chain, sk_X509_num(chain) - 1); 671 if (X509_check_trust(tmp_cert, NID_OCSP_sign, 0) != 672 X509_TRUST_TRUSTED) { 673 wpa_printf(MSG_DEBUG, 674 "OpenSSL: OCSP signer certificate not trusted"); 675 result = OCSP_NO_RESPONSE; 676 goto fail; 677 } 678 } 679 } 680 681 wpa_printf(MSG_DEBUG, "OpenSSL: OCSP version: %lu", 682 ASN1_INTEGER_get(rd->version)); 683 684 txt = responderid_str(rd->responderID); 685 if (txt) { 686 wpa_printf(MSG_DEBUG, "OpenSSL: OCSP responderID: %s", 687 txt); 688 os_free(txt); 689 } 690 691 txt = generalizedtime_str(rd->producedAt); 692 if (txt) { 693 wpa_printf(MSG_DEBUG, "OpenSSL: OCSP producedAt: %s", 694 txt); 695 os_free(txt); 696 } 697 698 num_resp = sk_SingleResponse_num(rd->responses); 699 if (num_resp == 0) { 700 wpa_printf(MSG_DEBUG, 701 "OpenSSL: No OCSP SingleResponse within BasicOCSPResponse"); 702 result = OCSP_NO_RESPONSE; 703 goto fail; 704 } 705 cmp_sresp = sk_SingleResponse_value(rd->responses, 0); 706 for (j = 0; j < num_resp; j++) { 707 SingleResponse *sresp; 708 CertID *cid1, *cid2; 709 710 sresp = sk_SingleResponse_value(rd->responses, j); 711 wpa_printf(MSG_DEBUG, "OpenSSL: OCSP SingleResponse %u/%u", 712 j + 1, num_resp); 713 714 txt = algor_str(sresp->certID->hashAlgorithm); 715 if (txt) { 716 wpa_printf(MSG_DEBUG, 717 "OpenSSL: certID hashAlgorithm: %s", txt); 718 os_free(txt); 719 } 720 721 txt = octet_string_str(sresp->certID->issuerNameHash); 722 if (txt) { 723 wpa_printf(MSG_DEBUG, 724 "OpenSSL: certID issuerNameHash: %s", txt); 725 os_free(txt); 726 } 727 728 txt = octet_string_str(sresp->certID->issuerKeyHash); 729 if (txt) { 730 wpa_printf(MSG_DEBUG, 731 "OpenSSL: certID issuerKeyHash: %s", txt); 732 os_free(txt); 733 } 734 735 txt = integer_str(sresp->certID->serialNumber); 736 if (txt) { 737 wpa_printf(MSG_DEBUG, 738 "OpenSSL: certID serialNumber: %s", txt); 739 os_free(txt); 740 } 741 742 switch (sresp->certStatus->type) { 743 case 0: 744 wpa_printf(MSG_DEBUG, "OpenSSL: certStatus: good"); 745 break; 746 case 1: 747 wpa_printf(MSG_DEBUG, "OpenSSL: certStatus: revoked"); 748 break; 749 default: 750 wpa_printf(MSG_DEBUG, "OpenSSL: certStatus: unknown"); 751 break; 752 } 753 754 txt = generalizedtime_str(sresp->thisUpdate); 755 if (txt) { 756 wpa_printf(MSG_DEBUG, "OpenSSL: thisUpdate: %s", txt); 757 os_free(txt); 758 } 759 760 if (sresp->nextUpdate) { 761 txt = generalizedtime_str(sresp->nextUpdate); 762 if (txt) { 763 wpa_printf(MSG_DEBUG, "OpenSSL: nextUpdate: %s", 764 txt); 765 os_free(txt); 766 } 767 } 768 769 txt = extensions_str("singleExtensions", 770 sresp->singleExtensions); 771 if (txt) { 772 wpa_printf(MSG_DEBUG, "OpenSSL: %s", txt); 773 os_free(txt); 774 } 775 776 cid1 = cmp_sresp->certID; 777 cid2 = sresp->certID; 778 if (j > 0 && 779 (OBJ_cmp(cid1->hashAlgorithm->algorithm, 780 cid2->hashAlgorithm->algorithm) != 0 || 781 ASN1_OCTET_STRING_cmp(cid1->issuerNameHash, 782 cid2->issuerNameHash) != 0 || 783 ASN1_OCTET_STRING_cmp(cid1->issuerKeyHash, 784 cid2->issuerKeyHash) != 0)) { 785 wpa_printf(MSG_DEBUG, 786 "OpenSSL: Different OCSP response issuer information between SingleResponse values within BasicOCSPResponse"); 787 goto fail; 788 } 789 790 if (!matching_resp && issuer && 791 ASN1_INTEGER_cmp(sresp->certID->serialNumber, 792 X509_get_serialNumber(cert)) == 0 && 793 issuer_match(cert, issuer, sresp->certID) == 0) { 794 wpa_printf(MSG_DEBUG, 795 "OpenSSL: This response matches peer certificate"); 796 matching_resp = sresp; 797 } 798 } 799 800 txt = extensions_str("responseExtensions", rd->responseExtensions); 801 if (txt) { 802 wpa_printf(MSG_DEBUG, "OpenSSL: %s", txt); 803 os_free(txt); 804 } 805 806 if (!matching_resp) { 807 wpa_printf(MSG_DEBUG, 808 "OpenSSL: Could not find OCSP response that matches the peer certificate"); 809 result = OCSP_NO_RESPONSE; 810 goto fail; 811 } 812 813 if (!ocsp_resp_valid(matching_resp->thisUpdate, 814 matching_resp->nextUpdate)) { 815 wpa_printf(MSG_DEBUG, 816 "OpenSSL: OCSP response not valid at this time"); 817 goto fail; 818 } 819 820 if (matching_resp->certStatus->type == 1) { 821 wpa_printf(MSG_DEBUG, 822 "OpenSSL: OCSP response indicated that the peer certificate has been revoked"); 823 result = OCSP_REVOKED; 824 goto fail; 825 } 826 827 if (matching_resp->certStatus->type != 0) { 828 wpa_printf(MSG_DEBUG, 829 "OpenSSL: OCSP response did not indicate good status"); 830 result = OCSP_NO_RESPONSE; 831 goto fail; 832 } 833 834 /* OCSP response indicated the certificate is good. */ 835 result = OCSP_GOOD; 836 fail: 837 sk_X509_pop_free(chain, X509_free); 838 sk_X509_free(untrusted); 839 sk_X509_pop_free(certs, X509_free); 840 BasicOCSPResponse_free(basic); 841 OCSPResponse_free(resp); 842 843 return result; 844 } 845 846 #endif /* OPENSSL_IS_BORINGSSL */ 847