s_cb.c revision 1.1
1 /* 2 * Copyright 1995-2025 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the Apache License 2.0 (the "License"). You may not use 5 * this file except in compliance with the License. You can obtain a copy 6 * in the file LICENSE in the source distribution or at 7 * https://www.openssl.org/source/license.html 8 */ 9 10 /* 11 * callback functions used by s_client, s_server, and s_time, 12 * as well as other common logic for those apps 13 */ 14 #include <stdio.h> 15 #include <stdlib.h> 16 #include <string.h> /* for memcpy() and strcmp() */ 17 #include "apps.h" 18 #include <openssl/core_names.h> 19 #include <openssl/params.h> 20 #include <openssl/err.h> 21 #include <openssl/rand.h> 22 #include <openssl/x509.h> 23 #include <openssl/ssl.h> 24 #include <openssl/bn.h> 25 #ifndef OPENSSL_NO_DH 26 # include <openssl/dh.h> 27 #endif 28 #include "s_apps.h" 29 30 #define COOKIE_SECRET_LENGTH 16 31 32 VERIFY_CB_ARGS verify_args = { -1, 0, X509_V_OK, 0 }; 33 34 #ifndef OPENSSL_NO_SOCK 35 static unsigned char cookie_secret[COOKIE_SECRET_LENGTH]; 36 static int cookie_initialized = 0; 37 #endif 38 static BIO *bio_keylog = NULL; 39 40 static const char *lookup(int val, const STRINT_PAIR* list, const char* def) 41 { 42 for ( ; list->name; ++list) 43 if (list->retval == val) 44 return list->name; 45 return def; 46 } 47 48 int verify_callback(int ok, X509_STORE_CTX *ctx) 49 { 50 X509 *err_cert; 51 int err, depth; 52 53 err_cert = X509_STORE_CTX_get_current_cert(ctx); 54 err = X509_STORE_CTX_get_error(ctx); 55 depth = X509_STORE_CTX_get_error_depth(ctx); 56 57 if (!verify_args.quiet || !ok) { 58 BIO_printf(bio_err, "depth=%d ", depth); 59 if (err_cert != NULL) { 60 X509_NAME_print_ex(bio_err, 61 X509_get_subject_name(err_cert), 62 0, get_nameopt()); 63 BIO_puts(bio_err, "\n"); 64 } else { 65 BIO_puts(bio_err, "<no cert>\n"); 66 } 67 } 68 if (!ok) { 69 BIO_printf(bio_err, "verify error:num=%d:%s\n", err, 70 X509_verify_cert_error_string(err)); 71 if (verify_args.depth < 0 || verify_args.depth >= depth) { 72 if (!verify_args.return_error) 73 ok = 1; 74 verify_args.error = err; 75 } else { 76 ok = 0; 77 verify_args.error = X509_V_ERR_CERT_CHAIN_TOO_LONG; 78 } 79 } 80 switch (err) { 81 case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT: 82 if (err_cert != NULL) { 83 BIO_puts(bio_err, "issuer= "); 84 X509_NAME_print_ex(bio_err, X509_get_issuer_name(err_cert), 85 0, get_nameopt()); 86 BIO_puts(bio_err, "\n"); 87 } 88 break; 89 case X509_V_ERR_CERT_NOT_YET_VALID: 90 case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD: 91 if (err_cert != NULL) { 92 BIO_printf(bio_err, "notBefore="); 93 ASN1_TIME_print(bio_err, X509_get0_notBefore(err_cert)); 94 BIO_printf(bio_err, "\n"); 95 } 96 break; 97 case X509_V_ERR_CERT_HAS_EXPIRED: 98 case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD: 99 if (err_cert != NULL) { 100 BIO_printf(bio_err, "notAfter="); 101 ASN1_TIME_print(bio_err, X509_get0_notAfter(err_cert)); 102 BIO_printf(bio_err, "\n"); 103 } 104 break; 105 case X509_V_ERR_NO_EXPLICIT_POLICY: 106 if (!verify_args.quiet) 107 policies_print(ctx); 108 break; 109 } 110 if (err == X509_V_OK && ok == 2 && !verify_args.quiet) 111 policies_print(ctx); 112 if (ok && !verify_args.quiet) 113 BIO_printf(bio_err, "verify return:%d\n", ok); 114 return ok; 115 } 116 117 int set_cert_stuff(SSL_CTX *ctx, char *cert_file, char *key_file) 118 { 119 if (cert_file != NULL) { 120 if (SSL_CTX_use_certificate_file(ctx, cert_file, 121 SSL_FILETYPE_PEM) <= 0) { 122 BIO_printf(bio_err, "unable to get certificate from '%s'\n", 123 cert_file); 124 ERR_print_errors(bio_err); 125 return 0; 126 } 127 if (key_file == NULL) 128 key_file = cert_file; 129 if (SSL_CTX_use_PrivateKey_file(ctx, key_file, SSL_FILETYPE_PEM) <= 0) { 130 BIO_printf(bio_err, "unable to get private key from '%s'\n", 131 key_file); 132 ERR_print_errors(bio_err); 133 return 0; 134 } 135 136 /* 137 * If we are using DSA, we can copy the parameters from the private 138 * key 139 */ 140 141 /* 142 * Now we know that a key and cert have been set against the SSL 143 * context 144 */ 145 if (!SSL_CTX_check_private_key(ctx)) { 146 BIO_printf(bio_err, 147 "Private key does not match the certificate public key\n"); 148 return 0; 149 } 150 } 151 return 1; 152 } 153 154 int set_cert_key_stuff(SSL_CTX *ctx, X509 *cert, EVP_PKEY *key, 155 STACK_OF(X509) *chain, int build_chain) 156 { 157 int chflags = chain ? SSL_BUILD_CHAIN_FLAG_CHECK : 0; 158 159 if (cert == NULL) 160 return 1; 161 if (SSL_CTX_use_certificate(ctx, cert) <= 0) { 162 BIO_printf(bio_err, "error setting certificate\n"); 163 ERR_print_errors(bio_err); 164 return 0; 165 } 166 167 if (SSL_CTX_use_PrivateKey(ctx, key) <= 0) { 168 BIO_printf(bio_err, "error setting private key\n"); 169 ERR_print_errors(bio_err); 170 return 0; 171 } 172 173 /* 174 * Now we know that a key and cert have been set against the SSL context 175 */ 176 if (!SSL_CTX_check_private_key(ctx)) { 177 BIO_printf(bio_err, 178 "Private key does not match the certificate public key\n"); 179 return 0; 180 } 181 if (chain && !SSL_CTX_set1_chain(ctx, chain)) { 182 BIO_printf(bio_err, "error setting certificate chain\n"); 183 ERR_print_errors(bio_err); 184 return 0; 185 } 186 if (build_chain && !SSL_CTX_build_cert_chain(ctx, chflags)) { 187 BIO_printf(bio_err, "error building certificate chain\n"); 188 ERR_print_errors(bio_err); 189 return 0; 190 } 191 return 1; 192 } 193 194 static STRINT_PAIR cert_type_list[] = { 195 {"RSA sign", TLS_CT_RSA_SIGN}, 196 {"DSA sign", TLS_CT_DSS_SIGN}, 197 {"RSA fixed DH", TLS_CT_RSA_FIXED_DH}, 198 {"DSS fixed DH", TLS_CT_DSS_FIXED_DH}, 199 {"ECDSA sign", TLS_CT_ECDSA_SIGN}, 200 {"RSA fixed ECDH", TLS_CT_RSA_FIXED_ECDH}, 201 {"ECDSA fixed ECDH", TLS_CT_ECDSA_FIXED_ECDH}, 202 {"GOST01 Sign", TLS_CT_GOST01_SIGN}, 203 {"GOST12 Sign", TLS_CT_GOST12_IANA_SIGN}, 204 {NULL} 205 }; 206 207 static void ssl_print_client_cert_types(BIO *bio, SSL *s) 208 { 209 const unsigned char *p; 210 int i; 211 int cert_type_num = SSL_get0_certificate_types(s, &p); 212 213 if (!cert_type_num) 214 return; 215 BIO_puts(bio, "Client Certificate Types: "); 216 for (i = 0; i < cert_type_num; i++) { 217 unsigned char cert_type = p[i]; 218 const char *cname = lookup((int)cert_type, cert_type_list, NULL); 219 220 if (i) 221 BIO_puts(bio, ", "); 222 if (cname != NULL) 223 BIO_puts(bio, cname); 224 else 225 BIO_printf(bio, "UNKNOWN (%d),", cert_type); 226 } 227 BIO_puts(bio, "\n"); 228 } 229 230 static const char *get_sigtype(int nid) 231 { 232 switch (nid) { 233 case EVP_PKEY_RSA: 234 return "RSA"; 235 236 case EVP_PKEY_RSA_PSS: 237 return "RSA-PSS"; 238 239 case EVP_PKEY_DSA: 240 return "DSA"; 241 242 case EVP_PKEY_EC: 243 return "ECDSA"; 244 245 case NID_ED25519: 246 return "ed25519"; 247 248 case NID_ED448: 249 return "ed448"; 250 251 case NID_id_GostR3410_2001: 252 return "gost2001"; 253 254 case NID_id_GostR3410_2012_256: 255 return "gost2012_256"; 256 257 case NID_id_GostR3410_2012_512: 258 return "gost2012_512"; 259 260 default: 261 /* Try to output provider-registered sig alg name */ 262 return OBJ_nid2sn(nid); 263 } 264 } 265 266 static int do_print_sigalgs(BIO *out, SSL *s, int shared) 267 { 268 int i, nsig, client; 269 270 client = SSL_is_server(s) ? 0 : 1; 271 if (shared) 272 nsig = SSL_get_shared_sigalgs(s, 0, NULL, NULL, NULL, NULL, NULL); 273 else 274 nsig = SSL_get_sigalgs(s, -1, NULL, NULL, NULL, NULL, NULL); 275 if (nsig == 0) 276 return 1; 277 278 if (shared) 279 BIO_puts(out, "Shared "); 280 281 if (client) 282 BIO_puts(out, "Requested "); 283 BIO_puts(out, "Signature Algorithms: "); 284 for (i = 0; i < nsig; i++) { 285 int hash_nid, sign_nid; 286 unsigned char rhash, rsign; 287 const char *sstr = NULL; 288 if (shared) 289 SSL_get_shared_sigalgs(s, i, &sign_nid, &hash_nid, NULL, 290 &rsign, &rhash); 291 else 292 SSL_get_sigalgs(s, i, &sign_nid, &hash_nid, NULL, &rsign, &rhash); 293 if (i) 294 BIO_puts(out, ":"); 295 switch (rsign | rhash << 8) { 296 case 0x0809: 297 BIO_puts(out, "rsa_pss_pss_sha256"); 298 continue; 299 case 0x080a: 300 BIO_puts(out, "rsa_pss_pss_sha384"); 301 continue; 302 case 0x080b: 303 BIO_puts(out, "rsa_pss_pss_sha512"); 304 continue; 305 case 0x081a: 306 BIO_puts(out, "ecdsa_brainpoolP256r1_sha256"); 307 continue; 308 case 0x081b: 309 BIO_puts(out, "ecdsa_brainpoolP384r1_sha384"); 310 continue; 311 case 0x081c: 312 BIO_puts(out, "ecdsa_brainpoolP512r1_sha512"); 313 continue; 314 } 315 sstr = get_sigtype(sign_nid); 316 if (sstr) 317 BIO_printf(out, "%s", sstr); 318 else 319 BIO_printf(out, "0x%02X", (int)rsign); 320 if (hash_nid != NID_undef) 321 BIO_printf(out, "+%s", OBJ_nid2sn(hash_nid)); 322 else if (sstr == NULL) 323 BIO_printf(out, "+0x%02X", (int)rhash); 324 } 325 BIO_puts(out, "\n"); 326 return 1; 327 } 328 329 int ssl_print_sigalgs(BIO *out, SSL *s) 330 { 331 const char *name; 332 int nid; 333 334 if (!SSL_is_server(s)) 335 ssl_print_client_cert_types(out, s); 336 do_print_sigalgs(out, s, 0); 337 do_print_sigalgs(out, s, 1); 338 if (SSL_get_peer_signature_nid(s, &nid) && nid != NID_undef) 339 BIO_printf(out, "Peer signing digest: %s\n", OBJ_nid2sn(nid)); 340 if (SSL_get0_peer_signature_name(s, &name)) 341 BIO_printf(out, "Peer signature type: %s\n", name); 342 else if (SSL_get_peer_signature_type_nid(s, &nid)) 343 BIO_printf(out, "Peer signature type: %s\n", get_sigtype(nid)); 344 return 1; 345 } 346 347 #ifndef OPENSSL_NO_EC 348 int ssl_print_point_formats(BIO *out, SSL *s) 349 { 350 int i, nformats; 351 const char *pformats; 352 353 nformats = SSL_get0_ec_point_formats(s, &pformats); 354 if (nformats <= 0) 355 return 1; 356 BIO_puts(out, "Supported Elliptic Curve Point Formats: "); 357 for (i = 0; i < nformats; i++, pformats++) { 358 if (i) 359 BIO_puts(out, ":"); 360 switch (*pformats) { 361 case TLSEXT_ECPOINTFORMAT_uncompressed: 362 BIO_puts(out, "uncompressed"); 363 break; 364 365 case TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime: 366 BIO_puts(out, "ansiX962_compressed_prime"); 367 break; 368 369 case TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2: 370 BIO_puts(out, "ansiX962_compressed_char2"); 371 break; 372 373 default: 374 BIO_printf(out, "unknown(%d)", (int)*pformats); 375 break; 376 377 } 378 } 379 BIO_puts(out, "\n"); 380 return 1; 381 } 382 383 int ssl_print_groups(BIO *out, SSL *s, int noshared) 384 { 385 int i, ngroups, *groups, nid; 386 387 ngroups = SSL_get1_groups(s, NULL); 388 if (ngroups <= 0) 389 return 1; 390 groups = app_malloc(ngroups * sizeof(int), "groups to print"); 391 SSL_get1_groups(s, groups); 392 393 BIO_puts(out, "Supported groups: "); 394 for (i = 0; i < ngroups; i++) { 395 if (i) 396 BIO_puts(out, ":"); 397 nid = groups[i]; 398 BIO_printf(out, "%s", SSL_group_to_name(s, nid)); 399 } 400 OPENSSL_free(groups); 401 if (noshared) { 402 BIO_puts(out, "\n"); 403 return 1; 404 } 405 BIO_puts(out, "\nShared groups: "); 406 ngroups = SSL_get_shared_group(s, -1); 407 for (i = 0; i < ngroups; i++) { 408 if (i) 409 BIO_puts(out, ":"); 410 nid = SSL_get_shared_group(s, i); 411 BIO_printf(out, "%s", SSL_group_to_name(s, nid)); 412 } 413 if (ngroups == 0) 414 BIO_puts(out, "NONE"); 415 BIO_puts(out, "\n"); 416 return 1; 417 } 418 #endif 419 420 int ssl_print_tmp_key(BIO *out, SSL *s) 421 { 422 const char *keyname; 423 EVP_PKEY *key; 424 425 if (!SSL_get_peer_tmp_key(s, &key)) { 426 if (SSL_version(s) == TLS1_3_VERSION) 427 BIO_printf(out, "Negotiated TLS1.3 group: %s\n", 428 SSL_group_to_name(s, SSL_get_negotiated_group(s))); 429 return 1; 430 } 431 432 BIO_puts(out, "Peer Temp Key: "); 433 switch (EVP_PKEY_get_id(key)) { 434 case EVP_PKEY_RSA: 435 BIO_printf(out, "RSA, %d bits\n", EVP_PKEY_get_bits(key)); 436 break; 437 438 case EVP_PKEY_KEYMGMT: 439 if ((keyname = EVP_PKEY_get0_type_name(key)) == NULL) 440 keyname = "?"; 441 BIO_printf(out, "%s\n", keyname); 442 break; 443 444 case EVP_PKEY_DH: 445 BIO_printf(out, "DH, %d bits\n", EVP_PKEY_get_bits(key)); 446 break; 447 #ifndef OPENSSL_NO_EC 448 case EVP_PKEY_EC: 449 { 450 char name[80]; 451 size_t name_len; 452 453 if (!EVP_PKEY_get_utf8_string_param(key, OSSL_PKEY_PARAM_GROUP_NAME, 454 name, sizeof(name), &name_len)) 455 strcpy(name, "?"); 456 BIO_printf(out, "ECDH, %s, %d bits\n", name, EVP_PKEY_get_bits(key)); 457 } 458 break; 459 #endif 460 default: 461 BIO_printf(out, "%s, %d bits\n", OBJ_nid2sn(EVP_PKEY_get_id(key)), 462 EVP_PKEY_get_bits(key)); 463 } 464 EVP_PKEY_free(key); 465 return 1; 466 } 467 468 long bio_dump_callback(BIO *bio, int cmd, const char *argp, size_t len, 469 int argi, long argl, int ret, size_t *processed) 470 { 471 BIO *out; 472 BIO_MMSG_CB_ARGS *mmsgargs; 473 size_t i; 474 475 out = (BIO *)BIO_get_callback_arg(bio); 476 if (out == NULL) 477 return ret; 478 479 switch (cmd) { 480 case (BIO_CB_READ | BIO_CB_RETURN): 481 if (ret > 0 && processed != NULL) { 482 BIO_printf(out, "read from %p [%p] (%zu bytes => %zu (0x%zX))\n", 483 (void *)bio, (void *)argp, len, *processed, *processed); 484 BIO_dump(out, argp, (int)*processed); 485 } else { 486 BIO_printf(out, "read from %p [%p] (%zu bytes => %d)\n", 487 (void *)bio, (void *)argp, len, ret); 488 } 489 break; 490 491 case (BIO_CB_WRITE | BIO_CB_RETURN): 492 if (ret > 0 && processed != NULL) { 493 BIO_printf(out, "write to %p [%p] (%zu bytes => %zu (0x%zX))\n", 494 (void *)bio, (void *)argp, len, *processed, *processed); 495 BIO_dump(out, argp, (int)*processed); 496 } else { 497 BIO_printf(out, "write to %p [%p] (%zu bytes => %d)\n", 498 (void *)bio, (void *)argp, len, ret); 499 } 500 break; 501 502 case (BIO_CB_RECVMMSG | BIO_CB_RETURN): 503 mmsgargs = (BIO_MMSG_CB_ARGS *)argp; 504 if (ret > 0) { 505 for (i = 0; i < *(mmsgargs->msgs_processed); i++) { 506 BIO_MSG *msg = (BIO_MSG *)((char *)mmsgargs->msg 507 + (i * mmsgargs->stride)); 508 509 BIO_printf(out, "read from %p [%p] (%zu bytes => %zu (0x%zX))\n", 510 (void *)bio, (void *)msg->data, msg->data_len, 511 msg->data_len, msg->data_len); 512 BIO_dump(out, msg->data, msg->data_len); 513 } 514 } else if (mmsgargs->num_msg > 0) { 515 BIO_MSG *msg = mmsgargs->msg; 516 517 BIO_printf(out, "read from %p [%p] (%zu bytes => %d)\n", 518 (void *)bio, (void *)msg->data, msg->data_len, ret); 519 } 520 break; 521 522 case (BIO_CB_SENDMMSG | BIO_CB_RETURN): 523 mmsgargs = (BIO_MMSG_CB_ARGS *)argp; 524 if (ret > 0) { 525 for (i = 0; i < *(mmsgargs->msgs_processed); i++) { 526 BIO_MSG *msg = (BIO_MSG *)((char *)mmsgargs->msg 527 + (i * mmsgargs->stride)); 528 529 BIO_printf(out, "write to %p [%p] (%zu bytes => %zu (0x%zX))\n", 530 (void *)bio, (void *)msg->data, msg->data_len, 531 msg->data_len, msg->data_len); 532 BIO_dump(out, msg->data, msg->data_len); 533 } 534 } else if (mmsgargs->num_msg > 0) { 535 BIO_MSG *msg = mmsgargs->msg; 536 537 BIO_printf(out, "write to %p [%p] (%zu bytes => %d)\n", 538 (void *)bio, (void *)msg->data, msg->data_len, ret); 539 } 540 break; 541 542 default: 543 /* do nothing */ 544 break; 545 } 546 return ret; 547 } 548 549 void apps_ssl_info_callback(const SSL *s, int where, int ret) 550 { 551 const char *str; 552 int w; 553 554 w = where & ~SSL_ST_MASK; 555 556 if (w & SSL_ST_CONNECT) 557 str = "SSL_connect"; 558 else if (w & SSL_ST_ACCEPT) 559 str = "SSL_accept"; 560 else 561 str = "undefined"; 562 563 if (where & SSL_CB_LOOP) { 564 BIO_printf(bio_err, "%s:%s\n", str, SSL_state_string_long(s)); 565 } else if (where & SSL_CB_ALERT) { 566 str = (where & SSL_CB_READ) ? "read" : "write"; 567 BIO_printf(bio_err, "SSL3 alert %s:%s:%s\n", 568 str, 569 SSL_alert_type_string_long(ret), 570 SSL_alert_desc_string_long(ret)); 571 } else if (where & SSL_CB_EXIT) { 572 if (ret == 0) 573 BIO_printf(bio_err, "%s:failed in %s\n", 574 str, SSL_state_string_long(s)); 575 else if (ret < 0) 576 BIO_printf(bio_err, "%s:error in %s\n", 577 str, SSL_state_string_long(s)); 578 } 579 } 580 581 static STRINT_PAIR ssl_versions[] = { 582 {"SSL 3.0", SSL3_VERSION}, 583 {"TLS 1.0", TLS1_VERSION}, 584 {"TLS 1.1", TLS1_1_VERSION}, 585 {"TLS 1.2", TLS1_2_VERSION}, 586 {"TLS 1.3", TLS1_3_VERSION}, 587 {"DTLS 1.0", DTLS1_VERSION}, 588 {"DTLS 1.0 (bad)", DTLS1_BAD_VER}, 589 {NULL} 590 }; 591 592 static STRINT_PAIR alert_types[] = { 593 {" close_notify", 0}, 594 {" end_of_early_data", 1}, 595 {" unexpected_message", 10}, 596 {" bad_record_mac", 20}, 597 {" decryption_failed", 21}, 598 {" record_overflow", 22}, 599 {" decompression_failure", 30}, 600 {" handshake_failure", 40}, 601 {" bad_certificate", 42}, 602 {" unsupported_certificate", 43}, 603 {" certificate_revoked", 44}, 604 {" certificate_expired", 45}, 605 {" certificate_unknown", 46}, 606 {" illegal_parameter", 47}, 607 {" unknown_ca", 48}, 608 {" access_denied", 49}, 609 {" decode_error", 50}, 610 {" decrypt_error", 51}, 611 {" export_restriction", 60}, 612 {" protocol_version", 70}, 613 {" insufficient_security", 71}, 614 {" internal_error", 80}, 615 {" inappropriate_fallback", 86}, 616 {" user_canceled", 90}, 617 {" no_renegotiation", 100}, 618 {" missing_extension", 109}, 619 {" unsupported_extension", 110}, 620 {" certificate_unobtainable", 111}, 621 {" unrecognized_name", 112}, 622 {" bad_certificate_status_response", 113}, 623 {" bad_certificate_hash_value", 114}, 624 {" unknown_psk_identity", 115}, 625 {" certificate_required", 116}, 626 {NULL} 627 }; 628 629 static STRINT_PAIR handshakes[] = { 630 {", HelloRequest", SSL3_MT_HELLO_REQUEST}, 631 {", ClientHello", SSL3_MT_CLIENT_HELLO}, 632 {", ServerHello", SSL3_MT_SERVER_HELLO}, 633 {", HelloVerifyRequest", DTLS1_MT_HELLO_VERIFY_REQUEST}, 634 {", NewSessionTicket", SSL3_MT_NEWSESSION_TICKET}, 635 {", EndOfEarlyData", SSL3_MT_END_OF_EARLY_DATA}, 636 {", EncryptedExtensions", SSL3_MT_ENCRYPTED_EXTENSIONS}, 637 {", Certificate", SSL3_MT_CERTIFICATE}, 638 {", ServerKeyExchange", SSL3_MT_SERVER_KEY_EXCHANGE}, 639 {", CertificateRequest", SSL3_MT_CERTIFICATE_REQUEST}, 640 {", ServerHelloDone", SSL3_MT_SERVER_DONE}, 641 {", CertificateVerify", SSL3_MT_CERTIFICATE_VERIFY}, 642 {", ClientKeyExchange", SSL3_MT_CLIENT_KEY_EXCHANGE}, 643 {", Finished", SSL3_MT_FINISHED}, 644 {", CertificateUrl", SSL3_MT_CERTIFICATE_URL}, 645 {", CertificateStatus", SSL3_MT_CERTIFICATE_STATUS}, 646 {", SupplementalData", SSL3_MT_SUPPLEMENTAL_DATA}, 647 {", KeyUpdate", SSL3_MT_KEY_UPDATE}, 648 {", CompressedCertificate", SSL3_MT_COMPRESSED_CERTIFICATE}, 649 #ifndef OPENSSL_NO_NEXTPROTONEG 650 {", NextProto", SSL3_MT_NEXT_PROTO}, 651 #endif 652 {", MessageHash", SSL3_MT_MESSAGE_HASH}, 653 {NULL} 654 }; 655 656 void msg_cb(int write_p, int version, int content_type, const void *buf, 657 size_t len, SSL *ssl, void *arg) 658 { 659 BIO *bio = arg; 660 const char *str_write_p = write_p ? ">>>" : "<<<"; 661 char tmpbuf[128]; 662 const char *str_version, *str_content_type = "", *str_details1 = "", *str_details2 = ""; 663 const unsigned char* bp = buf; 664 665 if (version == SSL3_VERSION || 666 version == TLS1_VERSION || 667 version == TLS1_1_VERSION || 668 version == TLS1_2_VERSION || 669 version == TLS1_3_VERSION || 670 version == DTLS1_VERSION || version == DTLS1_BAD_VER) { 671 str_version = lookup(version, ssl_versions, "???"); 672 switch (content_type) { 673 case SSL3_RT_CHANGE_CIPHER_SPEC: 674 /* type 20 */ 675 str_content_type = ", ChangeCipherSpec"; 676 break; 677 case SSL3_RT_ALERT: 678 /* type 21 */ 679 str_content_type = ", Alert"; 680 str_details1 = ", ???"; 681 if (len == 2) { 682 switch (bp[0]) { 683 case 1: 684 str_details1 = ", warning"; 685 break; 686 case 2: 687 str_details1 = ", fatal"; 688 break; 689 } 690 str_details2 = lookup((int)bp[1], alert_types, " ???"); 691 } 692 break; 693 case SSL3_RT_HANDSHAKE: 694 /* type 22 */ 695 str_content_type = ", Handshake"; 696 str_details1 = "???"; 697 if (len > 0) 698 str_details1 = lookup((int)bp[0], handshakes, "???"); 699 break; 700 case SSL3_RT_APPLICATION_DATA: 701 /* type 23 */ 702 str_content_type = ", ApplicationData"; 703 break; 704 case SSL3_RT_HEADER: 705 /* type 256 */ 706 str_content_type = ", RecordHeader"; 707 break; 708 case SSL3_RT_INNER_CONTENT_TYPE: 709 /* type 257 */ 710 str_content_type = ", InnerContent"; 711 break; 712 default: 713 BIO_snprintf(tmpbuf, sizeof(tmpbuf)-1, ", Unknown (content_type=%d)", content_type); 714 str_content_type = tmpbuf; 715 } 716 } else { 717 BIO_snprintf(tmpbuf, sizeof(tmpbuf)-1, "Not TLS data or unknown version (version=%d, content_type=%d)", version, content_type); 718 str_version = tmpbuf; 719 } 720 721 BIO_printf(bio, "%s %s%s [length %04lx]%s%s\n", str_write_p, str_version, 722 str_content_type, (unsigned long)len, str_details1, 723 str_details2); 724 725 if (len > 0) { 726 size_t num, i; 727 728 BIO_printf(bio, " "); 729 num = len; 730 for (i = 0; i < num; i++) { 731 if (i % 16 == 0 && i > 0) 732 BIO_printf(bio, "\n "); 733 BIO_printf(bio, " %02x", ((const unsigned char *)buf)[i]); 734 } 735 if (i < len) 736 BIO_printf(bio, " ..."); 737 BIO_printf(bio, "\n"); 738 } 739 (void)BIO_flush(bio); 740 } 741 742 static const STRINT_PAIR tlsext_types[] = { 743 {"server name", TLSEXT_TYPE_server_name}, 744 {"max fragment length", TLSEXT_TYPE_max_fragment_length}, 745 {"client certificate URL", TLSEXT_TYPE_client_certificate_url}, 746 {"trusted CA keys", TLSEXT_TYPE_trusted_ca_keys}, 747 {"truncated HMAC", TLSEXT_TYPE_truncated_hmac}, 748 {"status request", TLSEXT_TYPE_status_request}, 749 {"user mapping", TLSEXT_TYPE_user_mapping}, 750 {"client authz", TLSEXT_TYPE_client_authz}, 751 {"server authz", TLSEXT_TYPE_server_authz}, 752 {"cert type", TLSEXT_TYPE_cert_type}, 753 {"supported_groups", TLSEXT_TYPE_supported_groups}, 754 {"EC point formats", TLSEXT_TYPE_ec_point_formats}, 755 {"SRP", TLSEXT_TYPE_srp}, 756 {"signature algorithms", TLSEXT_TYPE_signature_algorithms}, 757 {"use SRTP", TLSEXT_TYPE_use_srtp}, 758 {"session ticket", TLSEXT_TYPE_session_ticket}, 759 {"renegotiation info", TLSEXT_TYPE_renegotiate}, 760 {"signed certificate timestamps", TLSEXT_TYPE_signed_certificate_timestamp}, 761 {"client cert type", TLSEXT_TYPE_client_cert_type}, 762 {"server cert type", TLSEXT_TYPE_server_cert_type}, 763 {"TLS padding", TLSEXT_TYPE_padding}, 764 #ifdef TLSEXT_TYPE_next_proto_neg 765 {"next protocol", TLSEXT_TYPE_next_proto_neg}, 766 #endif 767 #ifdef TLSEXT_TYPE_encrypt_then_mac 768 {"encrypt-then-mac", TLSEXT_TYPE_encrypt_then_mac}, 769 #endif 770 #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation 771 {"application layer protocol negotiation", 772 TLSEXT_TYPE_application_layer_protocol_negotiation}, 773 #endif 774 #ifdef TLSEXT_TYPE_extended_master_secret 775 {"extended master secret", TLSEXT_TYPE_extended_master_secret}, 776 #endif 777 {"compress certificate", TLSEXT_TYPE_compress_certificate}, 778 {"key share", TLSEXT_TYPE_key_share}, 779 {"supported versions", TLSEXT_TYPE_supported_versions}, 780 {"psk", TLSEXT_TYPE_psk}, 781 {"psk kex modes", TLSEXT_TYPE_psk_kex_modes}, 782 {"certificate authorities", TLSEXT_TYPE_certificate_authorities}, 783 {"post handshake auth", TLSEXT_TYPE_post_handshake_auth}, 784 {"early_data", TLSEXT_TYPE_early_data}, 785 {NULL} 786 }; 787 788 /* from rfc8446 4.2.3. + gost (https://tools.ietf.org/id/draft-smyshlyaev-tls12-gost-suites-04.html) */ 789 static STRINT_PAIR signature_tls13_scheme_list[] = { 790 {"rsa_pkcs1_sha1", 0x0201 /* TLSEXT_SIGALG_rsa_pkcs1_sha1 */}, 791 {"ecdsa_sha1", 0x0203 /* TLSEXT_SIGALG_ecdsa_sha1 */}, 792 /* {"rsa_pkcs1_sha224", 0x0301 TLSEXT_SIGALG_rsa_pkcs1_sha224}, not in rfc8446 */ 793 /* {"ecdsa_sha224", 0x0303 TLSEXT_SIGALG_ecdsa_sha224} not in rfc8446 */ 794 {"rsa_pkcs1_sha256", 0x0401 /* TLSEXT_SIGALG_rsa_pkcs1_sha256 */}, 795 {"ecdsa_secp256r1_sha256", 0x0403 /* TLSEXT_SIGALG_ecdsa_secp256r1_sha256 */}, 796 {"rsa_pkcs1_sha384", 0x0501 /* TLSEXT_SIGALG_rsa_pkcs1_sha384 */}, 797 {"ecdsa_secp384r1_sha384", 0x0503 /* TLSEXT_SIGALG_ecdsa_secp384r1_sha384 */}, 798 {"rsa_pkcs1_sha512", 0x0601 /* TLSEXT_SIGALG_rsa_pkcs1_sha512 */}, 799 {"ecdsa_secp521r1_sha512", 0x0603 /* TLSEXT_SIGALG_ecdsa_secp521r1_sha512 */}, 800 {"rsa_pss_rsae_sha256", 0x0804 /* TLSEXT_SIGALG_rsa_pss_rsae_sha256 */}, 801 {"rsa_pss_rsae_sha384", 0x0805 /* TLSEXT_SIGALG_rsa_pss_rsae_sha384 */}, 802 {"rsa_pss_rsae_sha512", 0x0806 /* TLSEXT_SIGALG_rsa_pss_rsae_sha512 */}, 803 {"ed25519", 0x0807 /* TLSEXT_SIGALG_ed25519 */}, 804 {"ed448", 0x0808 /* TLSEXT_SIGALG_ed448 */}, 805 {"rsa_pss_pss_sha256", 0x0809 /* TLSEXT_SIGALG_rsa_pss_pss_sha256 */}, 806 {"rsa_pss_pss_sha384", 0x080a /* TLSEXT_SIGALG_rsa_pss_pss_sha384 */}, 807 {"rsa_pss_pss_sha512", 0x080b /* TLSEXT_SIGALG_rsa_pss_pss_sha512 */}, 808 {"gostr34102001", 0xeded /* TLSEXT_SIGALG_gostr34102001_gostr3411 */}, 809 {"gostr34102012_256", 0xeeee /* TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256 */}, 810 {"gostr34102012_512", 0xefef /* TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512 */}, 811 {NULL} 812 }; 813 814 /* from rfc5246 7.4.1.4.1. */ 815 static STRINT_PAIR signature_tls12_alg_list[] = { 816 {"anonymous", TLSEXT_signature_anonymous /* 0 */}, 817 {"RSA", TLSEXT_signature_rsa /* 1 */}, 818 {"DSA", TLSEXT_signature_dsa /* 2 */}, 819 {"ECDSA", TLSEXT_signature_ecdsa /* 3 */}, 820 {NULL} 821 }; 822 823 /* from rfc5246 7.4.1.4.1. */ 824 static STRINT_PAIR signature_tls12_hash_list[] = { 825 {"none", TLSEXT_hash_none /* 0 */}, 826 {"MD5", TLSEXT_hash_md5 /* 1 */}, 827 {"SHA1", TLSEXT_hash_sha1 /* 2 */}, 828 {"SHA224", TLSEXT_hash_sha224 /* 3 */}, 829 {"SHA256", TLSEXT_hash_sha256 /* 4 */}, 830 {"SHA384", TLSEXT_hash_sha384 /* 5 */}, 831 {"SHA512", TLSEXT_hash_sha512 /* 6 */}, 832 {NULL} 833 }; 834 835 void tlsext_cb(SSL *s, int client_server, int type, 836 const unsigned char *data, int len, void *arg) 837 { 838 BIO *bio = arg; 839 const char *extname = lookup(type, tlsext_types, "unknown"); 840 841 BIO_printf(bio, "TLS %s extension \"%s\" (id=%d), len=%d\n", 842 client_server ? "server" : "client", extname, type, len); 843 BIO_dump(bio, (const char *)data, len); 844 (void)BIO_flush(bio); 845 } 846 847 #ifndef OPENSSL_NO_SOCK 848 int generate_stateless_cookie_callback(SSL *ssl, unsigned char *cookie, 849 size_t *cookie_len) 850 { 851 unsigned char *buffer = NULL; 852 size_t length = 0; 853 unsigned short port; 854 BIO_ADDR *lpeer = NULL, *peer = NULL; 855 int res = 0; 856 857 /* Initialize a random secret */ 858 if (!cookie_initialized) { 859 if (RAND_bytes(cookie_secret, COOKIE_SECRET_LENGTH) <= 0) { 860 BIO_printf(bio_err, "error setting random cookie secret\n"); 861 return 0; 862 } 863 cookie_initialized = 1; 864 } 865 866 if (SSL_is_dtls(ssl)) { 867 lpeer = peer = BIO_ADDR_new(); 868 if (peer == NULL) { 869 BIO_printf(bio_err, "memory full\n"); 870 return 0; 871 } 872 873 /* Read peer information */ 874 (void)BIO_dgram_get_peer(SSL_get_rbio(ssl), peer); 875 } else { 876 peer = ourpeer; 877 } 878 879 /* Create buffer with peer's address and port */ 880 if (!BIO_ADDR_rawaddress(peer, NULL, &length)) { 881 BIO_printf(bio_err, "Failed getting peer address\n"); 882 BIO_ADDR_free(lpeer); 883 return 0; 884 } 885 OPENSSL_assert(length != 0); 886 port = BIO_ADDR_rawport(peer); 887 length += sizeof(port); 888 buffer = app_malloc(length, "cookie generate buffer"); 889 890 memcpy(buffer, &port, sizeof(port)); 891 BIO_ADDR_rawaddress(peer, buffer + sizeof(port), NULL); 892 893 if (EVP_Q_mac(NULL, "HMAC", NULL, "SHA1", NULL, 894 cookie_secret, COOKIE_SECRET_LENGTH, buffer, length, 895 cookie, DTLS1_COOKIE_LENGTH, cookie_len) == NULL) { 896 BIO_printf(bio_err, 897 "Error calculating HMAC-SHA1 of buffer with secret\n"); 898 goto end; 899 } 900 res = 1; 901 end: 902 OPENSSL_free(buffer); 903 BIO_ADDR_free(lpeer); 904 905 return res; 906 } 907 908 int verify_stateless_cookie_callback(SSL *ssl, const unsigned char *cookie, 909 size_t cookie_len) 910 { 911 unsigned char result[EVP_MAX_MD_SIZE]; 912 size_t resultlength; 913 914 /* Note: we check cookie_initialized because if it's not, 915 * it cannot be valid */ 916 if (cookie_initialized 917 && generate_stateless_cookie_callback(ssl, result, &resultlength) 918 && cookie_len == resultlength 919 && memcmp(result, cookie, resultlength) == 0) 920 return 1; 921 922 return 0; 923 } 924 925 int generate_cookie_callback(SSL *ssl, unsigned char *cookie, 926 unsigned int *cookie_len) 927 { 928 size_t temp = 0; 929 int res = generate_stateless_cookie_callback(ssl, cookie, &temp); 930 931 if (res != 0) 932 *cookie_len = (unsigned int)temp; 933 return res; 934 } 935 936 int verify_cookie_callback(SSL *ssl, const unsigned char *cookie, 937 unsigned int cookie_len) 938 { 939 return verify_stateless_cookie_callback(ssl, cookie, cookie_len); 940 } 941 942 #endif 943 944 /* 945 * Example of extended certificate handling. Where the standard support of 946 * one certificate per algorithm is not sufficient an application can decide 947 * which certificate(s) to use at runtime based on whatever criteria it deems 948 * appropriate. 949 */ 950 951 /* Linked list of certificates, keys and chains */ 952 struct ssl_excert_st { 953 int certform; 954 const char *certfile; 955 int keyform; 956 const char *keyfile; 957 const char *chainfile; 958 X509 *cert; 959 EVP_PKEY *key; 960 STACK_OF(X509) *chain; 961 int build_chain; 962 struct ssl_excert_st *next, *prev; 963 }; 964 965 static STRINT_PAIR chain_flags[] = { 966 {"Overall Validity", CERT_PKEY_VALID}, 967 {"Sign with EE key", CERT_PKEY_SIGN}, 968 {"EE signature", CERT_PKEY_EE_SIGNATURE}, 969 {"CA signature", CERT_PKEY_CA_SIGNATURE}, 970 {"EE key parameters", CERT_PKEY_EE_PARAM}, 971 {"CA key parameters", CERT_PKEY_CA_PARAM}, 972 {"Explicitly sign with EE key", CERT_PKEY_EXPLICIT_SIGN}, 973 {"Issuer Name", CERT_PKEY_ISSUER_NAME}, 974 {"Certificate Type", CERT_PKEY_CERT_TYPE}, 975 {NULL} 976 }; 977 978 static void print_chain_flags(SSL *s, int flags) 979 { 980 STRINT_PAIR *pp; 981 982 for (pp = chain_flags; pp->name; ++pp) 983 BIO_printf(bio_err, "\t%s: %s\n", 984 pp->name, 985 (flags & pp->retval) ? "OK" : "NOT OK"); 986 BIO_printf(bio_err, "\tSuite B: "); 987 if (SSL_set_cert_flags(s, 0) & SSL_CERT_FLAG_SUITEB_128_LOS) 988 BIO_puts(bio_err, flags & CERT_PKEY_SUITEB ? "OK\n" : "NOT OK\n"); 989 else 990 BIO_printf(bio_err, "not tested\n"); 991 } 992 993 /* 994 * Very basic selection callback: just use any certificate chain reported as 995 * valid. More sophisticated could prioritise according to local policy. 996 */ 997 static int set_cert_cb(SSL *ssl, void *arg) 998 { 999 int i, rv; 1000 SSL_EXCERT *exc = arg; 1001 #ifdef CERT_CB_TEST_RETRY 1002 static int retry_cnt; 1003 1004 if (retry_cnt < 5) { 1005 retry_cnt++; 1006 BIO_printf(bio_err, 1007 "Certificate callback retry test: count %d\n", 1008 retry_cnt); 1009 return -1; 1010 } 1011 #endif 1012 SSL_certs_clear(ssl); 1013 1014 if (exc == NULL) 1015 return 1; 1016 1017 /* 1018 * Go to end of list and traverse backwards since we prepend newer 1019 * entries this retains the original order. 1020 */ 1021 while (exc->next != NULL) 1022 exc = exc->next; 1023 1024 i = 0; 1025 1026 while (exc != NULL) { 1027 i++; 1028 rv = SSL_check_chain(ssl, exc->cert, exc->key, exc->chain); 1029 BIO_printf(bio_err, "Checking cert chain %d:\nSubject: ", i); 1030 X509_NAME_print_ex(bio_err, X509_get_subject_name(exc->cert), 0, 1031 get_nameopt()); 1032 BIO_puts(bio_err, "\n"); 1033 print_chain_flags(ssl, rv); 1034 if (rv & CERT_PKEY_VALID) { 1035 if (!SSL_use_certificate(ssl, exc->cert) 1036 || !SSL_use_PrivateKey(ssl, exc->key)) { 1037 return 0; 1038 } 1039 /* 1040 * NB: we wouldn't normally do this as it is not efficient 1041 * building chains on each connection better to cache the chain 1042 * in advance. 1043 */ 1044 if (exc->build_chain) { 1045 if (!SSL_build_cert_chain(ssl, 0)) 1046 return 0; 1047 } else if (exc->chain != NULL) { 1048 if (!SSL_set1_chain(ssl, exc->chain)) 1049 return 0; 1050 } 1051 } 1052 exc = exc->prev; 1053 } 1054 return 1; 1055 } 1056 1057 void ssl_ctx_set_excert(SSL_CTX *ctx, SSL_EXCERT *exc) 1058 { 1059 SSL_CTX_set_cert_cb(ctx, set_cert_cb, exc); 1060 } 1061 1062 static int ssl_excert_prepend(SSL_EXCERT **pexc) 1063 { 1064 SSL_EXCERT *exc = app_malloc(sizeof(*exc), "prepend cert"); 1065 1066 memset(exc, 0, sizeof(*exc)); 1067 1068 exc->next = *pexc; 1069 *pexc = exc; 1070 1071 if (exc->next) { 1072 exc->certform = exc->next->certform; 1073 exc->keyform = exc->next->keyform; 1074 exc->next->prev = exc; 1075 } else { 1076 exc->certform = FORMAT_PEM; 1077 exc->keyform = FORMAT_PEM; 1078 } 1079 return 1; 1080 1081 } 1082 1083 void ssl_excert_free(SSL_EXCERT *exc) 1084 { 1085 SSL_EXCERT *curr; 1086 1087 if (exc == NULL) 1088 return; 1089 while (exc) { 1090 X509_free(exc->cert); 1091 EVP_PKEY_free(exc->key); 1092 OSSL_STACK_OF_X509_free(exc->chain); 1093 curr = exc; 1094 exc = exc->next; 1095 OPENSSL_free(curr); 1096 } 1097 } 1098 1099 int load_excert(SSL_EXCERT **pexc) 1100 { 1101 SSL_EXCERT *exc = *pexc; 1102 1103 if (exc == NULL) 1104 return 1; 1105 /* If nothing in list, free and set to NULL */ 1106 if (exc->certfile == NULL && exc->next == NULL) { 1107 ssl_excert_free(exc); 1108 *pexc = NULL; 1109 return 1; 1110 } 1111 for (; exc; exc = exc->next) { 1112 if (exc->certfile == NULL) { 1113 BIO_printf(bio_err, "Missing filename\n"); 1114 return 0; 1115 } 1116 exc->cert = load_cert(exc->certfile, exc->certform, 1117 "Server Certificate"); 1118 if (exc->cert == NULL) 1119 return 0; 1120 if (exc->keyfile != NULL) { 1121 exc->key = load_key(exc->keyfile, exc->keyform, 1122 0, NULL, NULL, "server key"); 1123 } else { 1124 exc->key = load_key(exc->certfile, exc->certform, 1125 0, NULL, NULL, "server key"); 1126 } 1127 if (exc->key == NULL) 1128 return 0; 1129 if (exc->chainfile != NULL) { 1130 if (!load_certs(exc->chainfile, 0, &exc->chain, NULL, "server chain")) 1131 return 0; 1132 } 1133 } 1134 return 1; 1135 } 1136 1137 enum range { OPT_X_ENUM }; 1138 1139 int args_excert(int opt, SSL_EXCERT **pexc) 1140 { 1141 SSL_EXCERT *exc = *pexc; 1142 1143 assert(opt > OPT_X__FIRST); 1144 assert(opt < OPT_X__LAST); 1145 1146 if (exc == NULL) { 1147 if (!ssl_excert_prepend(&exc)) { 1148 BIO_printf(bio_err, " %s: Error initialising xcert\n", 1149 opt_getprog()); 1150 goto err; 1151 } 1152 *pexc = exc; 1153 } 1154 1155 switch ((enum range)opt) { 1156 case OPT_X__FIRST: 1157 case OPT_X__LAST: 1158 return 0; 1159 case OPT_X_CERT: 1160 if (exc->certfile != NULL && !ssl_excert_prepend(&exc)) { 1161 BIO_printf(bio_err, "%s: Error adding xcert\n", opt_getprog()); 1162 goto err; 1163 } 1164 *pexc = exc; 1165 exc->certfile = opt_arg(); 1166 break; 1167 case OPT_X_KEY: 1168 if (exc->keyfile != NULL) { 1169 BIO_printf(bio_err, "%s: Key already specified\n", opt_getprog()); 1170 goto err; 1171 } 1172 exc->keyfile = opt_arg(); 1173 break; 1174 case OPT_X_CHAIN: 1175 if (exc->chainfile != NULL) { 1176 BIO_printf(bio_err, "%s: Chain already specified\n", 1177 opt_getprog()); 1178 goto err; 1179 } 1180 exc->chainfile = opt_arg(); 1181 break; 1182 case OPT_X_CHAIN_BUILD: 1183 exc->build_chain = 1; 1184 break; 1185 case OPT_X_CERTFORM: 1186 if (!opt_format(opt_arg(), OPT_FMT_ANY, &exc->certform)) 1187 return 0; 1188 break; 1189 case OPT_X_KEYFORM: 1190 if (!opt_format(opt_arg(), OPT_FMT_ANY, &exc->keyform)) 1191 return 0; 1192 break; 1193 } 1194 return 1; 1195 1196 err: 1197 ERR_print_errors(bio_err); 1198 ssl_excert_free(exc); 1199 *pexc = NULL; 1200 return 0; 1201 } 1202 1203 static void print_raw_cipherlist(SSL *s) 1204 { 1205 const unsigned char *rlist; 1206 static const unsigned char scsv_id[] = { 0, 0xFF }; 1207 size_t i, rlistlen, num; 1208 1209 if (!SSL_is_server(s)) 1210 return; 1211 num = SSL_get0_raw_cipherlist(s, NULL); 1212 OPENSSL_assert(num == 2); 1213 rlistlen = SSL_get0_raw_cipherlist(s, &rlist); 1214 BIO_puts(bio_err, "Client cipher list: "); 1215 for (i = 0; i < rlistlen; i += num, rlist += num) { 1216 const SSL_CIPHER *c = SSL_CIPHER_find(s, rlist); 1217 if (i) 1218 BIO_puts(bio_err, ":"); 1219 if (c != NULL) { 1220 BIO_puts(bio_err, SSL_CIPHER_get_name(c)); 1221 } else if (memcmp(rlist, scsv_id, num) == 0) { 1222 BIO_puts(bio_err, "SCSV"); 1223 } else { 1224 size_t j; 1225 BIO_puts(bio_err, "0x"); 1226 for (j = 0; j < num; j++) 1227 BIO_printf(bio_err, "%02X", rlist[j]); 1228 } 1229 } 1230 BIO_puts(bio_err, "\n"); 1231 } 1232 1233 /* 1234 * Hex encoder for TLSA RRdata, not ':' delimited. 1235 */ 1236 static char *hexencode(const unsigned char *data, size_t len) 1237 { 1238 static const char *hex = "0123456789abcdef"; 1239 char *out; 1240 char *cp; 1241 size_t outlen = 2 * len + 1; 1242 int ilen = (int) outlen; 1243 1244 if (outlen < len || ilen < 0 || outlen != (size_t)ilen) { 1245 BIO_printf(bio_err, "%s: %zu-byte buffer too large to hexencode\n", 1246 opt_getprog(), len); 1247 exit(1); 1248 } 1249 cp = out = app_malloc(ilen, "TLSA hex data buffer"); 1250 1251 while (len-- > 0) { 1252 *cp++ = hex[(*data >> 4) & 0x0f]; 1253 *cp++ = hex[*data++ & 0x0f]; 1254 } 1255 *cp = '\0'; 1256 return out; 1257 } 1258 1259 void print_verify_detail(SSL *s, BIO *bio) 1260 { 1261 int mdpth; 1262 EVP_PKEY *mspki = NULL; 1263 long verify_err = SSL_get_verify_result(s); 1264 1265 if (verify_err == X509_V_OK) { 1266 const char *peername = SSL_get0_peername(s); 1267 1268 BIO_printf(bio, "Verification: OK\n"); 1269 if (peername != NULL) 1270 BIO_printf(bio, "Verified peername: %s\n", peername); 1271 } else { 1272 const char *reason = X509_verify_cert_error_string(verify_err); 1273 1274 BIO_printf(bio, "Verification error: %s\n", reason); 1275 } 1276 1277 if ((mdpth = SSL_get0_dane_authority(s, NULL, &mspki)) >= 0) { 1278 uint8_t usage, selector, mtype; 1279 const unsigned char *data = NULL; 1280 size_t dlen = 0; 1281 char *hexdata; 1282 1283 mdpth = SSL_get0_dane_tlsa(s, &usage, &selector, &mtype, &data, &dlen); 1284 1285 /* 1286 * The TLSA data field can be quite long when it is a certificate, 1287 * public key or even a SHA2-512 digest. Because the initial octets of 1288 * ASN.1 certificates and public keys contain mostly boilerplate OIDs 1289 * and lengths, we show the last 12 bytes of the data instead, as these 1290 * are more likely to distinguish distinct TLSA records. 1291 */ 1292 #define TLSA_TAIL_SIZE 12 1293 if (dlen > TLSA_TAIL_SIZE) 1294 hexdata = hexencode(data + dlen - TLSA_TAIL_SIZE, TLSA_TAIL_SIZE); 1295 else 1296 hexdata = hexencode(data, dlen); 1297 BIO_printf(bio, "DANE TLSA %d %d %d %s%s ", 1298 usage, selector, mtype, 1299 (dlen > TLSA_TAIL_SIZE) ? "..." : "", hexdata); 1300 if (SSL_get0_peer_rpk(s) == NULL) 1301 BIO_printf(bio, "%s certificate at depth %d\n", 1302 (mspki != NULL) ? "signed the peer" : 1303 mdpth ? "matched the TA" : "matched the EE", mdpth); 1304 else 1305 BIO_printf(bio, "matched the peer raw public key\n"); 1306 OPENSSL_free(hexdata); 1307 } 1308 } 1309 1310 void print_ssl_summary(SSL *s) 1311 { 1312 const char *sigalg; 1313 const SSL_CIPHER *c; 1314 X509 *peer = SSL_get0_peer_certificate(s); 1315 EVP_PKEY *peer_rpk = SSL_get0_peer_rpk(s); 1316 int nid; 1317 1318 BIO_printf(bio_err, "Protocol version: %s\n", SSL_get_version(s)); 1319 print_raw_cipherlist(s); 1320 c = SSL_get_current_cipher(s); 1321 BIO_printf(bio_err, "Ciphersuite: %s\n", SSL_CIPHER_get_name(c)); 1322 do_print_sigalgs(bio_err, s, 0); 1323 if (peer != NULL) { 1324 BIO_puts(bio_err, "Peer certificate: "); 1325 X509_NAME_print_ex(bio_err, X509_get_subject_name(peer), 1326 0, get_nameopt()); 1327 BIO_puts(bio_err, "\n"); 1328 if (SSL_get_peer_signature_nid(s, &nid)) 1329 BIO_printf(bio_err, "Hash used: %s\n", OBJ_nid2sn(nid)); 1330 if (SSL_get0_peer_signature_name(s, &sigalg)) 1331 BIO_printf(bio_err, "Signature type: %s\n", sigalg); 1332 print_verify_detail(s, bio_err); 1333 } else if (peer_rpk != NULL) { 1334 BIO_printf(bio_err, "Peer used raw public key\n"); 1335 if (SSL_get0_peer_signature_name(s, &sigalg)) 1336 BIO_printf(bio_err, "Signature type: %s\n", sigalg); 1337 print_verify_detail(s, bio_err); 1338 } else { 1339 BIO_puts(bio_err, "No peer certificate or raw public key\n"); 1340 } 1341 #ifndef OPENSSL_NO_EC 1342 ssl_print_point_formats(bio_err, s); 1343 if (SSL_is_server(s)) 1344 ssl_print_groups(bio_err, s, 1); 1345 #endif 1346 ssl_print_tmp_key(bio_err, s); 1347 } 1348 1349 int config_ctx(SSL_CONF_CTX *cctx, STACK_OF(OPENSSL_STRING) *str, 1350 SSL_CTX *ctx) 1351 { 1352 int i; 1353 1354 SSL_CONF_CTX_set_ssl_ctx(cctx, ctx); 1355 for (i = 0; i < sk_OPENSSL_STRING_num(str); i += 2) { 1356 const char *flag = sk_OPENSSL_STRING_value(str, i); 1357 const char *arg = sk_OPENSSL_STRING_value(str, i + 1); 1358 1359 if (SSL_CONF_cmd(cctx, flag, arg) <= 0) { 1360 BIO_printf(bio_err, "Call to SSL_CONF_cmd(%s, %s) failed\n", 1361 flag, arg == NULL ? "<NULL>" : arg); 1362 ERR_print_errors(bio_err); 1363 return 0; 1364 } 1365 } 1366 if (!SSL_CONF_CTX_finish(cctx)) { 1367 BIO_puts(bio_err, "Error finishing context\n"); 1368 ERR_print_errors(bio_err); 1369 return 0; 1370 } 1371 return 1; 1372 } 1373 1374 static int add_crls_store(X509_STORE *st, STACK_OF(X509_CRL) *crls) 1375 { 1376 X509_CRL *crl; 1377 int i, ret = 1; 1378 1379 for (i = 0; i < sk_X509_CRL_num(crls); i++) { 1380 crl = sk_X509_CRL_value(crls, i); 1381 if (!X509_STORE_add_crl(st, crl)) 1382 ret = 0; 1383 } 1384 return ret; 1385 } 1386 1387 int ssl_ctx_add_crls(SSL_CTX *ctx, STACK_OF(X509_CRL) *crls, int crl_download) 1388 { 1389 X509_STORE *st; 1390 1391 st = SSL_CTX_get_cert_store(ctx); 1392 add_crls_store(st, crls); 1393 if (crl_download) 1394 store_setup_crl_download(st); 1395 return 1; 1396 } 1397 1398 int ssl_load_stores(SSL_CTX *ctx, 1399 const char *vfyCApath, const char *vfyCAfile, 1400 const char *vfyCAstore, 1401 const char *chCApath, const char *chCAfile, 1402 const char *chCAstore, 1403 STACK_OF(X509_CRL) *crls, int crl_download) 1404 { 1405 X509_STORE *vfy = NULL, *ch = NULL; 1406 int rv = 0; 1407 1408 if (vfyCApath != NULL || vfyCAfile != NULL || vfyCAstore != NULL) { 1409 vfy = X509_STORE_new(); 1410 if (vfy == NULL) 1411 goto err; 1412 if (vfyCAfile != NULL && !X509_STORE_load_file(vfy, vfyCAfile)) 1413 goto err; 1414 if (vfyCApath != NULL && !X509_STORE_load_path(vfy, vfyCApath)) 1415 goto err; 1416 if (vfyCAstore != NULL && !X509_STORE_load_store(vfy, vfyCAstore)) 1417 goto err; 1418 add_crls_store(vfy, crls); 1419 if (SSL_CTX_set1_verify_cert_store(ctx, vfy) == 0) 1420 goto err; 1421 if (crl_download) 1422 store_setup_crl_download(vfy); 1423 } 1424 if (chCApath != NULL || chCAfile != NULL || chCAstore != NULL) { 1425 ch = X509_STORE_new(); 1426 if (ch == NULL) 1427 goto err; 1428 if (chCAfile != NULL && !X509_STORE_load_file(ch, chCAfile)) 1429 goto err; 1430 if (chCApath != NULL && !X509_STORE_load_path(ch, chCApath)) 1431 goto err; 1432 if (chCAstore != NULL && !X509_STORE_load_store(ch, chCAstore)) 1433 goto err; 1434 if (SSL_CTX_set1_chain_cert_store(ctx, ch) == 0) 1435 goto err; 1436 } 1437 rv = 1; 1438 err: 1439 X509_STORE_free(vfy); 1440 X509_STORE_free(ch); 1441 return rv; 1442 } 1443 1444 /* Verbose print out of security callback */ 1445 1446 typedef struct { 1447 BIO *out; 1448 int verbose; 1449 int (*old_cb) (const SSL *s, const SSL_CTX *ctx, int op, int bits, int nid, 1450 void *other, void *ex); 1451 } security_debug_ex; 1452 1453 static STRINT_PAIR callback_types[] = { 1454 {"Supported Ciphersuite", SSL_SECOP_CIPHER_SUPPORTED}, 1455 {"Shared Ciphersuite", SSL_SECOP_CIPHER_SHARED}, 1456 {"Check Ciphersuite", SSL_SECOP_CIPHER_CHECK}, 1457 #ifndef OPENSSL_NO_DH 1458 {"Temp DH key bits", SSL_SECOP_TMP_DH}, 1459 #endif 1460 {"Supported Curve", SSL_SECOP_CURVE_SUPPORTED}, 1461 {"Shared Curve", SSL_SECOP_CURVE_SHARED}, 1462 {"Check Curve", SSL_SECOP_CURVE_CHECK}, 1463 {"Supported Signature Algorithm", SSL_SECOP_SIGALG_SUPPORTED}, 1464 {"Shared Signature Algorithm", SSL_SECOP_SIGALG_SHARED}, 1465 {"Check Signature Algorithm", SSL_SECOP_SIGALG_CHECK}, 1466 {"Signature Algorithm mask", SSL_SECOP_SIGALG_MASK}, 1467 {"Certificate chain EE key", SSL_SECOP_EE_KEY}, 1468 {"Certificate chain CA key", SSL_SECOP_CA_KEY}, 1469 {"Peer Chain EE key", SSL_SECOP_PEER_EE_KEY}, 1470 {"Peer Chain CA key", SSL_SECOP_PEER_CA_KEY}, 1471 {"Certificate chain CA digest", SSL_SECOP_CA_MD}, 1472 {"Peer chain CA digest", SSL_SECOP_PEER_CA_MD}, 1473 {"SSL compression", SSL_SECOP_COMPRESSION}, 1474 {"Session ticket", SSL_SECOP_TICKET}, 1475 {NULL} 1476 }; 1477 1478 static int security_callback_debug(const SSL *s, const SSL_CTX *ctx, 1479 int op, int bits, int nid, 1480 void *other, void *ex) 1481 { 1482 security_debug_ex *sdb = ex; 1483 int rv, show_bits = 1, cert_md = 0; 1484 const char *nm; 1485 int show_nm; 1486 1487 rv = sdb->old_cb(s, ctx, op, bits, nid, other, ex); 1488 if (rv == 1 && sdb->verbose < 2) 1489 return 1; 1490 BIO_puts(sdb->out, "Security callback: "); 1491 1492 nm = lookup(op, callback_types, NULL); 1493 show_nm = nm != NULL; 1494 switch (op) { 1495 case SSL_SECOP_TICKET: 1496 case SSL_SECOP_COMPRESSION: 1497 show_bits = 0; 1498 show_nm = 0; 1499 break; 1500 case SSL_SECOP_VERSION: 1501 BIO_printf(sdb->out, "Version=%s", lookup(nid, ssl_versions, "???")); 1502 show_bits = 0; 1503 show_nm = 0; 1504 break; 1505 case SSL_SECOP_CA_MD: 1506 case SSL_SECOP_PEER_CA_MD: 1507 cert_md = 1; 1508 break; 1509 case SSL_SECOP_SIGALG_SUPPORTED: 1510 case SSL_SECOP_SIGALG_SHARED: 1511 case SSL_SECOP_SIGALG_CHECK: 1512 case SSL_SECOP_SIGALG_MASK: 1513 show_nm = 0; 1514 break; 1515 } 1516 if (show_nm) 1517 BIO_printf(sdb->out, "%s=", nm); 1518 1519 switch (op & SSL_SECOP_OTHER_TYPE) { 1520 1521 case SSL_SECOP_OTHER_CIPHER: 1522 BIO_puts(sdb->out, SSL_CIPHER_get_name(other)); 1523 break; 1524 1525 #ifndef OPENSSL_NO_EC 1526 case SSL_SECOP_OTHER_CURVE: 1527 { 1528 const char *cname; 1529 cname = EC_curve_nid2nist(nid); 1530 if (cname == NULL) 1531 cname = OBJ_nid2sn(nid); 1532 BIO_puts(sdb->out, cname); 1533 } 1534 break; 1535 #endif 1536 case SSL_SECOP_OTHER_CERT: 1537 { 1538 if (cert_md) { 1539 int sig_nid = X509_get_signature_nid(other); 1540 1541 BIO_puts(sdb->out, OBJ_nid2sn(sig_nid)); 1542 } else { 1543 EVP_PKEY *pkey = X509_get0_pubkey(other); 1544 1545 if (pkey == NULL) { 1546 BIO_printf(sdb->out, "Public key missing"); 1547 } else { 1548 const char *algname = ""; 1549 1550 EVP_PKEY_asn1_get0_info(NULL, NULL, NULL, NULL, 1551 &algname, EVP_PKEY_get0_asn1(pkey)); 1552 BIO_printf(sdb->out, "%s, bits=%d", 1553 algname, EVP_PKEY_get_bits(pkey)); 1554 } 1555 } 1556 break; 1557 } 1558 case SSL_SECOP_OTHER_SIGALG: 1559 { 1560 const unsigned char *salg = other; 1561 const char *sname = NULL; 1562 int raw_sig_code = (salg[0] << 8) + salg[1]; /* always big endian (msb, lsb) */ 1563 /* raw_sig_code: signature_scheme from tls1.3, or signature_and_hash from tls1.2 */ 1564 1565 if (nm != NULL) 1566 BIO_printf(sdb->out, "%s", nm); 1567 else 1568 BIO_printf(sdb->out, "s_cb.c:security_callback_debug op=0x%x", op); 1569 1570 sname = lookup(raw_sig_code, signature_tls13_scheme_list, NULL); 1571 if (sname != NULL) { 1572 BIO_printf(sdb->out, " scheme=%s", sname); 1573 } else { 1574 int alg_code = salg[1]; 1575 int hash_code = salg[0]; 1576 const char *alg_str = lookup(alg_code, signature_tls12_alg_list, NULL); 1577 const char *hash_str = lookup(hash_code, signature_tls12_hash_list, NULL); 1578 1579 if (alg_str != NULL && hash_str != NULL) 1580 BIO_printf(sdb->out, " digest=%s, algorithm=%s", hash_str, alg_str); 1581 else 1582 BIO_printf(sdb->out, " scheme=unknown(0x%04x)", raw_sig_code); 1583 } 1584 } 1585 1586 } 1587 1588 if (show_bits) 1589 BIO_printf(sdb->out, ", security bits=%d", bits); 1590 BIO_printf(sdb->out, ": %s\n", rv ? "yes" : "no"); 1591 return rv; 1592 } 1593 1594 void ssl_ctx_security_debug(SSL_CTX *ctx, int verbose) 1595 { 1596 static security_debug_ex sdb; 1597 1598 sdb.out = bio_err; 1599 sdb.verbose = verbose; 1600 sdb.old_cb = SSL_CTX_get_security_callback(ctx); 1601 SSL_CTX_set_security_callback(ctx, security_callback_debug); 1602 SSL_CTX_set0_security_ex_data(ctx, &sdb); 1603 } 1604 1605 static void keylog_callback(const SSL *ssl, const char *line) 1606 { 1607 if (bio_keylog == NULL) { 1608 BIO_printf(bio_err, "Keylog callback is invoked without valid file!\n"); 1609 return; 1610 } 1611 1612 /* 1613 * There might be concurrent writers to the keylog file, so we must ensure 1614 * that the given line is written at once. 1615 */ 1616 BIO_printf(bio_keylog, "%s\n", line); 1617 (void)BIO_flush(bio_keylog); 1618 } 1619 1620 int set_keylog_file(SSL_CTX *ctx, const char *keylog_file) 1621 { 1622 /* Close any open files */ 1623 BIO_free_all(bio_keylog); 1624 bio_keylog = NULL; 1625 1626 if (ctx == NULL || keylog_file == NULL) { 1627 /* Keylogging is disabled, OK. */ 1628 return 0; 1629 } 1630 1631 /* 1632 * Append rather than write in order to allow concurrent modification. 1633 * Furthermore, this preserves existing keylog files which is useful when 1634 * the tool is run multiple times. 1635 */ 1636 bio_keylog = BIO_new_file(keylog_file, "a"); 1637 if (bio_keylog == NULL) { 1638 BIO_printf(bio_err, "Error writing keylog file %s\n", keylog_file); 1639 return 1; 1640 } 1641 1642 /* Write a header for seekable, empty files (this excludes pipes). */ 1643 if (BIO_tell(bio_keylog) == 0) { 1644 BIO_puts(bio_keylog, 1645 "# SSL/TLS secrets log file, generated by OpenSSL\n"); 1646 (void)BIO_flush(bio_keylog); 1647 } 1648 SSL_CTX_set_keylog_callback(ctx, keylog_callback); 1649 return 0; 1650 } 1651 1652 void print_ca_names(BIO *bio, SSL *s) 1653 { 1654 const char *cs = SSL_is_server(s) ? "server" : "client"; 1655 const STACK_OF(X509_NAME) *sk = SSL_get0_peer_CA_list(s); 1656 int i; 1657 1658 if (sk == NULL || sk_X509_NAME_num(sk) == 0) { 1659 if (!SSL_is_server(s)) 1660 BIO_printf(bio, "---\nNo %s certificate CA names sent\n", cs); 1661 return; 1662 } 1663 1664 BIO_printf(bio, "---\nAcceptable %s certificate CA names\n", cs); 1665 for (i = 0; i < sk_X509_NAME_num(sk); i++) { 1666 X509_NAME_print_ex(bio, sk_X509_NAME_value(sk, i), 0, get_nameopt()); 1667 BIO_write(bio, "\n", 1); 1668 } 1669 } 1670 1671 void ssl_print_secure_renegotiation_notes(BIO *bio, SSL *s) 1672 { 1673 if (SSL_VERSION_ALLOWS_RENEGOTIATION(s)) { 1674 BIO_printf(bio, "Secure Renegotiation IS%s supported\n", 1675 SSL_get_secure_renegotiation_support(s) ? "" : " NOT"); 1676 } else { 1677 BIO_printf(bio, "This TLS version forbids renegotiation.\n"); 1678 } 1679 } 1680 1681 int progress_cb(EVP_PKEY_CTX *ctx) 1682 { 1683 BIO *b = EVP_PKEY_CTX_get_app_data(ctx); 1684 int p = EVP_PKEY_CTX_get_keygen_info(ctx, 0); 1685 static const char symbols[] = ".+*\n"; 1686 char c = (p >= 0 && (size_t)p <= sizeof(symbols) - 1) ? symbols[p] : '?'; 1687 1688 BIO_write(b, &c, 1); 1689 (void)BIO_flush(b); 1690 return 1; 1691 } 1692
Indexes created Tue Mar 03 05:31:39 UTC 2026