9481fa51572aa8560e00fa68ec2eb57cdc0e76e6
[openssl.git] / 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 }