apps/s_cb.c

   1 /*
   2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (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 /* callback functions used by s_client, s_server, and s_time */
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h> /* for memcpy() and strcmp() */
  14 #define USE_SOCKETS
  15 #include "apps.h"
  16 #undef USE_SOCKETS
  17 #include <openssl/err.h>
  18 #include <openssl/rand.h>
  19 #include <openssl/x509.h>
  20 #include <openssl/ssl.h>
  21 #include <openssl/bn.h>
  22 #ifndef OPENSSL_NO_DH
  23 # include <openssl/dh.h>
  24 #endif
  25 #include "s_apps.h"
  26
  27 #define COOKIE_SECRET_LENGTH    16
  28
  29 int verify_depth = 0;
  30 int verify_quiet = 0;
  31 int verify_error = X509_V_OK;
  32 int verify_return_error = 0;
  33 #ifndef OPENSSL_NO_SOCK
  34 static unsigned char cookie_secret[COOKIE_SECRET_LENGTH];
  35 static int cookie_initialized = 0;
  36 #endif
  37
  38 static const char *lookup(int val, const STRINT_PAIR* list, const char* def)
  39 {
  40     for ( ; list->name; ++list)
  41         if (list->retval == val)
  42             return list->name;
  43     return def;
  44 }
  45
  46 int verify_callback(int ok, X509_STORE_CTX *ctx)
  47 {
  48     X509 *err_cert;
  49     int err, depth;
  50
  51     err_cert = X509_STORE_CTX_get_current_cert(ctx);
  52     err = X509_STORE_CTX_get_error(ctx);
  53     depth = X509_STORE_CTX_get_error_depth(ctx);
  54
  55     if (!verify_quiet || !ok) {
  56         BIO_printf(bio_err, "depth=%d ", depth);
  57         if (err_cert) {
  58             X509_NAME_print_ex(bio_err,
  59                                X509_get_subject_name(err_cert),
  60                                0, XN_FLAG_ONELINE);
  61             BIO_puts(bio_err, "\n");
  62         } else
  63             BIO_puts(bio_err, "<no cert>\n");
  64     }
  65     if (!ok) {
  66         BIO_printf(bio_err, "verify error:num=%d:%s\n", err,
  67                    X509_verify_cert_error_string(err));
  68         if (verify_depth >= depth) {
  69             if (!verify_return_error)
  70                 ok = 1;
  71             verify_error = err;
  72         } else {
  73             ok = 0;
  74             verify_error = X509_V_ERR_CERT_CHAIN_TOO_LONG;
  75         }
  76     }
  77     switch (err) {
  78     case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
  79         BIO_puts(bio_err, "issuer= ");
  80         X509_NAME_print_ex(bio_err, X509_get_issuer_name(err_cert),
  81                            0, XN_FLAG_ONELINE);
  82         BIO_puts(bio_err, "\n");
  83         break;
  84     case X509_V_ERR_CERT_NOT_YET_VALID:
  85     case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
  86         BIO_printf(bio_err, "notBefore=");
  87         ASN1_TIME_print(bio_err, X509_get_notBefore(err_cert));
  88         BIO_printf(bio_err, "\n");
  89         break;
  90     case X509_V_ERR_CERT_HAS_EXPIRED:
  91     case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:
  92         BIO_printf(bio_err, "notAfter=");
  93         ASN1_TIME_print(bio_err, X509_get_notAfter(err_cert));
  94         BIO_printf(bio_err, "\n");
  95         break;
  96     case X509_V_ERR_NO_EXPLICIT_POLICY:
  97         if (!verify_quiet)
  98             policies_print(ctx);
  99         break;
 100     }
 101     if (err == X509_V_OK && ok == 2 && !verify_quiet)
 102         policies_print(ctx);
 103     if (ok && !verify_quiet)
 104         BIO_printf(bio_err, "verify return:%d\n", ok);
 105     return (ok);
 106 }
 107
 108 int set_cert_stuff(SSL_CTX *ctx, char *cert_file, char *key_file)
 109 {
 110     if (cert_file != NULL) {
 111         if (SSL_CTX_use_certificate_file(ctx, cert_file,
 112                                          SSL_FILETYPE_PEM) <= 0) {
 113             BIO_printf(bio_err, "unable to get certificate from '%s'\n",
 114                        cert_file);
 115             ERR_print_errors(bio_err);
 116             return (0);
 117         }
 118         if (key_file == NULL)
 119             key_file = cert_file;
 120         if (SSL_CTX_use_PrivateKey_file(ctx, key_file, SSL_FILETYPE_PEM) <= 0) {
 121             BIO_printf(bio_err, "unable to get private key from '%s'\n",
 122                        key_file);
 123             ERR_print_errors(bio_err);
 124             return (0);
 125         }
 126
 127         /*
 128          * If we are using DSA, we can copy the parameters from the private
 129          * key
 130          */
 131
 132         /*
 133          * Now we know that a key and cert have been set against the SSL
 134          * context
 135          */
 136         if (!SSL_CTX_check_private_key(ctx)) {
 137             BIO_printf(bio_err,
 138                        "Private key does not match the certificate public key\n");
 139             return (0);
 140         }
 141     }
 142     return (1);
 143 }
 144
 145 int set_cert_key_stuff(SSL_CTX *ctx, X509 *cert, EVP_PKEY *key,
 146                        STACK_OF(X509) *chain, int build_chain)
 147 {
 148     int chflags = chain ? SSL_BUILD_CHAIN_FLAG_CHECK : 0;
 149     if (cert == NULL)
 150         return 1;
 151     if (SSL_CTX_use_certificate(ctx, cert) <= 0) {
 152         BIO_printf(bio_err, "error setting certificate\n");
 153         ERR_print_errors(bio_err);
 154         return 0;
 155     }
 156
 157     if (SSL_CTX_use_PrivateKey(ctx, key) <= 0) {
 158         BIO_printf(bio_err, "error setting private key\n");
 159         ERR_print_errors(bio_err);
 160         return 0;
 161     }
 162
 163     /*
 164      * Now we know that a key and cert have been set against the SSL context
 165      */
 166     if (!SSL_CTX_check_private_key(ctx)) {
 167         BIO_printf(bio_err,
 168                    "Private key does not match the certificate public key\n");
 169         return 0;
 170     }
 171     if (chain && !SSL_CTX_set1_chain(ctx, chain)) {
 172         BIO_printf(bio_err, "error setting certificate chain\n");
 173         ERR_print_errors(bio_err);
 174         return 0;
 175     }
 176     if (build_chain && !SSL_CTX_build_cert_chain(ctx, chflags)) {
 177         BIO_printf(bio_err, "error building certificate chain\n");
 178         ERR_print_errors(bio_err);
 179         return 0;
 180     }
 181     return 1;
 182 }
 183
 184 static STRINT_PAIR cert_type_list[] = {
 185     {"RSA sign", TLS_CT_RSA_SIGN},
 186     {"DSA sign", TLS_CT_DSS_SIGN},
 187     {"RSA fixed DH", TLS_CT_RSA_FIXED_DH},
 188     {"DSS fixed DH", TLS_CT_DSS_FIXED_DH},
 189     {"ECDSA sign", TLS_CT_ECDSA_SIGN},
 190     {"RSA fixed ECDH", TLS_CT_RSA_FIXED_ECDH},
 191     {"ECDSA fixed ECDH", TLS_CT_ECDSA_FIXED_ECDH},
 192     {"GOST01 Sign", TLS_CT_GOST01_SIGN},
 193     {NULL}
 194 };
 195
 196 static void ssl_print_client_cert_types(BIO *bio, SSL *s)
 197 {
 198     const unsigned char *p;
 199     int i;
 200     int cert_type_num = SSL_get0_certificate_types(s, &p);
 201     if (!cert_type_num)
 202         return;
 203     BIO_puts(bio, "Client Certificate Types: ");
 204     for (i = 0; i < cert_type_num; i++) {
 205         unsigned char cert_type = p[i];
 206         const char *cname = lookup((int)cert_type, cert_type_list, NULL);
 207
 208         if (i)
 209             BIO_puts(bio, ", ");
 210         if (cname)
 211             BIO_puts(bio, cname);
 212         else
 213             BIO_printf(bio, "UNKNOWN (%d),", cert_type);
 214     }
 215     BIO_puts(bio, "\n");
 216 }
 217
 218 static int do_print_sigalgs(BIO *out, SSL *s, int shared)
 219 {
 220     int i, nsig, client;
 221     client = SSL_is_server(s) ? 0 : 1;
 222     if (shared)
 223         nsig = SSL_get_shared_sigalgs(s, -1, NULL, NULL, NULL, NULL, NULL);
 224     else
 225         nsig = SSL_get_sigalgs(s, -1, NULL, NULL, NULL, NULL, NULL);
 226     if (nsig == 0)
 227         return 1;
 228
 229     if (shared)
 230         BIO_puts(out, "Shared ");
 231
 232     if (client)
 233         BIO_puts(out, "Requested ");
 234     BIO_puts(out, "Signature Algorithms: ");
 235     for (i = 0; i < nsig; i++) {
 236         int hash_nid, sign_nid;
 237         unsigned char rhash, rsign;
 238         const char *sstr = NULL;
 239         if (shared)
 240             SSL_get_shared_sigalgs(s, i, &sign_nid, &hash_nid, NULL,
 241                                    &rsign, &rhash);
 242         else
 243             SSL_get_sigalgs(s, i, &sign_nid, &hash_nid, NULL, &rsign, &rhash);
 244         if (i)
 245             BIO_puts(out, ":");
 246         if (sign_nid == EVP_PKEY_RSA)
 247             sstr = "RSA";
 248         else if (sign_nid == EVP_PKEY_DSA)
 249             sstr = "DSA";
 250         else if (sign_nid == EVP_PKEY_EC)
 251             sstr = "ECDSA";
 252         if (sstr)
 253             BIO_printf(out, "%s+", sstr);
 254         else
 255             BIO_printf(out, "0x%02X+", (int)rsign);
 256         if (hash_nid != NID_undef)
 257             BIO_printf(out, "%s", OBJ_nid2sn(hash_nid));
 258         else
 259             BIO_printf(out, "0x%02X", (int)rhash);
 260     }
 261     BIO_puts(out, "\n");
 262     return 1;
 263 }
 264
 265 int ssl_print_sigalgs(BIO *out, SSL *s)
 266 {
 267     int mdnid;
 268     if (!SSL_is_server(s))
 269         ssl_print_client_cert_types(out, s);
 270     do_print_sigalgs(out, s, 0);
 271     do_print_sigalgs(out, s, 1);
 272     if (SSL_get_peer_signature_nid(s, &mdnid))
 273         BIO_printf(out, "Peer signing digest: %s\n", OBJ_nid2sn(mdnid));
 274     return 1;
 275 }
 276
 277 #ifndef OPENSSL_NO_EC
 278 int ssl_print_point_formats(BIO *out, SSL *s)
 279 {
 280     int i, nformats;
 281     const char *pformats;
 282     nformats = SSL_get0_ec_point_formats(s, &pformats);
 283     if (nformats <= 0)
 284         return 1;
 285     BIO_puts(out, "Supported Elliptic Curve Point Formats: ");
 286     for (i = 0; i < nformats; i++, pformats++) {
 287         if (i)
 288             BIO_puts(out, ":");
 289         switch (*pformats) {
 290         case TLSEXT_ECPOINTFORMAT_uncompressed:
 291             BIO_puts(out, "uncompressed");
 292             break;
 293
 294         case TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime:
 295             BIO_puts(out, "ansiX962_compressed_prime");
 296             break;
 297
 298         case TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2:
 299             BIO_puts(out, "ansiX962_compressed_char2");
 300             break;
 301
 302         default:
 303             BIO_printf(out, "unknown(%d)", (int)*pformats);
 304             break;
 305
 306         }
 307     }
 308     BIO_puts(out, "\n");
 309     return 1;
 310 }
 311
 312 int ssl_print_curves(BIO *out, SSL *s, int noshared)
 313 {
 314     int i, ncurves, *curves, nid;
 315     const char *cname;
 316
 317     ncurves = SSL_get1_curves(s, NULL);
 318     if (ncurves <= 0)
 319         return 1;
 320     curves = app_malloc(ncurves * sizeof(int), "curves to print");
 321     SSL_get1_curves(s, curves);
 322
 323     BIO_puts(out, "Supported Elliptic Curves: ");
 324     for (i = 0; i < ncurves; i++) {
 325         if (i)
 326             BIO_puts(out, ":");
 327         nid = curves[i];
 328         /* If unrecognised print out hex version */
 329         if (nid & TLSEXT_nid_unknown)
 330             BIO_printf(out, "0x%04X", nid & 0xFFFF);
 331         else {
 332             /* Use NIST name for curve if it exists */
 333             cname = EC_curve_nid2nist(nid);
 334             if (!cname)
 335                 cname = OBJ_nid2sn(nid);
 336             BIO_printf(out, "%s", cname);
 337         }
 338     }
 339     OPENSSL_free(curves);
 340     if (noshared) {
 341         BIO_puts(out, "\n");
 342         return 1;
 343     }
 344     BIO_puts(out, "\nShared Elliptic curves: ");
 345     ncurves = SSL_get_shared_curve(s, -1);
 346     for (i = 0; i < ncurves; i++) {
 347         if (i)
 348             BIO_puts(out, ":");
 349         nid = SSL_get_shared_curve(s, i);
 350         cname = EC_curve_nid2nist(nid);
 351         if (!cname)
 352             cname = OBJ_nid2sn(nid);
 353         BIO_printf(out, "%s", cname);
 354     }
 355     if (ncurves == 0)
 356         BIO_puts(out, "NONE");
 357     BIO_puts(out, "\n");
 358     return 1;
 359 }
 360 #endif
 361 int ssl_print_tmp_key(BIO *out, SSL *s)
 362 {
 363     EVP_PKEY *key;
 364     if (!SSL_get_server_tmp_key(s, &key))
 365         return 1;
 366     BIO_puts(out, "Server Temp Key: ");
 367     switch (EVP_PKEY_id(key)) {
 368     case EVP_PKEY_RSA:
 369         BIO_printf(out, "RSA, %d bits\n", EVP_PKEY_bits(key));
 370         break;
 371
 372     case EVP_PKEY_DH:
 373         BIO_printf(out, "DH, %d bits\n", EVP_PKEY_bits(key));
 374         break;
 375 #ifndef OPENSSL_NO_EC
 376     case EVP_PKEY_EC:
 377         {
 378             EC_KEY *ec = EVP_PKEY_get1_EC_KEY(key);
 379             int nid;
 380             const char *cname;
 381             nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
 382             EC_KEY_free(ec);
 383             cname = EC_curve_nid2nist(nid);
 384             if (!cname)
 385                 cname = OBJ_nid2sn(nid);
 386             BIO_printf(out, "ECDH, %s, %d bits\n", cname, EVP_PKEY_bits(key));
 387         }
 388 #endif
 389     }
 390     EVP_PKEY_free(key);
 391     return 1;
 392 }
 393
 394 long bio_dump_callback(BIO *bio, int cmd, const char *argp,
 395                        int argi, long argl, long ret)
 396 {
 397     BIO *out;
 398
 399     out = (BIO *)BIO_get_callback_arg(bio);
 400     if (out == NULL)
 401         return (ret);
 402
 403     if (cmd == (BIO_CB_READ | BIO_CB_RETURN)) {
 404         BIO_printf(out, "read from %p [%p] (%lu bytes => %ld (0x%lX))\n",
 405                    (void *)bio, (void *)argp, (unsigned long)argi, ret, ret);
 406         BIO_dump(out, argp, (int)ret);
 407         return (ret);
 408     } else if (cmd == (BIO_CB_WRITE | BIO_CB_RETURN)) {
 409         BIO_printf(out, "write to %p [%p] (%lu bytes => %ld (0x%lX))\n",
 410                    (void *)bio, (void *)argp, (unsigned long)argi, ret, ret);
 411         BIO_dump(out, argp, (int)ret);
 412     }
 413     return (ret);
 414 }
 415
 416 void apps_ssl_info_callback(const SSL *s, int where, int ret)
 417 {
 418     const char *str;
 419     int w;
 420
 421     w = where & ~SSL_ST_MASK;
 422
 423     if (w & SSL_ST_CONNECT)
 424         str = "SSL_connect";
 425     else if (w & SSL_ST_ACCEPT)
 426         str = "SSL_accept";
 427     else
 428         str = "undefined";
 429
 430     if (where & SSL_CB_LOOP) {
 431         BIO_printf(bio_err, "%s:%s\n", str, SSL_state_string_long(s));
 432     } else if (where & SSL_CB_ALERT) {
 433         str = (where & SSL_CB_READ) ? "read" : "write";
 434         BIO_printf(bio_err, "SSL3 alert %s:%s:%s\n",
 435                    str,
 436                    SSL_alert_type_string_long(ret),
 437                    SSL_alert_desc_string_long(ret));
 438     } else if (where & SSL_CB_EXIT) {
 439         if (ret == 0)
 440             BIO_printf(bio_err, "%s:failed in %s\n",
 441                        str, SSL_state_string_long(s));
 442         else if (ret < 0) {
 443             BIO_printf(bio_err, "%s:error in %s\n",
 444                        str, SSL_state_string_long(s));
 445         }
 446     }
 447 }
 448
 449 static STRINT_PAIR ssl_versions[] = {
 450     {"SSL 3.0", SSL3_VERSION},
 451     {"TLS 1.0", TLS1_VERSION},
 452     {"TLS 1.1", TLS1_1_VERSION},
 453     {"TLS 1.2", TLS1_2_VERSION},
 454     {"DTLS 1.0", DTLS1_VERSION},
 455     {"DTLS 1.0 (bad)", DTLS1_BAD_VER},
 456     {NULL}
 457 };
 458 static STRINT_PAIR alert_types[] = {
 459     {" close_notify", 0},
 460     {" unexpected_message", 10},
 461     {" bad_record_mac", 20},
 462     {" decryption_failed", 21},
 463     {" record_overflow", 22},
 464     {" decompression_failure", 30},
 465     {" handshake_failure", 40},
 466     {" bad_certificate", 42},
 467     {" unsupported_certificate", 43},
 468     {" certificate_revoked", 44},
 469     {" certificate_expired", 45},
 470     {" certificate_unknown", 46},
 471     {" illegal_parameter", 47},
 472     {" unknown_ca", 48},
 473     {" access_denied", 49},
 474     {" decode_error", 50},
 475     {" decrypt_error", 51},
 476     {" export_restriction", 60},
 477     {" protocol_version", 70},
 478     {" insufficient_security", 71},
 479     {" internal_error", 80},
 480     {" user_canceled", 90},
 481     {" no_renegotiation", 100},
 482     {" unsupported_extension", 110},
 483     {" certificate_unobtainable", 111},
 484     {" unrecognized_name", 112},
 485     {" bad_certificate_status_response", 113},
 486     {" bad_certificate_hash_value", 114},
 487     {" unknown_psk_identity", 115},
 488     {NULL}
 489 };
 490
 491 static STRINT_PAIR handshakes[] = {
 492     {", HelloRequest", 0},
 493     {", ClientHello", 1},
 494     {", ServerHello", 2},
 495     {", HelloVerifyRequest", 3},
 496     {", NewSessionTicket", 4},
 497     {", Certificate", 11},
 498     {", ServerKeyExchange", 12},
 499     {", CertificateRequest", 13},
 500     {", ServerHelloDone", 14},
 501     {", CertificateVerify", 15},
 502     {", ClientKeyExchange", 16},
 503     {", Finished", 20},
 504     {", CertificateUrl", 21},
 505     {", CertificateStatus", 22},
 506     {", SupplementalData", 23},
 507     {NULL}
 508 };
 509
 510 void msg_cb(int write_p, int version, int content_type, const void *buf,
 511             size_t len, SSL *ssl, void *arg)
 512 {
 513     BIO *bio = arg;
 514     const char *str_write_p = write_p ? ">>>" : "<<<";
 515     const char *str_version = lookup(version, ssl_versions, "???");
 516     const char *str_content_type = "", *str_details1 = "", *str_details2 = "";
 517     const unsigned char* bp = buf;
 518
 519     if (version == SSL3_VERSION ||
 520         version == TLS1_VERSION ||
 521         version == TLS1_1_VERSION ||
 522         version == TLS1_2_VERSION ||
 523         version == DTLS1_VERSION || version == DTLS1_BAD_VER) {
 524         switch (content_type) {
 525         case 20:
 526             str_content_type = "ChangeCipherSpec";
 527             break;
 528         case 21:
 529             str_content_type = "Alert";
 530             str_details1 = ", ???";
 531             if (len == 2) {
 532                 switch (bp[0]) {
 533                 case 1:
 534                     str_details1 = ", warning";
 535                     break;
 536                 case 2:
 537                     str_details1 = ", fatal";
 538                     break;
 539                 }
 540                 str_details2 = lookup((int)bp[1], alert_types, " ???");
 541             }
 542             break;
 543         case 22:
 544             str_content_type = "Handshake";
 545             str_details1 = "???";
 546             if (len > 0)
 547                 str_details1 = lookup((int)bp[0], handshakes, "???");
 548             break;
 549         case 23:
 550             str_content_type = "ApplicationData";
 551             break;
 552 #ifndef OPENSSL_NO_HEARTBEATS
 553         case 24:
 554             str_details1 = ", Heartbeat";
 555
 556             if (len > 0) {
 557                 switch (bp[0]) {
 558                 case 1:
 559                     str_details1 = ", HeartbeatRequest";
 560                     break;
 561                 case 2:
 562                     str_details1 = ", HeartbeatResponse";
 563                     break;
 564                 }
 565             }
 566             break;
 567 #endif
 568         }
 569     }
 570
 571     BIO_printf(bio, "%s %s%s [length %04lx]%s%s\n", str_write_p, str_version,
 572                str_content_type, (unsigned long)len, str_details1,
 573                str_details2);
 574
 575     if (len > 0) {
 576         size_t num, i;
 577
 578         BIO_printf(bio, "   ");
 579         num = len;
 580         for (i = 0; i < num; i++) {
 581             if (i % 16 == 0 && i > 0)
 582                 BIO_printf(bio, "\n   ");
 583             BIO_printf(bio, " %02x", ((const unsigned char *)buf)[i]);
 584         }
 585         if (i < len)
 586             BIO_printf(bio, " ...");
 587         BIO_printf(bio, "\n");
 588     }
 589     (void)BIO_flush(bio);
 590 }
 591
 592 static STRINT_PAIR tlsext_types[] = {
 593     {"server name", TLSEXT_TYPE_server_name},
 594     {"max fragment length", TLSEXT_TYPE_max_fragment_length},
 595     {"client certificate URL", TLSEXT_TYPE_client_certificate_url},
 596     {"trusted CA keys", TLSEXT_TYPE_trusted_ca_keys},
 597     {"truncated HMAC", TLSEXT_TYPE_truncated_hmac},
 598     {"status request", TLSEXT_TYPE_status_request},
 599     {"user mapping", TLSEXT_TYPE_user_mapping},
 600     {"client authz", TLSEXT_TYPE_client_authz},
 601     {"server authz", TLSEXT_TYPE_server_authz},
 602     {"cert type", TLSEXT_TYPE_cert_type},
 603     {"elliptic curves", TLSEXT_TYPE_elliptic_curves},
 604     {"EC point formats", TLSEXT_TYPE_ec_point_formats},
 605     {"SRP", TLSEXT_TYPE_srp},
 606     {"signature algorithms", TLSEXT_TYPE_signature_algorithms},
 607     {"use SRTP", TLSEXT_TYPE_use_srtp},
 608     {"heartbeat", TLSEXT_TYPE_heartbeat},
 609     {"session ticket", TLSEXT_TYPE_session_ticket},
 610     {"renegotiation info", TLSEXT_TYPE_renegotiate},
 611     {"signed certificate timestamps", TLSEXT_TYPE_signed_certificate_timestamp},
 612     {"TLS padding", TLSEXT_TYPE_padding},
 613 #ifdef TLSEXT_TYPE_next_proto_neg
 614     {"next protocol", TLSEXT_TYPE_next_proto_neg},
 615 #endif
 616 #ifdef TLSEXT_TYPE_encrypt_then_mac
 617     {"encrypt-then-mac", TLSEXT_TYPE_encrypt_then_mac},
 618 #endif
 619 #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
 620     {"application layer protocol negotiation",
 621      TLSEXT_TYPE_application_layer_protocol_negotiation},
 622 #endif
 623 #ifdef TLSEXT_TYPE_extended_master_secret
 624     {"extended master secret", TLSEXT_TYPE_extended_master_secret},
 625 #endif
 626     {NULL}
 627 };
 628
 629 void tlsext_cb(SSL *s, int client_server, int type,
 630                const unsigned char *data, int len, void *arg)
 631 {
 632     BIO *bio = arg;
 633     const char *extname = lookup(type, tlsext_types, "unknown");
 634
 635     BIO_printf(bio, "TLS %s extension \"%s\" (id=%d), len=%d\n",
 636                client_server ? "server" : "client", extname, type, len);
 637     BIO_dump(bio, (const char *)data, len);
 638     (void)BIO_flush(bio);
 639 }
 640
 641 #ifndef OPENSSL_NO_SOCK
 642 int generate_cookie_callback(SSL *ssl, unsigned char *cookie,
 643                              unsigned int *cookie_len)
 644 {
 645     unsigned char *buffer;
 646     size_t length;
 647     unsigned short port;
 648     BIO_ADDR *peer = NULL;
 649
 650     /* Initialize a random secret */
 651     if (!cookie_initialized) {
 652         if (RAND_bytes(cookie_secret, COOKIE_SECRET_LENGTH) <= 0) {
 653             BIO_printf(bio_err, "error setting random cookie secret\n");
 654             return 0;
 655         }
 656         cookie_initialized = 1;
 657     }
 658
 659     peer = BIO_ADDR_new();
 660     if (peer == NULL) {
 661         BIO_printf(bio_err, "memory full\n");
 662         return 0;
 663     }
 664
 665     /* Read peer information */
 666     (void)BIO_dgram_get_peer(SSL_get_rbio(ssl), peer);
 667
 668     /* Create buffer with peer's address and port */
 669     BIO_ADDR_rawaddress(peer, NULL, &length);
 670     OPENSSL_assert(length != 0);
 671     port = BIO_ADDR_rawport(peer);
 672     length += sizeof(port);
 673     buffer = app_malloc(length, "cookie generate buffer");
 674
 675     memcpy(buffer, &port, sizeof(port));
 676     BIO_ADDR_rawaddress(peer, buffer + sizeof(port), NULL);
 677
 678     /* Calculate HMAC of buffer using the secret */
 679     HMAC(EVP_sha1(), cookie_secret, COOKIE_SECRET_LENGTH,
 680          buffer, length, cookie, cookie_len);
 681
 682     OPENSSL_free(buffer);
 683     BIO_ADDR_free(peer);
 684
 685     return 1;
 686 }
 687
 688 int verify_cookie_callback(SSL *ssl, const unsigned char *cookie,
 689                            unsigned int cookie_len)
 690 {
 691     unsigned char result[EVP_MAX_MD_SIZE];
 692     unsigned int resultlength;
 693
 694     /* Note: we check cookie_initialized because if it's not,
 695      * it cannot be valid */
 696     if (cookie_initialized
 697         && generate_cookie_callback(ssl, result, &resultlength)
 698         && cookie_len == resultlength
 699         && memcmp(result, cookie, resultlength) == 0)
 700         return 1;
 701
 702     return 0;
 703 }
 704 #endif
 705
 706 /*
 707  * Example of extended certificate handling. Where the standard support of
 708  * one certificate per algorithm is not sufficient an application can decide
 709  * which certificate(s) to use at runtime based on whatever criteria it deems
 710  * appropriate.
 711  */
 712
 713 /* Linked list of certificates, keys and chains */
 714 struct ssl_excert_st {
 715     int certform;
 716     const char *certfile;
 717     int keyform;
 718     const char *keyfile;
 719     const char *chainfile;
 720     X509 *cert;
 721     EVP_PKEY *key;
 722     STACK_OF(X509) *chain;
 723     int build_chain;
 724     struct ssl_excert_st *next, *prev;
 725 };
 726
 727 static STRINT_PAIR chain_flags[] = {
 728     {"Overall Validity", CERT_PKEY_VALID},
 729     {"Sign with EE key", CERT_PKEY_SIGN},
 730     {"EE signature", CERT_PKEY_EE_SIGNATURE},
 731     {"CA signature", CERT_PKEY_CA_SIGNATURE},
 732     {"EE key parameters", CERT_PKEY_EE_PARAM},
 733     {"CA key parameters", CERT_PKEY_CA_PARAM},
 734     {"Explicitly sign with EE key", CERT_PKEY_EXPLICIT_SIGN},
 735     {"Issuer Name", CERT_PKEY_ISSUER_NAME},
 736     {"Certificate Type", CERT_PKEY_CERT_TYPE},
 737     {NULL}
 738 };
 739
 740 static void print_chain_flags(SSL *s, int flags)
 741 {
 742     STRINT_PAIR *pp;
 743
 744     for (pp = chain_flags; pp->name; ++pp)
 745         BIO_printf(bio_err, "\t%s: %s\n",
 746                    pp->name,
 747                    (flags & pp->retval) ? "OK" : "NOT OK");
 748     BIO_printf(bio_err, "\tSuite B: ");
 749     if (SSL_set_cert_flags(s, 0) & SSL_CERT_FLAG_SUITEB_128_LOS)
 750         BIO_puts(bio_err, flags & CERT_PKEY_SUITEB ? "OK\n" : "NOT OK\n");
 751     else
 752         BIO_printf(bio_err, "not tested\n");
 753 }
 754
 755 /*
 756  * Very basic selection callback: just use any certificate chain reported as
 757  * valid. More sophisticated could prioritise according to local policy.
 758  */
 759 static int set_cert_cb(SSL *ssl, void *arg)
 760 {
 761     int i, rv;
 762     SSL_EXCERT *exc = arg;
 763 #ifdef CERT_CB_TEST_RETRY
 764     static int retry_cnt;
 765     if (retry_cnt < 5) {
 766         retry_cnt++;
 767         BIO_printf(bio_err,
 768                    "Certificate callback retry test: count %d\n",
 769                    retry_cnt);
 770         return -1;
 771     }
 772 #endif
 773     SSL_certs_clear(ssl);
 774
 775     if (!exc)
 776         return 1;
 777
 778     /*
 779      * Go to end of list and traverse backwards since we prepend newer
 780      * entries this retains the original order.
 781      */
 782     while (exc->next)
 783         exc = exc->next;
 784
 785     i = 0;
 786
 787     while (exc) {
 788         i++;
 789         rv = SSL_check_chain(ssl, exc->cert, exc->key, exc->chain);
 790         BIO_printf(bio_err, "Checking cert chain %d:\nSubject: ", i);
 791         X509_NAME_print_ex(bio_err, X509_get_subject_name(exc->cert), 0,
 792                            XN_FLAG_ONELINE);
 793         BIO_puts(bio_err, "\n");
 794         print_chain_flags(ssl, rv);
 795         if (rv & CERT_PKEY_VALID) {
 796             if (!SSL_use_certificate(ssl, exc->cert)
 797                     || !SSL_use_PrivateKey(ssl, exc->key)) {
 798                 return 0;
 799             }
 800             /*
 801              * NB: we wouldn't normally do this as it is not efficient
 802              * building chains on each connection better to cache the chain
 803              * in advance.
 804              */
 805             if (exc->build_chain) {
 806                 if (!SSL_build_cert_chain(ssl, 0))
 807                     return 0;
 808             } else if (exc->chain)
 809                 SSL_set1_chain(ssl, exc->chain);
 810         }
 811         exc = exc->prev;
 812     }
 813     return 1;
 814 }
 815
 816 void ssl_ctx_set_excert(SSL_CTX *ctx, SSL_EXCERT *exc)
 817 {
 818     SSL_CTX_set_cert_cb(ctx, set_cert_cb, exc);
 819 }
 820
 821 static int ssl_excert_prepend(SSL_EXCERT **pexc)
 822 {
 823     SSL_EXCERT *exc = app_malloc(sizeof(*exc), "prepend cert");
 824
 825     memset(exc, 0, sizeof(*exc));
 826
 827     exc->next = *pexc;
 828     *pexc = exc;
 829
 830     if (exc->next) {
 831         exc->certform = exc->next->certform;
 832         exc->keyform = exc->next->keyform;
 833         exc->next->prev = exc;
 834     } else {
 835         exc->certform = FORMAT_PEM;
 836         exc->keyform = FORMAT_PEM;
 837     }
 838     return 1;
 839
 840 }
 841
 842 void ssl_excert_free(SSL_EXCERT *exc)
 843 {
 844     SSL_EXCERT *curr;
 845
 846     if (!exc)
 847         return;
 848     while (exc) {
 849         X509_free(exc->cert);
 850         EVP_PKEY_free(exc->key);
 851         sk_X509_pop_free(exc->chain, X509_free);
 852         curr = exc;
 853         exc = exc->next;
 854         OPENSSL_free(curr);
 855     }
 856 }
 857
 858 int load_excert(SSL_EXCERT **pexc)
 859 {
 860     SSL_EXCERT *exc = *pexc;
 861     if (!exc)
 862         return 1;
 863     /* If nothing in list, free and set to NULL */
 864     if (!exc->certfile && !exc->next) {
 865         ssl_excert_free(exc);
 866         *pexc = NULL;
 867         return 1;
 868     }
 869     for (; exc; exc = exc->next) {
 870         if (!exc->certfile) {
 871             BIO_printf(bio_err, "Missing filename\n");
 872             return 0;
 873         }
 874         exc->cert = load_cert(exc->certfile, exc->certform,
 875                               "Server Certificate");
 876         if (!exc->cert)
 877             return 0;
 878         if (exc->keyfile) {
 879             exc->key = load_key(exc->keyfile, exc->keyform,
 880                                 0, NULL, NULL, "Server Key");
 881         } else {
 882             exc->key = load_key(exc->certfile, exc->certform,
 883                                 0, NULL, NULL, "Server Key");
 884         }
 885         if (!exc->key)
 886             return 0;
 887         if (exc->chainfile) {
 888             if (!load_certs(exc->chainfile, &exc->chain, FORMAT_PEM, NULL,
 889                             "Server Chain"))
 890                 return 0;
 891         }
 892     }
 893     return 1;
 894 }
 895
 896 enum range { OPT_X_ENUM };
 897
 898 int args_excert(int opt, SSL_EXCERT **pexc)
 899 {
 900     SSL_EXCERT *exc = *pexc;
 901
 902     assert(opt > OPT_X__FIRST);
 903     assert(opt < OPT_X__LAST);
 904
 905     if (exc == NULL) {
 906         if (!ssl_excert_prepend(&exc)) {
 907             BIO_printf(bio_err, " %s: Error initialising xcert\n",
 908                        opt_getprog());
 909             goto err;
 910         }
 911         *pexc = exc;
 912     }
 913
 914     switch ((enum range)opt) {
 915     case OPT_X__FIRST:
 916     case OPT_X__LAST:
 917         return 0;
 918     case OPT_X_CERT:
 919         if (exc->certfile && !ssl_excert_prepend(&exc)) {
 920             BIO_printf(bio_err, "%s: Error adding xcert\n", opt_getprog());
 921             goto err;
 922         }
 923         exc->certfile = opt_arg();
 924         break;
 925     case OPT_X_KEY:
 926         if (exc->keyfile) {
 927             BIO_printf(bio_err, "%s: Key already specified\n", opt_getprog());
 928             goto err;
 929         }
 930         exc->keyfile = opt_arg();
 931         break;
 932     case OPT_X_CHAIN:
 933         if (exc->chainfile) {
 934             BIO_printf(bio_err, "%s: Chain already specified\n",
 935                        opt_getprog());
 936             goto err;
 937         }
 938         exc->chainfile = opt_arg();
 939         break;
 940     case OPT_X_CHAIN_BUILD:
 941         exc->build_chain = 1;
 942         break;
 943     case OPT_X_CERTFORM:
 944         if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &exc->certform))
 945             return 0;
 946         break;
 947     case OPT_X_KEYFORM:
 948         if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &exc->keyform))
 949             return 0;
 950         break;
 951     }
 952     return 1;
 953
 954  err:
 955     ERR_print_errors(bio_err);
 956     ssl_excert_free(exc);
 957     *pexc = NULL;
 958     return 0;
 959 }
 960
 961 static void print_raw_cipherlist(SSL *s)
 962 {
 963     const unsigned char *rlist;
 964     static const unsigned char scsv_id[] = { 0, 0xFF };
 965     size_t i, rlistlen, num;
 966     if (!SSL_is_server(s))
 967         return;
 968     num = SSL_get0_raw_cipherlist(s, NULL);
 969     OPENSSL_assert(num == 2);
 970     rlistlen = SSL_get0_raw_cipherlist(s, &rlist);
 971     BIO_puts(bio_err, "Client cipher list: ");
 972     for (i = 0; i < rlistlen; i += num, rlist += num) {
 973         const SSL_CIPHER *c = SSL_CIPHER_find(s, rlist);
 974         if (i)
 975             BIO_puts(bio_err, ":");
 976         if (c)
 977             BIO_puts(bio_err, SSL_CIPHER_get_name(c));
 978         else if (!memcmp(rlist, scsv_id, num))
 979             BIO_puts(bio_err, "SCSV");
 980         else {
 981             size_t j;
 982             BIO_puts(bio_err, "0x");
 983             for (j = 0; j < num; j++)
 984                 BIO_printf(bio_err, "%02X", rlist[j]);
 985         }
 986     }
 987     BIO_puts(bio_err, "\n");
 988 }
 989
 990 /*
 991  * Hex encoder for TLSA RRdata, not ':' delimited.
 992  */
 993 static char *hexencode(const unsigned char *data, size_t len)
 994 {
 995     static const char *hex = "0123456789abcdef";
 996     char *out;
 997     char *cp;
 998     size_t outlen = 2 * len + 1;
 999     int ilen = (int) outlen;
1000
1001     if (outlen < len || ilen < 0 || outlen != (size_t)ilen) {
1002         BIO_printf(bio_err, "%s: %" PRIu64 "-byte buffer too large to hexencode\n",
1003                    opt_getprog(), (uint64_t)len);
1004         exit(1);
1005     }
1006     cp = out = app_malloc(ilen, "TLSA hex data buffer");
1007
1008     while (len-- > 0) {
1009         *cp++ = hex[(*data >> 4) & 0x0f];
1010         *cp++ = hex[*data++ & 0x0f];
1011     }
1012     *cp = '\0';
1013     return out;
1014 }
1015
1016 void print_verify_detail(SSL *s, BIO *bio)
1017 {
1018     int mdpth;
1019     EVP_PKEY *mspki;
1020     long verify_err = SSL_get_verify_result(s);
1021
1022     if (verify_err == X509_V_OK) {
1023         const char *peername = SSL_get0_peername(s);
1024
1025         BIO_printf(bio, "Verification: OK\n");
1026         if (peername != NULL)
1027             BIO_printf(bio, "Verified peername: %s\n", peername);
1028     } else {
1029         const char *reason = X509_verify_cert_error_string(verify_err);
1030
1031         BIO_printf(bio, "Verification error: %s\n", reason);
1032     }
1033
1034     if ((mdpth = SSL_get0_dane_authority(s, NULL, &mspki)) >= 0) {
1035         uint8_t usage, selector, mtype;
1036         const unsigned char *data = NULL;
1037         size_t dlen = 0;
1038         char *hexdata;
1039
1040         mdpth = SSL_get0_dane_tlsa(s, &usage, &selector, &mtype, &data, &dlen);
1041
1042         /*
1043          * The TLSA data field can be quite long when it is a certificate,
1044          * public key or even a SHA2-512 digest.  Because the initial octets of
1045          * ASN.1 certificates and public keys contain mostly boilerplate OIDs
1046          * and lengths, we show the last 12 bytes of the data instead, as these
1047          * are more likely to distinguish distinct TLSA records.
1048          */
1049 #define TLSA_TAIL_SIZE 12
1050         if (dlen > TLSA_TAIL_SIZE)
1051             hexdata = hexencode(data + dlen - TLSA_TAIL_SIZE, TLSA_TAIL_SIZE);
1052         else
1053             hexdata = hexencode(data, dlen);
1054         BIO_printf(bio, "DANE TLSA %d %d %d %s%s %s at depth %d\n",
1055                    usage, selector, mtype,
1056                    (dlen > TLSA_TAIL_SIZE) ? "..." : "", hexdata,
1057                    (mspki != NULL) ? "signed the certificate" :
1058                    mdpth ? "matched TA certificate" : "matched EE certificate",
1059                    mdpth);
1060         OPENSSL_free(hexdata);
1061     }
1062 }
1063
1064 void print_ssl_summary(SSL *s)
1065 {
1066     const SSL_CIPHER *c;
1067     X509 *peer;
1068     /* const char *pnam = SSL_is_server(s) ? "client" : "server"; */
1069
1070     BIO_printf(bio_err, "Protocol version: %s\n", SSL_get_version(s));
1071     print_raw_cipherlist(s);
1072     c = SSL_get_current_cipher(s);
1073     BIO_printf(bio_err, "Ciphersuite: %s\n", SSL_CIPHER_get_name(c));
1074     do_print_sigalgs(bio_err, s, 0);
1075     peer = SSL_get_peer_certificate(s);
1076     if (peer) {
1077         int nid;
1078
1079         BIO_puts(bio_err, "Peer certificate: ");
1080         X509_NAME_print_ex(bio_err, X509_get_subject_name(peer),
1081                            0, XN_FLAG_ONELINE);
1082         BIO_puts(bio_err, "\n");
1083         if (SSL_get_peer_signature_nid(s, &nid))
1084             BIO_printf(bio_err, "Hash used: %s\n", OBJ_nid2sn(nid));
1085         print_verify_detail(s, bio_err);
1086     } else
1087         BIO_puts(bio_err, "No peer certificate\n");
1088     X509_free(peer);
1089 #ifndef OPENSSL_NO_EC
1090     ssl_print_point_formats(bio_err, s);
1091     if (SSL_is_server(s))
1092         ssl_print_curves(bio_err, s, 1);
1093     else
1094         ssl_print_tmp_key(bio_err, s);
1095 #else
1096     if (!SSL_is_server(s))
1097         ssl_print_tmp_key(bio_err, s);
1098 #endif
1099 }
1100
1101 int config_ctx(SSL_CONF_CTX *cctx, STACK_OF(OPENSSL_STRING) *str,
1102                SSL_CTX *ctx)
1103 {
1104     int i;
1105
1106     SSL_CONF_CTX_set_ssl_ctx(cctx, ctx);
1107     for (i = 0; i < sk_OPENSSL_STRING_num(str); i += 2) {
1108         const char *flag = sk_OPENSSL_STRING_value(str, i);
1109         const char *arg = sk_OPENSSL_STRING_value(str, i + 1);
1110         if (SSL_CONF_cmd(cctx, flag, arg) <= 0) {
1111             if (arg)
1112                 BIO_printf(bio_err, "Error with command: \"%s %s\"\n",
1113                            flag, arg);
1114             else
1115                 BIO_printf(bio_err, "Error with command: \"%s\"\n", flag);
1116             ERR_print_errors(bio_err);
1117             return 0;
1118         }
1119     }
1120     if (!SSL_CONF_CTX_finish(cctx)) {
1121         BIO_puts(bio_err, "Error finishing context\n");
1122         ERR_print_errors(bio_err);
1123         return 0;
1124     }
1125     return 1;
1126 }
1127
1128 static int add_crls_store(X509_STORE *st, STACK_OF(X509_CRL) *crls)
1129 {
1130     X509_CRL *crl;
1131     int i;
1132     for (i = 0; i < sk_X509_CRL_num(crls); i++) {
1133         crl = sk_X509_CRL_value(crls, i);
1134         X509_STORE_add_crl(st, crl);
1135     }
1136     return 1;
1137 }
1138
1139 int ssl_ctx_add_crls(SSL_CTX *ctx, STACK_OF(X509_CRL) *crls, int crl_download)
1140 {
1141     X509_STORE *st;
1142     st = SSL_CTX_get_cert_store(ctx);
1143     add_crls_store(st, crls);
1144     if (crl_download)
1145         store_setup_crl_download(st);
1146     return 1;
1147 }
1148
1149 int ssl_load_stores(SSL_CTX *ctx,
1150                     const char *vfyCApath, const char *vfyCAfile,
1151                     const char *chCApath, const char *chCAfile,
1152                     STACK_OF(X509_CRL) *crls, int crl_download)
1153 {
1154     X509_STORE *vfy = NULL, *ch = NULL;
1155     int rv = 0;
1156     if (vfyCApath != NULL || vfyCAfile != NULL) {
1157         vfy = X509_STORE_new();
1158         if (vfy == NULL)
1159             goto err;
1160         if (!X509_STORE_load_locations(vfy, vfyCAfile, vfyCApath))
1161             goto err;
1162         add_crls_store(vfy, crls);
1163         SSL_CTX_set1_verify_cert_store(ctx, vfy);
1164         if (crl_download)
1165             store_setup_crl_download(vfy);
1166     }
1167     if (chCApath != NULL || chCAfile != NULL) {
1168         ch = X509_STORE_new();
1169         if (ch == NULL)
1170             goto err;
1171         if (!X509_STORE_load_locations(ch, chCAfile, chCApath))
1172             goto err;
1173         SSL_CTX_set1_chain_cert_store(ctx, ch);
1174     }
1175     rv = 1;
1176  err:
1177     X509_STORE_free(vfy);
1178     X509_STORE_free(ch);
1179     return rv;
1180 }
1181
1182 /* Verbose print out of security callback */
1183
1184 typedef struct {
1185     BIO *out;
1186     int verbose;
1187     int (*old_cb) (const SSL *s, const SSL_CTX *ctx, int op, int bits, int nid,
1188                    void *other, void *ex);
1189 } security_debug_ex;
1190
1191 static STRINT_PAIR callback_types[] = {
1192     {"Supported Ciphersuite", SSL_SECOP_CIPHER_SUPPORTED},
1193     {"Shared Ciphersuite", SSL_SECOP_CIPHER_SHARED},
1194     {"Check Ciphersuite", SSL_SECOP_CIPHER_CHECK},
1195 #ifndef OPENSSL_NO_DH
1196     {"Temp DH key bits", SSL_SECOP_TMP_DH},
1197 #endif
1198     {"Supported Curve", SSL_SECOP_CURVE_SUPPORTED},
1199     {"Shared Curve", SSL_SECOP_CURVE_SHARED},
1200     {"Check Curve", SSL_SECOP_CURVE_CHECK},
1201     {"Supported Signature Algorithm digest", SSL_SECOP_SIGALG_SUPPORTED},
1202     {"Shared Signature Algorithm digest", SSL_SECOP_SIGALG_SHARED},
1203     {"Check Signature Algorithm digest", SSL_SECOP_SIGALG_CHECK},
1204     {"Signature Algorithm mask", SSL_SECOP_SIGALG_MASK},
1205     {"Certificate chain EE key", SSL_SECOP_EE_KEY},
1206     {"Certificate chain CA key", SSL_SECOP_CA_KEY},
1207     {"Peer Chain EE key", SSL_SECOP_PEER_EE_KEY},
1208     {"Peer Chain CA key", SSL_SECOP_PEER_CA_KEY},
1209     {"Certificate chain CA digest", SSL_SECOP_CA_MD},
1210     {"Peer chain CA digest", SSL_SECOP_PEER_CA_MD},
1211     {"SSL compression", SSL_SECOP_COMPRESSION},
1212     {"Session ticket", SSL_SECOP_TICKET},
1213     {NULL}
1214 };
1215
1216 static int security_callback_debug(const SSL *s, const SSL_CTX *ctx,
1217                                    int op, int bits, int nid,
1218                                    void *other, void *ex)
1219 {
1220     security_debug_ex *sdb = ex;
1221     int rv, show_bits = 1, cert_md = 0;
1222     const char *nm;
1223     rv = sdb->old_cb(s, ctx, op, bits, nid, other, ex);
1224     if (rv == 1 && sdb->verbose < 2)
1225         return 1;
1226     BIO_puts(sdb->out, "Security callback: ");
1227
1228     nm = lookup(op, callback_types, NULL);
1229     switch (op) {
1230     case SSL_SECOP_TICKET:
1231     case SSL_SECOP_COMPRESSION:
1232         show_bits = 0;
1233         nm = NULL;
1234         break;
1235     case SSL_SECOP_VERSION:
1236         BIO_printf(sdb->out, "Version=%s", lookup(nid, ssl_versions, "???"));
1237         show_bits = 0;
1238         nm = NULL;
1239         break;
1240     case SSL_SECOP_CA_MD:
1241     case SSL_SECOP_PEER_CA_MD:
1242         cert_md = 1;
1243         break;
1244     }
1245     if (nm)
1246         BIO_printf(sdb->out, "%s=", nm);
1247
1248     switch (op & SSL_SECOP_OTHER_TYPE) {
1249
1250     case SSL_SECOP_OTHER_CIPHER:
1251         BIO_puts(sdb->out, SSL_CIPHER_get_name(other));
1252         break;
1253
1254 #ifndef OPENSSL_NO_EC
1255     case SSL_SECOP_OTHER_CURVE:
1256         {
1257             const char *cname;
1258             cname = EC_curve_nid2nist(nid);
1259             if (cname == NULL)
1260                 cname = OBJ_nid2sn(nid);
1261             BIO_puts(sdb->out, cname);
1262         }
1263         break;
1264 #endif
1265 #ifndef OPENSSL_NO_DH
1266     case SSL_SECOP_OTHER_DH:
1267         {
1268             DH *dh = other;
1269             BIO_printf(sdb->out, "%d", DH_bits(dh));
1270             break;
1271         }
1272 #endif
1273     case SSL_SECOP_OTHER_CERT:
1274         {
1275             if (cert_md) {
1276                 int sig_nid = X509_get_signature_nid(other);
1277                 BIO_puts(sdb->out, OBJ_nid2sn(sig_nid));
1278             } else {
1279                 EVP_PKEY *pkey = X509_get0_pubkey(other);
1280                 const char *algname = "";
1281                 EVP_PKEY_asn1_get0_info(NULL, NULL, NULL, NULL,
1282                                         &algname, EVP_PKEY_get0_asn1(pkey));
1283                 BIO_printf(sdb->out, "%s, bits=%d",
1284                            algname, EVP_PKEY_bits(pkey));
1285             }
1286             break;
1287         }
1288     case SSL_SECOP_OTHER_SIGALG:
1289         {
1290             const unsigned char *salg = other;
1291             const char *sname = NULL;
1292             switch (salg[1]) {
1293             case TLSEXT_signature_anonymous:
1294                 sname = "anonymous";
1295                 break;
1296             case TLSEXT_signature_rsa:
1297                 sname = "RSA";
1298                 break;
1299             case TLSEXT_signature_dsa:
1300                 sname = "DSA";
1301                 break;
1302             case TLSEXT_signature_ecdsa:
1303                 sname = "ECDSA";
1304                 break;
1305             }
1306
1307             BIO_puts(sdb->out, OBJ_nid2sn(nid));
1308             if (sname)
1309                 BIO_printf(sdb->out, ", algorithm=%s", sname);
1310             else
1311                 BIO_printf(sdb->out, ", algid=%d", salg[1]);
1312             break;
1313         }
1314
1315     }
1316
1317     if (show_bits)
1318         BIO_printf(sdb->out, ", security bits=%d", bits);
1319     BIO_printf(sdb->out, ": %s\n", rv ? "yes" : "no");
1320     return rv;
1321 }
1322
1323 void ssl_ctx_security_debug(SSL_CTX *ctx, int verbose)
1324 {
1325     static security_debug_ex sdb;
1326
1327     sdb.out = bio_err;
1328     sdb.verbose = verbose;
1329     sdb.old_cb = SSL_CTX_get_security_callback(ctx);
1330     SSL_CTX_set_security_callback(ctx, security_callback_debug);
1331     SSL_CTX_set0_security_ex_data(ctx, &sdb);
1332 }