2 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
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
10 /* ====================================================================
11 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
12 * ECC cipher suite support in OpenSSL originally developed by
13 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
15 /* ====================================================================
16 * Copyright 2005 Nokia. All rights reserved.
18 * The portions of the attached software ("Contribution") is developed by
19 * Nokia Corporation and is licensed pursuant to the OpenSSL open source
22 * The Contribution, originally written by Mika Kousa and Pasi Eronen of
23 * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
24 * support (see RFC 4279) to OpenSSL.
26 * No patent licenses or other rights except those expressly stated in
27 * the OpenSSL open source license shall be deemed granted or received
28 * expressly, by implication, estoppel, or otherwise.
30 * No assurances are provided by Nokia that the Contribution does not
31 * infringe the patent or other intellectual property rights of any third
32 * party or that the license provides you with all the necessary rights
33 * to make use of the Contribution.
35 * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
36 * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
37 * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
38 * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
42 /* Or gethostname won't be declared properly on Linux and GNU platforms. */
44 # define _BSD_SOURCE 1
46 #ifndef _DEFAULT_SOURCE
47 # define _DEFAULT_SOURCE 1
61 #ifdef OPENSSL_SYS_VMS
63 * Or isascii won't be declared properly on VMS (at least with DECompHP C).
65 # define _XOPEN_SOURCE 500
70 #include <openssl/bio.h>
71 #include <openssl/crypto.h>
72 #include <openssl/evp.h>
73 #include <openssl/x509.h>
74 #include <openssl/x509v3.h>
75 #include <openssl/ssl.h>
76 #include <openssl/err.h>
77 #include <openssl/rand.h>
78 #ifndef OPENSSL_NO_RSA
79 # include <openssl/rsa.h>
81 #ifndef OPENSSL_NO_DSA
82 # include <openssl/dsa.h>
85 # include <openssl/dh.h>
87 #include <openssl/bn.h>
89 # include <openssl/ct.h>
93 * Or gethostname won't be declared properly
94 * on Compaq platforms (at least with DEC C).
95 * Do not try to put it earlier, or IPv6 includes
98 #define _XOPEN_SOURCE_EXTENDED 1
100 #ifdef OPENSSL_SYS_WINDOWS
101 # include <winsock.h>
103 # include OPENSSL_UNISTD
106 static SSL_CTX *s_ctx = NULL;
107 static SSL_CTX *s_ctx2 = NULL;
110 * There is really no standard for this, so let's assign something
115 static int verify_callback(int ok, X509_STORE_CTX *ctx);
116 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg);
117 #define APP_CALLBACK_STRING "Test Callback Argument"
118 struct app_verify_arg {
123 #ifndef OPENSSL_NO_DH
124 static DH *get_dh512(void);
125 static DH *get_dh1024(void);
126 static DH *get_dh1024dsa(void);
129 static char *psk_key = NULL; /* by default PSK is not used */
130 #ifndef OPENSSL_NO_PSK
131 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
133 unsigned int max_identity_len,
135 unsigned int max_psk_len);
136 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
138 unsigned int max_psk_len);
141 static BIO *bio_err = NULL;
142 static BIO *bio_stdout = NULL;
144 #ifndef OPENSSL_NO_NEXTPROTONEG
145 /* Note that this code assumes that this is only a one element list: */
146 static const char NEXT_PROTO_STRING[] = "\x09testproto";
147 static int npn_client = 0;
148 static int npn_server = 0;
149 static int npn_server_reject = 0;
151 static int cb_client_npn(SSL *s, unsigned char **out, unsigned char *outlen,
152 const unsigned char *in, unsigned int inlen,
156 * This callback only returns the protocol string, rather than a length
157 * prefixed set. We assume that NEXT_PROTO_STRING is a one element list
158 * and remove the first byte to chop off the length prefix.
160 *out = (unsigned char *)NEXT_PROTO_STRING + 1;
161 *outlen = sizeof(NEXT_PROTO_STRING) - 2;
162 return SSL_TLSEXT_ERR_OK;
165 static int cb_server_npn(SSL *s, const unsigned char **data,
166 unsigned int *len, void *arg)
168 *data = (const unsigned char *)NEXT_PROTO_STRING;
169 *len = sizeof(NEXT_PROTO_STRING) - 1;
170 return SSL_TLSEXT_ERR_OK;
173 static int cb_server_rejects_npn(SSL *s, const unsigned char **data,
174 unsigned int *len, void *arg)
176 return SSL_TLSEXT_ERR_NOACK;
179 static int verify_npn(SSL *client, SSL *server)
181 const unsigned char *client_s;
183 const unsigned char *server_s;
186 SSL_get0_next_proto_negotiated(client, &client_s, &client_len);
187 SSL_get0_next_proto_negotiated(server, &server_s, &server_len);
190 BIO_printf(bio_stdout, "Client NPN: ");
191 BIO_write(bio_stdout, client_s, client_len);
192 BIO_printf(bio_stdout, "\n");
196 BIO_printf(bio_stdout, "Server NPN: ");
197 BIO_write(bio_stdout, server_s, server_len);
198 BIO_printf(bio_stdout, "\n");
202 * If an NPN string was returned, it must be the protocol that we
203 * expected to negotiate.
205 if (client_len && (client_len != sizeof(NEXT_PROTO_STRING) - 2 ||
206 memcmp(client_s, NEXT_PROTO_STRING + 1, client_len)))
208 if (server_len && (server_len != sizeof(NEXT_PROTO_STRING) - 2 ||
209 memcmp(server_s, NEXT_PROTO_STRING + 1, server_len)))
212 if (!npn_client && client_len)
214 if (!npn_server && server_len)
216 if (npn_server_reject && server_len)
218 if (npn_client && npn_server && (!client_len || !server_len))
225 static const char *alpn_client;
226 static char *alpn_server;
227 static char *alpn_server2;
228 static const char *alpn_expected;
229 static unsigned char *alpn_selected;
230 static const char *server_min_proto;
231 static const char *server_max_proto;
232 static const char *client_min_proto;
233 static const char *client_max_proto;
234 static const char *should_negotiate;
235 static const char *sn_client;
236 static const char *sn_server1;
237 static const char *sn_server2;
238 static int sn_expect = 0;
239 static const char *server_sess_out;
240 static const char *server_sess_in;
241 static const char *client_sess_out;
242 static const char *client_sess_in;
243 static SSL_SESSION *server_sess;
244 static SSL_SESSION *client_sess;
246 static int servername_cb(SSL *s, int *ad, void *arg)
248 const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
249 if (sn_server2 == NULL) {
250 BIO_printf(bio_stdout, "Servername 2 is NULL\n");
251 return SSL_TLSEXT_ERR_NOACK;
255 if (s_ctx2 != NULL && sn_server2 != NULL &&
256 !strcasecmp(servername, sn_server2)) {
257 BIO_printf(bio_stdout, "Switching server context.\n");
258 SSL_set_SSL_CTX(s, s_ctx2);
261 return SSL_TLSEXT_ERR_OK;
263 static int verify_servername(SSL *client, SSL *server)
265 /* just need to see if sn_context is what we expect */
266 SSL_CTX* ctx = SSL_get_SSL_CTX(server);
269 if (sn_expect == 1 && ctx == s_ctx)
271 if (sn_expect == 2 && ctx == s_ctx2)
273 BIO_printf(bio_stdout, "Servername: expected context %d\n", sn_expect);
275 BIO_printf(bio_stdout, "Servername: context is 2\n");
276 else if (ctx == s_ctx)
277 BIO_printf(bio_stdout, "Servername: context is 1\n");
279 BIO_printf(bio_stdout, "Servername: context is unknown\n");
285 * next_protos_parse parses a comma separated list of strings into a string
286 * in a format suitable for passing to SSL_CTX_set_next_protos_advertised.
287 * outlen: (output) set to the length of the resulting buffer on success.
288 * in: a NUL terminated string like "abc,def,ghi"
290 * returns: a malloced buffer or NULL on failure.
292 static unsigned char *next_protos_parse(size_t *outlen,
303 out = OPENSSL_malloc(strlen(in) + 1);
307 for (i = 0; i <= len; ++i) {
308 if (i == len || in[i] == ',') {
309 if (i - start > 255) {
313 out[start] = i - start;
323 static int cb_server_alpn(SSL *s, const unsigned char **out,
324 unsigned char *outlen, const unsigned char *in,
325 unsigned int inlen, void *arg)
327 unsigned char *protos;
329 char* alpn_str = arg;
331 protos = next_protos_parse(&protos_len, alpn_str);
332 if (protos == NULL) {
333 fprintf(stderr, "failed to parser ALPN server protocol string: %s\n",
338 if (SSL_select_next_proto
339 ((unsigned char **)out, outlen, protos, protos_len, in,
340 inlen) != OPENSSL_NPN_NEGOTIATED) {
341 OPENSSL_free(protos);
342 return SSL_TLSEXT_ERR_NOACK;
346 * Make a copy of the selected protocol which will be freed in
349 alpn_selected = OPENSSL_malloc(*outlen);
350 memcpy(alpn_selected, *out, *outlen);
351 *out = alpn_selected;
353 OPENSSL_free(protos);
354 return SSL_TLSEXT_ERR_OK;
357 static int verify_alpn(SSL *client, SSL *server)
359 const unsigned char *client_proto, *server_proto;
360 unsigned int client_proto_len = 0, server_proto_len = 0;
361 SSL_get0_alpn_selected(client, &client_proto, &client_proto_len);
362 SSL_get0_alpn_selected(server, &server_proto, &server_proto_len);
364 OPENSSL_free(alpn_selected);
365 alpn_selected = NULL;
367 if (client_proto_len != server_proto_len) {
368 BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");
372 if (client_proto != NULL &&
373 memcmp(client_proto, server_proto, client_proto_len) != 0) {
374 BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");
378 if (client_proto_len > 0 && alpn_expected == NULL) {
379 BIO_printf(bio_stdout, "ALPN unexpectedly negotiated\n");
383 if (alpn_expected != NULL &&
384 (client_proto_len != strlen(alpn_expected) ||
385 memcmp(client_proto, alpn_expected, client_proto_len) != 0)) {
386 BIO_printf(bio_stdout,
387 "ALPN selected protocols not equal to expected protocol: %s\n",
395 BIO_printf(bio_stdout, "ALPN results: client: '");
396 BIO_write(bio_stdout, client_proto, client_proto_len);
397 BIO_printf(bio_stdout, "', server: '");
398 BIO_write(bio_stdout, server_proto, server_proto_len);
399 BIO_printf(bio_stdout, "'\n");
400 BIO_printf(bio_stdout, "ALPN configured: client: '%s', server: '",
402 if (SSL_get_SSL_CTX(server) == s_ctx2) {
403 BIO_printf(bio_stdout, "%s'\n",
406 BIO_printf(bio_stdout, "%s'\n",
413 * WARNING : below extension types are *NOT* IETF assigned, and could
414 * conflict if these types are reassigned and handled specially by OpenSSL
417 #define TACK_EXT_TYPE 62208
418 #define CUSTOM_EXT_TYPE_0 1000
419 #define CUSTOM_EXT_TYPE_1 1001
420 #define CUSTOM_EXT_TYPE_2 1002
421 #define CUSTOM_EXT_TYPE_3 1003
423 static const char custom_ext_cli_string[] = "abc";
424 static const char custom_ext_srv_string[] = "defg";
426 /* These set from cmdline */
427 static char *serverinfo_file = NULL;
428 static int serverinfo_sct = 0;
429 static int serverinfo_tack = 0;
431 /* These set based on extension callbacks */
432 static int serverinfo_sct_seen = 0;
433 static int serverinfo_tack_seen = 0;
434 static int serverinfo_other_seen = 0;
436 /* This set from cmdline */
437 static int custom_ext = 0;
439 /* This set based on extension callbacks */
440 static int custom_ext_error = 0;
442 static int serverinfo_cli_parse_cb(SSL *s, unsigned int ext_type,
443 const unsigned char *in, size_t inlen,
446 if (ext_type == TLSEXT_TYPE_signed_certificate_timestamp)
447 serverinfo_sct_seen++;
448 else if (ext_type == TACK_EXT_TYPE)
449 serverinfo_tack_seen++;
451 serverinfo_other_seen++;
455 static int verify_serverinfo()
457 if (serverinfo_sct != serverinfo_sct_seen)
459 if (serverinfo_tack != serverinfo_tack_seen)
461 if (serverinfo_other_seen)
467 * Four test cases for custom extensions:
468 * 0 - no ClientHello extension or ServerHello response
469 * 1 - ClientHello with "abc", no response
470 * 2 - ClientHello with "abc", empty response
471 * 3 - ClientHello with "abc", "defg" response
474 static int custom_ext_0_cli_add_cb(SSL *s, unsigned int ext_type,
475 const unsigned char **out,
476 size_t *outlen, int *al, void *arg)
478 if (ext_type != CUSTOM_EXT_TYPE_0)
479 custom_ext_error = 1;
480 return 0; /* Don't send an extension */
483 static int custom_ext_0_cli_parse_cb(SSL *s, unsigned int ext_type,
484 const unsigned char *in,
485 size_t inlen, int *al, void *arg)
490 static int custom_ext_1_cli_add_cb(SSL *s, unsigned int ext_type,
491 const unsigned char **out,
492 size_t *outlen, int *al, void *arg)
494 if (ext_type != CUSTOM_EXT_TYPE_1)
495 custom_ext_error = 1;
496 *out = (const unsigned char *)custom_ext_cli_string;
497 *outlen = strlen(custom_ext_cli_string);
498 return 1; /* Send "abc" */
501 static int custom_ext_1_cli_parse_cb(SSL *s, unsigned int ext_type,
502 const unsigned char *in,
503 size_t inlen, int *al, void *arg)
508 static int custom_ext_2_cli_add_cb(SSL *s, unsigned int ext_type,
509 const unsigned char **out,
510 size_t *outlen, int *al, void *arg)
512 if (ext_type != CUSTOM_EXT_TYPE_2)
513 custom_ext_error = 1;
514 *out = (const unsigned char *)custom_ext_cli_string;
515 *outlen = strlen(custom_ext_cli_string);
516 return 1; /* Send "abc" */
519 static int custom_ext_2_cli_parse_cb(SSL *s, unsigned int ext_type,
520 const unsigned char *in,
521 size_t inlen, int *al, void *arg)
523 if (ext_type != CUSTOM_EXT_TYPE_2)
524 custom_ext_error = 1;
526 custom_ext_error = 1; /* Should be empty response */
530 static int custom_ext_3_cli_add_cb(SSL *s, unsigned int ext_type,
531 const unsigned char **out,
532 size_t *outlen, int *al, void *arg)
534 if (ext_type != CUSTOM_EXT_TYPE_3)
535 custom_ext_error = 1;
536 *out = (const unsigned char *)custom_ext_cli_string;
537 *outlen = strlen(custom_ext_cli_string);
538 return 1; /* Send "abc" */
541 static int custom_ext_3_cli_parse_cb(SSL *s, unsigned int ext_type,
542 const unsigned char *in,
543 size_t inlen, int *al, void *arg)
545 if (ext_type != CUSTOM_EXT_TYPE_3)
546 custom_ext_error = 1;
547 if (inlen != strlen(custom_ext_srv_string))
548 custom_ext_error = 1;
549 if (memcmp(custom_ext_srv_string, in, inlen) != 0)
550 custom_ext_error = 1; /* Check for "defg" */
555 * custom_ext_0_cli_add_cb returns 0 - the server won't receive a callback
558 static int custom_ext_0_srv_parse_cb(SSL *s, unsigned int ext_type,
559 const unsigned char *in,
560 size_t inlen, int *al, void *arg)
562 custom_ext_error = 1;
566 /* 'add' callbacks are only called if the 'parse' callback is called */
567 static int custom_ext_0_srv_add_cb(SSL *s, unsigned int ext_type,
568 const unsigned char **out,
569 size_t *outlen, int *al, void *arg)
571 /* Error: should not have been called */
572 custom_ext_error = 1;
573 return 0; /* Don't send an extension */
576 static int custom_ext_1_srv_parse_cb(SSL *s, unsigned int ext_type,
577 const unsigned char *in,
578 size_t inlen, int *al, void *arg)
580 if (ext_type != CUSTOM_EXT_TYPE_1)
581 custom_ext_error = 1;
582 /* Check for "abc" */
583 if (inlen != strlen(custom_ext_cli_string))
584 custom_ext_error = 1;
585 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
586 custom_ext_error = 1;
590 static int custom_ext_1_srv_add_cb(SSL *s, unsigned int ext_type,
591 const unsigned char **out,
592 size_t *outlen, int *al, void *arg)
594 return 0; /* Don't send an extension */
597 static int custom_ext_2_srv_parse_cb(SSL *s, unsigned int ext_type,
598 const unsigned char *in,
599 size_t inlen, int *al, void *arg)
601 if (ext_type != CUSTOM_EXT_TYPE_2)
602 custom_ext_error = 1;
603 /* Check for "abc" */
604 if (inlen != strlen(custom_ext_cli_string))
605 custom_ext_error = 1;
606 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
607 custom_ext_error = 1;
611 static int custom_ext_2_srv_add_cb(SSL *s, unsigned int ext_type,
612 const unsigned char **out,
613 size_t *outlen, int *al, void *arg)
617 return 1; /* Send empty extension */
620 static int custom_ext_3_srv_parse_cb(SSL *s, unsigned int ext_type,
621 const unsigned char *in,
622 size_t inlen, int *al, void *arg)
624 if (ext_type != CUSTOM_EXT_TYPE_3)
625 custom_ext_error = 1;
626 /* Check for "abc" */
627 if (inlen != strlen(custom_ext_cli_string))
628 custom_ext_error = 1;
629 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
630 custom_ext_error = 1;
634 static int custom_ext_3_srv_add_cb(SSL *s, unsigned int ext_type,
635 const unsigned char **out,
636 size_t *outlen, int *al, void *arg)
638 *out = (const unsigned char *)custom_ext_srv_string;
639 *outlen = strlen(custom_ext_srv_string);
640 return 1; /* Send "defg" */
643 static char *cipher = NULL;
644 static int verbose = 0;
645 static int debug = 0;
646 static const char rnd_seed[] =
647 "string to make the random number generator think it has entropy";
649 int doit_localhost(SSL *s_ssl, SSL *c_ssl, int family,
650 long bytes, clock_t *s_time, clock_t *c_time);
651 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long bytes, clock_t *s_time,
653 int doit(SSL *s_ssl, SSL *c_ssl, long bytes);
655 static void sv_usage(void)
657 fprintf(stderr, "usage: ssltest [args ...]\n");
658 fprintf(stderr, "\n");
659 fprintf(stderr, " -server_auth - check server certificate\n");
660 fprintf(stderr, " -client_auth - do client authentication\n");
661 fprintf(stderr, " -v - more output\n");
662 fprintf(stderr, " -d - debug output\n");
663 fprintf(stderr, " -reuse - use session-id reuse\n");
664 fprintf(stderr, " -num <val> - number of connections to perform\n");
666 " -bytes <val> - number of bytes to swap between client/server\n");
667 #ifndef OPENSSL_NO_DH
669 " -dhe512 - use 512 bit key for DHE (to test failure)\n");
671 " -dhe1024 - use 1024 bit key (safe prime) for DHE (default, no-op)\n");
673 " -dhe1024dsa - use 1024 bit key (with 160-bit subprime) for DHE\n");
674 fprintf(stderr, " -no_dhe - disable DHE\n");
676 #ifndef OPENSSL_NO_EC
677 fprintf(stderr, " -no_ecdhe - disable ECDHE\nTODO(openssl-team): no_ecdhe was broken by auto ecdh. Make this work again.\n");
679 #ifndef OPENSSL_NO_PSK
680 fprintf(stderr, " -psk arg - PSK in hex (without 0x)\n");
682 #ifndef OPENSSL_NO_SSL3
683 fprintf(stderr, " -ssl3 - use SSLv3\n");
685 #ifndef OPENSSL_NO_TLS1
686 fprintf(stderr, " -tls1 - use TLSv1\n");
688 #ifndef OPENSSL_NO_DTLS
689 fprintf(stderr, " -dtls - use DTLS\n");
690 #ifndef OPENSSL_NO_DTLS1
691 fprintf(stderr, " -dtls1 - use DTLSv1\n");
693 #ifndef OPENSSL_NO_DTLS1_2
694 fprintf(stderr, " -dtls12 - use DTLSv1.2\n");
697 fprintf(stderr, " -CApath arg - PEM format directory of CA's\n");
698 fprintf(stderr, " -CAfile arg - PEM format file of CA's\n");
699 fprintf(stderr, " -cert arg - Server certificate file\n");
701 " -key arg - Server key file (default: same as -cert)\n");
702 fprintf(stderr, " -c_cert arg - Client certificate file\n");
704 " -c_key arg - Client key file (default: same as -c_cert)\n");
705 fprintf(stderr, " -cipher arg - The cipher list\n");
706 fprintf(stderr, " -bio_pair - Use BIO pairs\n");
707 fprintf(stderr, " -ipv4 - Use IPv4 connection on localhost\n");
708 fprintf(stderr, " -ipv6 - Use IPv6 connection on localhost\n");
709 fprintf(stderr, " -f - Test even cases that can't work\n");
711 " -time - measure processor time used by client and server\n");
712 fprintf(stderr, " -zlib - use zlib compression\n");
713 #ifndef OPENSSL_NO_NEXTPROTONEG
714 fprintf(stderr, " -npn_client - have client side offer NPN\n");
715 fprintf(stderr, " -npn_server - have server side offer NPN\n");
716 fprintf(stderr, " -npn_server_reject - have server reject NPN\n");
718 fprintf(stderr, " -serverinfo_file file - have server use this file\n");
719 fprintf(stderr, " -serverinfo_sct - have client offer and expect SCT\n");
721 " -serverinfo_tack - have client offer and expect TACK\n");
723 " -custom_ext - try various custom extension callbacks\n");
724 fprintf(stderr, " -alpn_client <string> - have client side offer ALPN\n");
725 fprintf(stderr, " -alpn_server <string> - have server side offer ALPN\n");
726 fprintf(stderr, " -alpn_server1 <string> - alias for -alpn_server\n");
727 fprintf(stderr, " -alpn_server2 <string> - have server side context 2 offer ALPN\n");
729 " -alpn_expected <string> - the ALPN protocol that should be negotiated\n");
730 fprintf(stderr, " -server_min_proto <string> - Minimum version the server should support\n");
731 fprintf(stderr, " -server_max_proto <string> - Maximum version the server should support\n");
732 fprintf(stderr, " -client_min_proto <string> - Minimum version the client should support\n");
733 fprintf(stderr, " -client_max_proto <string> - Maximum version the client should support\n");
734 fprintf(stderr, " -should_negotiate <string> - The version that should be negotiated, fail-client or fail-server\n");
735 #ifndef OPENSSL_NO_CT
736 fprintf(stderr, " -noct - no certificate transparency\n");
737 fprintf(stderr, " -requestct - request certificate transparency\n");
738 fprintf(stderr, " -requirect - require certificate transparency\n");
740 fprintf(stderr, " -sn_client <string> - have client request this servername\n");
741 fprintf(stderr, " -sn_server1 <string> - have server context 1 respond to this servername\n");
742 fprintf(stderr, " -sn_server2 <string> - have server context 2 respond to this servername\n");
743 fprintf(stderr, " -sn_expect1 - expected server 1\n");
744 fprintf(stderr, " -sn_expect2 - expected server 2\n");
745 fprintf(stderr, " -server_sess_out <file> - Save the server session to a file\n");
746 fprintf(stderr, " -server_sess_in <file> - Read the server session from a file\n");
747 fprintf(stderr, " -client_sess_out <file> - Save the client session to a file\n");
748 fprintf(stderr, " -client_sess_in <file> - Read the client session from a file\n");
749 fprintf(stderr, " -should_reuse <number> - The expected state of reusing the session\n");
750 fprintf(stderr, " -no_ticket - do not issue TLS session ticket\n");
753 static void print_key_details(BIO *out, EVP_PKEY *key)
755 int keyid = EVP_PKEY_id(key);
756 #ifndef OPENSSL_NO_EC
757 if (keyid == EVP_PKEY_EC) {
758 EC_KEY *ec = EVP_PKEY_get1_EC_KEY(key);
761 nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
763 cname = EC_curve_nid2nist(nid);
765 cname = OBJ_nid2sn(nid);
766 BIO_printf(out, "%d bits EC (%s)", EVP_PKEY_bits(key), cname);
782 algname = OBJ_nid2sn(keyid);
785 BIO_printf(out, "%d bits %s", EVP_PKEY_bits(key), algname);
789 static void print_details(SSL *c_ssl, const char *prefix)
791 const SSL_CIPHER *ciph;
796 ciph = SSL_get_current_cipher(c_ssl);
797 BIO_printf(bio_stdout, "%s%s, cipher %s %s",
799 SSL_get_version(c_ssl),
800 SSL_CIPHER_get_version(ciph), SSL_CIPHER_get_name(ciph));
801 cert = SSL_get_peer_certificate(c_ssl);
803 EVP_PKEY* pubkey = X509_get0_pubkey(cert);
805 if (pubkey != NULL) {
806 BIO_puts(bio_stdout, ", ");
807 print_key_details(bio_stdout, pubkey);
811 if (SSL_get_server_tmp_key(c_ssl, &pkey)) {
812 BIO_puts(bio_stdout, ", temp key: ");
813 print_key_details(bio_stdout, pkey);
816 if (SSL_get_peer_signature_nid(c_ssl, &mdnid))
817 BIO_printf(bio_stdout, ", digest=%s", OBJ_nid2sn(mdnid));
818 BIO_printf(bio_stdout, "\n");
822 * protocol_from_string - converts a protocol version string to a number
824 * Returns -1 on failure or the version on success
826 static int protocol_from_string(const char *value)
828 struct protocol_versions {
832 static const struct protocol_versions versions[] = {
833 {"ssl3", SSL3_VERSION},
834 {"tls1", TLS1_VERSION},
835 {"tls1.1", TLS1_1_VERSION},
836 {"tls1.2", TLS1_2_VERSION},
837 {"tls1.3", TLS1_3_VERSION},
838 {"dtls1", DTLS1_VERSION},
839 {"dtls1.2", DTLS1_2_VERSION}};
841 size_t n = OSSL_NELEM(versions);
843 for (i = 0; i < n; i++)
844 if (strcmp(versions[i].name, value) == 0)
845 return versions[i].version;
849 static SSL_SESSION *read_session(const char *filename)
852 BIO *f = BIO_new_file(filename, "r");
855 BIO_printf(bio_err, "Can't open session file %s\n", filename);
856 ERR_print_errors(bio_err);
859 sess = PEM_read_bio_SSL_SESSION(f, NULL, 0, NULL);
861 BIO_printf(bio_err, "Can't parse session file %s\n", filename);
862 ERR_print_errors(bio_err);
868 static int write_session(const char *filename, SSL_SESSION *sess)
870 BIO *f = BIO_new_file(filename, "w");
873 BIO_printf(bio_err, "No session information\n");
877 BIO_printf(bio_err, "Can't open session file %s\n", filename);
878 ERR_print_errors(bio_err);
881 PEM_write_bio_SSL_SESSION(f, sess);
887 * set_protocol_version - Sets protocol version minimum or maximum
889 * Returns 0 on failure and 1 on success
891 static int set_protocol_version(const char *version, SSL *ssl, int setting)
893 if (version != NULL) {
894 int ver = protocol_from_string(version);
896 BIO_printf(bio_err, "Error parsing: %s\n", version);
899 return SSL_ctrl(ssl, setting, ver, NULL);
904 int main(int argc, char *argv[])
906 const char *CApath = NULL, *CAfile = NULL;
908 enum { BIO_MEM, BIO_PAIR, BIO_IPV4, BIO_IPV6 } bio_type = BIO_MEM;
910 int dtls1 = 0, dtls12 = 0, dtls = 0, tls1 = 0, tls1_2 = 0, ssl3 = 0, ret = 1;
912 int server_auth = 0, i;
913 struct app_verify_arg app_verify_arg =
914 { APP_CALLBACK_STRING, 0 };
916 SSL_CTX *c_ctx = NULL;
917 const SSL_METHOD *meth = NULL;
919 int number = 1, reuse = 0;
920 int should_reuse = -1;
923 #ifndef OPENSSL_NO_DH
925 int dhe512 = 0, dhe1024dsa = 0;
930 clock_t s_time = 0, c_time = 0;
931 #ifndef OPENSSL_NO_COMP
933 COMP_METHOD *cm = NULL;
934 STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
937 int min_version = 0, max_version = 0;
938 #ifndef OPENSSL_NO_CT
940 * Disable CT validation by default, because it will interfere with
941 * anything using custom extension handlers to deal with SCT extensions.
943 int ct_validation = 0;
945 SSL_CONF_CTX *s_cctx = NULL, *c_cctx = NULL, *s_cctx2 = NULL;
946 STACK_OF(OPENSSL_STRING) *conf_args = NULL;
947 char *arg = NULL, *argn = NULL;
953 bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
955 p = getenv("OPENSSL_DEBUG_MEMORY");
956 if (p != NULL && strcmp(p, "on") == 0)
957 CRYPTO_set_mem_debug(1);
958 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
960 RAND_seed(rnd_seed, sizeof rnd_seed);
962 bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);
964 s_cctx = SSL_CONF_CTX_new();
965 s_cctx2 = SSL_CONF_CTX_new();
966 c_cctx = SSL_CONF_CTX_new();
968 if (!s_cctx || !c_cctx || !s_cctx2) {
969 ERR_print_errors(bio_err);
973 SSL_CONF_CTX_set_flags(s_cctx,
974 SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_SERVER |
975 SSL_CONF_FLAG_CERTIFICATE |
976 SSL_CONF_FLAG_REQUIRE_PRIVATE);
977 SSL_CONF_CTX_set_flags(s_cctx2,
978 SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_SERVER |
979 SSL_CONF_FLAG_CERTIFICATE |
980 SSL_CONF_FLAG_REQUIRE_PRIVATE);
981 if (!SSL_CONF_CTX_set1_prefix(s_cctx, "-s_")) {
982 ERR_print_errors(bio_err);
985 if (!SSL_CONF_CTX_set1_prefix(s_cctx2, "-s_")) {
986 ERR_print_errors(bio_err);
990 SSL_CONF_CTX_set_flags(c_cctx,
991 SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_CLIENT |
992 SSL_CONF_FLAG_CERTIFICATE |
993 SSL_CONF_FLAG_REQUIRE_PRIVATE);
994 if (!SSL_CONF_CTX_set1_prefix(c_cctx, "-c_")) {
995 ERR_print_errors(bio_err);
1003 if (strcmp(*argv, "-F") == 0) {
1005 "not compiled with FIPS support, so exiting without running.\n");
1007 } else if (strcmp(*argv, "-server_auth") == 0)
1009 else if (strcmp(*argv, "-client_auth") == 0)
1011 else if (strcmp(*argv, "-v") == 0)
1013 else if (strcmp(*argv, "-d") == 0)
1015 else if (strcmp(*argv, "-reuse") == 0)
1017 else if (strcmp(*argv, "-dhe512") == 0) {
1018 #ifndef OPENSSL_NO_DH
1022 "ignoring -dhe512, since I'm compiled without DH\n");
1024 } else if (strcmp(*argv, "-dhe1024dsa") == 0) {
1025 #ifndef OPENSSL_NO_DH
1029 "ignoring -dhe1024dsa, since I'm compiled without DH\n");
1031 } else if (strcmp(*argv, "-no_dhe") == 0)
1033 else if (strcmp(*argv, "-no_ecdhe") == 0)
1035 else if (strcmp(*argv, "-psk") == 0) {
1038 psk_key = *(++argv);
1039 #ifndef OPENSSL_NO_PSK
1040 if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key)) {
1041 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
1048 else if (strcmp(*argv, "-tls1_2") == 0) {
1050 } else if (strcmp(*argv, "-tls1") == 0) {
1052 } else if (strcmp(*argv, "-ssl3") == 0) {
1054 } else if (strcmp(*argv, "-dtls1") == 0) {
1056 } else if (strcmp(*argv, "-dtls12") == 0) {
1058 } else if (strcmp(*argv, "-dtls") == 0) {
1060 } else if (strncmp(*argv, "-num", 4) == 0) {
1063 number = atoi(*(++argv));
1066 } else if (strcmp(*argv, "-bytes") == 0) {
1069 bytes = atol(*(++argv));
1072 i = strlen(argv[0]);
1073 if (argv[0][i - 1] == 'k')
1075 if (argv[0][i - 1] == 'm')
1076 bytes *= 1024L * 1024L;
1077 } else if (strcmp(*argv, "-cipher") == 0) {
1081 } else if (strcmp(*argv, "-CApath") == 0) {
1085 } else if (strcmp(*argv, "-CAfile") == 0) {
1089 } else if (strcmp(*argv, "-bio_pair") == 0) {
1090 bio_type = BIO_PAIR;
1092 #ifndef OPENSSL_NO_SOCK
1093 else if (strcmp(*argv, "-ipv4") == 0) {
1094 bio_type = BIO_IPV4;
1095 } else if (strcmp(*argv, "-ipv6") == 0) {
1096 bio_type = BIO_IPV6;
1099 else if (strcmp(*argv, "-f") == 0) {
1101 } else if (strcmp(*argv, "-time") == 0) {
1104 #ifndef OPENSSL_NO_CT
1105 else if (strcmp(*argv, "-noct") == 0) {
1108 else if (strcmp(*argv, "-ct") == 0) {
1112 #ifndef OPENSSL_NO_COMP
1113 else if (strcmp(*argv, "-zlib") == 0) {
1117 else if (strcmp(*argv, "-app_verify") == 0) {
1118 app_verify_arg.app_verify = 1;
1120 #ifndef OPENSSL_NO_NEXTPROTONEG
1121 else if (strcmp(*argv, "-npn_client") == 0) {
1123 } else if (strcmp(*argv, "-npn_server") == 0) {
1125 } else if (strcmp(*argv, "-npn_server_reject") == 0) {
1126 npn_server_reject = 1;
1129 else if (strcmp(*argv, "-serverinfo_sct") == 0) {
1131 } else if (strcmp(*argv, "-serverinfo_tack") == 0) {
1132 serverinfo_tack = 1;
1133 } else if (strcmp(*argv, "-serverinfo_file") == 0) {
1136 serverinfo_file = *(++argv);
1137 } else if (strcmp(*argv, "-custom_ext") == 0) {
1139 } else if (strcmp(*argv, "-alpn_client") == 0) {
1142 alpn_client = *(++argv);
1143 } else if (strcmp(*argv, "-alpn_server") == 0 ||
1144 strcmp(*argv, "-alpn_server1") == 0) {
1147 alpn_server = *(++argv);
1148 } else if (strcmp(*argv, "-alpn_server2") == 0) {
1151 alpn_server2 = *(++argv);
1152 } else if (strcmp(*argv, "-alpn_expected") == 0) {
1155 alpn_expected = *(++argv);
1156 } else if (strcmp(*argv, "-server_min_proto") == 0) {
1159 server_min_proto = *(++argv);
1160 } else if (strcmp(*argv, "-server_max_proto") == 0) {
1163 server_max_proto = *(++argv);
1164 } else if (strcmp(*argv, "-client_min_proto") == 0) {
1167 client_min_proto = *(++argv);
1168 } else if (strcmp(*argv, "-client_max_proto") == 0) {
1171 client_max_proto = *(++argv);
1172 } else if (strcmp(*argv, "-should_negotiate") == 0) {
1175 should_negotiate = *(++argv);
1176 } else if (strcmp(*argv, "-sn_client") == 0) {
1179 sn_client = *(++argv);
1180 } else if (strcmp(*argv, "-sn_server1") == 0) {
1183 sn_server1 = *(++argv);
1184 } else if (strcmp(*argv, "-sn_server2") == 0) {
1187 sn_server2 = *(++argv);
1188 } else if (strcmp(*argv, "-sn_expect1") == 0) {
1190 } else if (strcmp(*argv, "-sn_expect2") == 0) {
1192 } else if (strcmp(*argv, "-server_sess_out") == 0) {
1195 server_sess_out = *(++argv);
1196 } else if (strcmp(*argv, "-server_sess_in") == 0) {
1199 server_sess_in = *(++argv);
1200 } else if (strcmp(*argv, "-client_sess_out") == 0) {
1203 client_sess_out = *(++argv);
1204 } else if (strcmp(*argv, "-client_sess_in") == 0) {
1207 client_sess_in = *(++argv);
1208 } else if (strcmp(*argv, "-should_reuse") == 0) {
1211 should_reuse = !!atoi(*(++argv));
1212 } else if (strcmp(*argv, "-no_ticket") == 0) {
1218 /* Try to process command using SSL_CONF */
1219 rv = SSL_CONF_cmd_argv(c_cctx, &argc, &argv);
1220 /* If not processed try server */
1222 rv = SSL_CONF_cmd_argv(s_cctx, &argc, &argv);
1223 /* Recognised: store it for later use */
1228 conf_args = sk_OPENSSL_STRING_new_null();
1232 if (!sk_OPENSSL_STRING_push(conf_args, arg))
1234 if (!sk_OPENSSL_STRING_push(conf_args, argn))
1239 BIO_printf(bio_err, "Missing argument for %s\n", arg);
1241 BIO_printf(bio_err, "Error with command %s\n", arg);
1243 BIO_printf(bio_err, "unknown option %s\n", arg);
1256 if (ssl3 + tls1 + tls1_2 + dtls + dtls1 + dtls12 > 1) {
1257 fprintf(stderr, "At most one of -ssl3, -tls1, -tls1_2, -dtls, -dtls1 or -dtls12 should "
1262 #ifdef OPENSSL_NO_SSL3
1267 #ifdef OPENSSL_NO_TLS1
1272 #ifdef OPENSSL_NO_TLS1_2
1277 #if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1)
1282 #if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1_2)
1290 * Testing was requested for a compiled-out protocol (e.g. SSLv3).
1291 * Ideally, we would error out, but the generic test wrapper can't know
1292 * when to expect failure. So we do nothing and return success.
1295 fprintf(stderr, "Testing was requested for a disabled protocol. "
1296 "Skipping tests.\n");
1301 if (!ssl3 && !tls1 && !tls1_2 && !dtls && !dtls1 && !dtls12 && number > 1
1302 && !reuse && !force) {
1303 fprintf(stderr, "This case cannot work. Use -f to perform "
1304 "the test anyway (and\n-d to see what happens), "
1305 "or add one of -ssl3, -tls1, -tls1_2, -dtls, -dtls1, -dtls12, -reuse\n"
1306 "to avoid protocol mismatch.\n");
1311 if (bio_type != BIO_PAIR) {
1312 fprintf(stderr, "Using BIO pair (-bio_pair)\n");
1313 bio_type = BIO_PAIR;
1315 if (number < 50 && !force)
1317 "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
1320 #ifndef OPENSSL_NO_COMP
1321 if (comp == COMP_ZLIB)
1324 if (COMP_get_type(cm) != NID_undef) {
1325 if (SSL_COMP_add_compression_method(comp, cm) != 0) {
1326 fprintf(stderr, "Failed to add compression method\n");
1327 ERR_print_errors_fp(stderr);
1331 "Warning: %s compression not supported\n",
1332 comp == COMP_ZLIB ? "zlib" : "unknown");
1333 ERR_print_errors_fp(stderr);
1336 ssl_comp_methods = SSL_COMP_get_compression_methods();
1337 n = sk_SSL_COMP_num(ssl_comp_methods);
1340 printf("Available compression methods:");
1341 for (j = 0; j < n; j++) {
1342 SSL_COMP *c = sk_SSL_COMP_value(ssl_comp_methods, j);
1343 printf(" %s:%d", SSL_COMP_get0_name(c), SSL_COMP_get_id(c));
1349 #ifndef OPENSSL_NO_TLS
1350 meth = TLS_method();
1352 min_version = SSL3_VERSION;
1353 max_version = SSL3_VERSION;
1355 min_version = TLS1_VERSION;
1356 max_version = TLS1_VERSION;
1357 } else if (tls1_2) {
1358 min_version = TLS1_2_VERSION;
1359 max_version = TLS1_2_VERSION;
1362 #ifndef OPENSSL_NO_DTLS
1363 if (dtls || dtls1 || dtls12)
1364 meth = DTLS_method();
1366 min_version = DTLS1_VERSION;
1367 max_version = DTLS1_VERSION;
1368 } else if (dtls12) {
1369 min_version = DTLS1_2_VERSION;
1370 max_version = DTLS1_2_VERSION;
1374 c_ctx = SSL_CTX_new(meth);
1375 s_ctx = SSL_CTX_new(meth);
1376 s_ctx2 = SSL_CTX_new(meth); /* no SSL_CTX_dup! */
1377 if ((c_ctx == NULL) || (s_ctx == NULL) || (s_ctx2 == NULL)) {
1378 ERR_print_errors(bio_err);
1382 * Since we will use low security ciphersuites and keys for testing set
1383 * security level to zero by default. Tests can override this by adding
1384 * "@SECLEVEL=n" to the cipher string.
1386 SSL_CTX_set_security_level(c_ctx, 0);
1387 SSL_CTX_set_security_level(s_ctx, 0);
1388 SSL_CTX_set_security_level(s_ctx2, 0);
1391 SSL_CTX_set_options(c_ctx, SSL_OP_NO_TICKET);
1392 SSL_CTX_set_options(s_ctx, SSL_OP_NO_TICKET);
1395 if (SSL_CTX_set_min_proto_version(c_ctx, min_version) == 0)
1397 if (SSL_CTX_set_max_proto_version(c_ctx, max_version) == 0)
1399 if (SSL_CTX_set_min_proto_version(s_ctx, min_version) == 0)
1401 if (SSL_CTX_set_max_proto_version(s_ctx, max_version) == 0)
1404 if (cipher != NULL) {
1405 if (!SSL_CTX_set_cipher_list(c_ctx, cipher)
1406 || !SSL_CTX_set_cipher_list(s_ctx, cipher)
1407 || !SSL_CTX_set_cipher_list(s_ctx2, cipher)) {
1408 ERR_print_errors(bio_err);
1413 #ifndef OPENSSL_NO_CT
1414 if (ct_validation &&
1415 !SSL_CTX_enable_ct(c_ctx, SSL_CT_VALIDATION_STRICT)) {
1416 ERR_print_errors(bio_err);
1421 /* Process SSL_CONF arguments */
1422 SSL_CONF_CTX_set_ssl_ctx(c_cctx, c_ctx);
1423 SSL_CONF_CTX_set_ssl_ctx(s_cctx, s_ctx);
1424 SSL_CONF_CTX_set_ssl_ctx(s_cctx2, s_ctx2);
1426 for (i = 0; i < sk_OPENSSL_STRING_num(conf_args); i += 2) {
1428 arg = sk_OPENSSL_STRING_value(conf_args, i);
1429 argn = sk_OPENSSL_STRING_value(conf_args, i + 1);
1430 rv = SSL_CONF_cmd(c_cctx, arg, argn);
1431 /* If not recognised use server context */
1433 rv = SSL_CONF_cmd(s_cctx2, arg, argn);
1435 rv = SSL_CONF_cmd(s_cctx, arg, argn);
1438 BIO_printf(bio_err, "Error processing %s %s\n",
1439 arg, argn ? argn : "");
1440 ERR_print_errors(bio_err);
1445 if (!SSL_CONF_CTX_finish(s_cctx) || !SSL_CONF_CTX_finish(c_cctx) || !SSL_CONF_CTX_finish(s_cctx2)) {
1446 BIO_puts(bio_err, "Error finishing context\n");
1447 ERR_print_errors(bio_err);
1450 #ifndef OPENSSL_NO_DH
1453 dh = get_dh1024dsa();
1458 SSL_CTX_set_tmp_dh(s_ctx, dh);
1459 SSL_CTX_set_tmp_dh(s_ctx2, dh);
1466 if ((!SSL_CTX_load_verify_locations(s_ctx, CAfile, CApath)) ||
1467 (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1468 (!SSL_CTX_load_verify_locations(s_ctx2, CAfile, CApath)) ||
1469 (!SSL_CTX_set_default_verify_paths(s_ctx2)) ||
1470 (!SSL_CTX_load_verify_locations(c_ctx, CAfile, CApath)) ||
1471 (!SSL_CTX_set_default_verify_paths(c_ctx))) {
1472 ERR_print_errors(bio_err);
1475 #ifndef OPENSSL_NO_CT
1476 if (!SSL_CTX_set_default_ctlog_list_file(s_ctx) ||
1477 !SSL_CTX_set_default_ctlog_list_file(s_ctx2) ||
1478 !SSL_CTX_set_default_ctlog_list_file(c_ctx)) {
1479 ERR_print_errors(bio_err);
1484 printf("client authentication\n");
1485 SSL_CTX_set_verify(s_ctx,
1486 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1488 SSL_CTX_set_verify(s_ctx2,
1489 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1491 SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback,
1493 SSL_CTX_set_cert_verify_callback(s_ctx2, app_verify_callback,
1497 printf("server authentication\n");
1498 SSL_CTX_set_verify(c_ctx, SSL_VERIFY_PEER, verify_callback);
1499 SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback,
1504 int session_id_context = 0;
1505 if (!SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context,
1506 sizeof session_id_context) ||
1507 !SSL_CTX_set_session_id_context(s_ctx2, (void *)&session_id_context,
1508 sizeof session_id_context)) {
1509 ERR_print_errors(bio_err);
1514 /* Use PSK only if PSK key is given */
1515 if (psk_key != NULL) {
1517 * no_psk is used to avoid putting psk command to openssl tool
1521 * if PSK is not compiled in and psk key is given, do nothing and
1527 #ifndef OPENSSL_NO_PSK
1528 SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1529 SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1530 SSL_CTX_set_psk_server_callback(s_ctx2, psk_server_callback);
1532 BIO_printf(bio_err, "setting PSK identity hint to s_ctx\n");
1533 if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint") ||
1534 !SSL_CTX_use_psk_identity_hint(s_ctx2, "ctx server identity_hint")) {
1535 BIO_printf(bio_err, "error setting PSK identity hint to s_ctx\n");
1536 ERR_print_errors(bio_err);
1542 #ifndef OPENSSL_NO_NEXTPROTONEG
1544 SSL_CTX_set_next_proto_select_cb(c_ctx, cb_client_npn, NULL);
1547 if (npn_server_reject) {
1549 "Can't have both -npn_server and -npn_server_reject\n");
1552 SSL_CTX_set_npn_advertised_cb(s_ctx, cb_server_npn, NULL);
1553 SSL_CTX_set_npn_advertised_cb(s_ctx2, cb_server_npn, NULL);
1555 if (npn_server_reject) {
1556 SSL_CTX_set_npn_advertised_cb(s_ctx, cb_server_rejects_npn, NULL);
1557 SSL_CTX_set_npn_advertised_cb(s_ctx2, cb_server_rejects_npn, NULL);
1561 if (serverinfo_sct) {
1562 if (!SSL_CTX_add_client_custom_ext(c_ctx,
1563 TLSEXT_TYPE_signed_certificate_timestamp,
1565 serverinfo_cli_parse_cb, NULL)) {
1566 BIO_printf(bio_err, "Error adding SCT extension\n");
1570 if (serverinfo_tack) {
1571 if (!SSL_CTX_add_client_custom_ext(c_ctx, TACK_EXT_TYPE,
1573 serverinfo_cli_parse_cb, NULL)) {
1574 BIO_printf(bio_err, "Error adding TACK extension\n");
1578 if (serverinfo_file)
1579 if (!SSL_CTX_use_serverinfo_file(s_ctx, serverinfo_file) ||
1580 !SSL_CTX_use_serverinfo_file(s_ctx2, serverinfo_file)) {
1581 BIO_printf(bio_err, "missing serverinfo file\n");
1586 if (!SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_0,
1587 custom_ext_0_cli_add_cb,
1589 custom_ext_0_cli_parse_cb, NULL)
1590 || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_1,
1591 custom_ext_1_cli_add_cb,
1593 custom_ext_1_cli_parse_cb, NULL)
1594 || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_2,
1595 custom_ext_2_cli_add_cb,
1597 custom_ext_2_cli_parse_cb, NULL)
1598 || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_3,
1599 custom_ext_3_cli_add_cb,
1601 custom_ext_3_cli_parse_cb, NULL)
1602 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_0,
1603 custom_ext_0_srv_add_cb,
1605 custom_ext_0_srv_parse_cb, NULL)
1606 || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_0,
1607 custom_ext_0_srv_add_cb,
1609 custom_ext_0_srv_parse_cb, NULL)
1610 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_1,
1611 custom_ext_1_srv_add_cb,
1613 custom_ext_1_srv_parse_cb, NULL)
1614 || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_1,
1615 custom_ext_1_srv_add_cb,
1617 custom_ext_1_srv_parse_cb, NULL)
1618 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_2,
1619 custom_ext_2_srv_add_cb,
1621 custom_ext_2_srv_parse_cb, NULL)
1622 || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_2,
1623 custom_ext_2_srv_add_cb,
1625 custom_ext_2_srv_parse_cb, NULL)
1626 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_3,
1627 custom_ext_3_srv_add_cb,
1629 custom_ext_3_srv_parse_cb, NULL)
1630 || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_3,
1631 custom_ext_3_srv_add_cb,
1633 custom_ext_3_srv_parse_cb, NULL)) {
1634 BIO_printf(bio_err, "Error setting custom extensions\n");
1640 SSL_CTX_set_alpn_select_cb(s_ctx, cb_server_alpn, alpn_server);
1642 SSL_CTX_set_alpn_select_cb(s_ctx2, cb_server_alpn, alpn_server2);
1646 unsigned char *alpn = next_protos_parse(&alpn_len, alpn_client);
1649 BIO_printf(bio_err, "Error parsing -alpn_client argument\n");
1652 /* Returns 0 on success!! */
1653 if (SSL_CTX_set_alpn_protos(c_ctx, alpn, alpn_len)) {
1654 BIO_printf(bio_err, "Error setting ALPN\n");
1661 if (server_sess_in != NULL) {
1662 server_sess = read_session(server_sess_in);
1663 if (server_sess == NULL)
1666 if (client_sess_in != NULL) {
1667 client_sess = read_session(client_sess_in);
1668 if (client_sess == NULL)
1672 if (server_sess_out != NULL || server_sess_in != NULL) {
1676 /* Use a fixed key so that we can decrypt the ticket. */
1677 size = SSL_CTX_set_tlsext_ticket_keys(s_ctx, NULL, 0);
1678 keys = OPENSSL_zalloc(size);
1679 SSL_CTX_set_tlsext_ticket_keys(s_ctx, keys, size);
1683 if (sn_server1 != NULL || sn_server2 != NULL)
1684 SSL_CTX_set_tlsext_servername_callback(s_ctx, servername_cb);
1686 c_ssl = SSL_new(c_ctx);
1687 s_ssl = SSL_new(s_ctx);
1690 SSL_set_tlsext_host_name(c_ssl, sn_client);
1692 if (!set_protocol_version(server_min_proto, s_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1694 if (!set_protocol_version(server_max_proto, s_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1696 if (!set_protocol_version(client_min_proto, c_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1698 if (!set_protocol_version(client_max_proto, c_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1702 if (SSL_CTX_add_session(s_ctx, server_sess) == 0) {
1703 BIO_printf(bio_err, "Can't add server session\n");
1704 ERR_print_errors(bio_err);
1709 BIO_printf(bio_stdout, "Doing handshakes=%d bytes=%ld\n", number, bytes);
1710 for (i = 0; i < number; i++) {
1712 if (!SSL_set_session(c_ssl, NULL)) {
1713 BIO_printf(bio_err, "Failed to set session\n");
1717 if (client_sess_in != NULL) {
1718 if (SSL_set_session(c_ssl, client_sess) == 0) {
1719 BIO_printf(bio_err, "Can't set client session\n");
1720 ERR_print_errors(bio_err);
1726 ret = doit(s_ssl, c_ssl, bytes);
1729 ret = doit_biopair(s_ssl, c_ssl, bytes, &s_time, &c_time);
1731 #ifndef OPENSSL_NO_SOCK
1733 ret = doit_localhost(s_ssl, c_ssl, BIO_FAMILY_IPV4,
1734 bytes, &s_time, &c_time);
1737 ret = doit_localhost(s_ssl, c_ssl, BIO_FAMILY_IPV6,
1738 bytes, &s_time, &c_time);
1750 if (should_negotiate && ret == 0 &&
1751 strcmp(should_negotiate, "fail-server") != 0 &&
1752 strcmp(should_negotiate, "fail-client") != 0) {
1753 int version = protocol_from_string(should_negotiate);
1755 BIO_printf(bio_err, "Error parsing: %s\n", should_negotiate);
1759 if (SSL_version(c_ssl) != version) {
1760 BIO_printf(bio_err, "Unexpected version negotiated. "
1761 "Expected: %s, got %s\n", should_negotiate, SSL_get_version(c_ssl));
1767 if (should_reuse != -1) {
1768 if (SSL_session_reused(s_ssl) != should_reuse ||
1769 SSL_session_reused(c_ssl) != should_reuse) {
1770 BIO_printf(bio_err, "Unexpected session reuse state. "
1771 "Expected: %d, server: %d, client: %d\n", should_reuse,
1772 SSL_session_reused(s_ssl), SSL_session_reused(c_ssl));
1778 if (server_sess_out != NULL) {
1779 if (write_session(server_sess_out, SSL_get_session(s_ssl)) == 0) {
1784 if (client_sess_out != NULL) {
1785 if (write_session(client_sess_out, SSL_get_session(c_ssl)) == 0) {
1792 print_details(c_ssl, "");
1795 #ifdef CLOCKS_PER_SEC
1797 * "To determine the time in seconds, the value returned by the clock
1798 * function should be divided by the value of the macro
1799 * CLOCKS_PER_SEC." -- ISO/IEC 9899
1801 BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1802 "Approximate total client time: %6.2f s\n",
1803 (double)s_time / CLOCKS_PER_SEC,
1804 (double)c_time / CLOCKS_PER_SEC);
1806 BIO_printf(bio_stdout,
1807 "Approximate total server time: %6.2f units\n"
1808 "Approximate total client time: %6.2f units\n",
1809 (double)s_time, (double)c_time);
1818 SSL_CTX_free(s_ctx);
1819 SSL_CTX_free(s_ctx2);
1820 SSL_CTX_free(c_ctx);
1821 SSL_CONF_CTX_free(s_cctx);
1822 SSL_CONF_CTX_free(s_cctx2);
1823 SSL_CONF_CTX_free(c_cctx);
1824 sk_OPENSSL_STRING_free(conf_args);
1826 BIO_free(bio_stdout);
1828 SSL_SESSION_free(server_sess);
1829 SSL_SESSION_free(client_sess);
1831 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
1832 if (CRYPTO_mem_leaks(bio_err) <= 0)
1839 #ifndef OPENSSL_NO_SOCK
1840 int doit_localhost(SSL *s_ssl, SSL *c_ssl, int family, long count,
1841 clock_t *s_time, clock_t *c_time)
1843 long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1844 BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1845 BIO *acpt = NULL, *server = NULL, *client = NULL;
1848 int err_in_client = 0;
1849 int err_in_server = 0;
1851 acpt = BIO_new_accept("0");
1854 BIO_set_accept_ip_family(acpt, family);
1855 BIO_set_bind_mode(acpt, BIO_SOCK_NONBLOCK | BIO_SOCK_REUSEADDR);
1856 if (BIO_do_accept(acpt) <= 0)
1859 BIO_snprintf(addr_str, sizeof(addr_str), ":%s", BIO_get_accept_port(acpt));
1861 client = BIO_new_connect(addr_str);
1862 BIO_set_conn_ip_family(client, family);
1866 if (BIO_set_nbio(client, 1) <= 0)
1868 if (BIO_set_nbio(acpt, 1) <= 0)
1872 int st_connect = 0, st_accept = 0;
1874 while(!st_connect || !st_accept) {
1876 if (BIO_do_connect(client) <= 0) {
1877 if (!BIO_should_retry(client))
1884 if (BIO_do_accept(acpt) <= 0) {
1885 if (!BIO_should_retry(acpt))
1893 /* We're not interested in accepting further connects */
1894 server = BIO_pop(acpt);
1898 s_ssl_bio = BIO_new(BIO_f_ssl());
1902 c_ssl_bio = BIO_new(BIO_f_ssl());
1906 SSL_set_connect_state(c_ssl);
1907 SSL_set_bio(c_ssl, client, client);
1908 (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1910 SSL_set_accept_state(s_ssl);
1911 SSL_set_bio(s_ssl, server, server);
1912 (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1916 * c_ssl_bio: SSL filter BIO
1918 * client: I/O for SSL library
1921 * server: I/O for SSL library
1923 * s_ssl_bio: SSL filter BIO
1927 * We have non-blocking behaviour throughout this test program, but
1928 * can be sure that there is *some* progress in each iteration; so we
1929 * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
1930 * we just try everything in each iteration
1936 char cbuf[1024 * 8];
1938 clock_t c_clock = clock();
1940 memset(cbuf, 0, sizeof(cbuf));
1943 if (SSL_in_init(c_ssl))
1944 printf("client waiting in SSL_connect - %s\n",
1945 SSL_state_string_long(c_ssl));
1948 /* Write to server. */
1950 if (cw_num > (long)sizeof cbuf)
1954 r = BIO_write(c_ssl_bio, cbuf, i);
1956 if (!BIO_should_retry(c_ssl_bio)) {
1957 fprintf(stderr, "ERROR in CLIENT\n");
1962 * BIO_should_retry(...) can just be ignored here. The
1963 * library expects us to call BIO_write with the same
1964 * arguments again, and that's what we will do in the
1967 } else if (r == 0) {
1968 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1972 printf("client wrote %d\n", r);
1978 /* Read from server. */
1980 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1982 if (!BIO_should_retry(c_ssl_bio)) {
1983 fprintf(stderr, "ERROR in CLIENT\n");
1988 * Again, "BIO_should_retry" can be ignored.
1990 } else if (r == 0) {
1991 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1995 printf("client read %d\n", r);
2001 * c_time and s_time increments will typically be very small
2002 * (depending on machine speed and clock tick intervals), but
2003 * sampling over a large number of connections should result in
2004 * fairly accurate figures. We cannot guarantee a lot, however
2005 * -- if each connection lasts for exactly one clock tick, it
2006 * will be counted only for the client or only for the server or
2009 *c_time += (clock() - c_clock);
2015 char sbuf[1024 * 8];
2017 clock_t s_clock = clock();
2019 memset(sbuf, 0, sizeof(sbuf));
2022 if (SSL_in_init(s_ssl))
2023 printf("server waiting in SSL_accept - %s\n",
2024 SSL_state_string_long(s_ssl));
2027 /* Write to client. */
2029 if (sw_num > (long)sizeof sbuf)
2033 r = BIO_write(s_ssl_bio, sbuf, i);
2035 if (!BIO_should_retry(s_ssl_bio)) {
2036 fprintf(stderr, "ERROR in SERVER\n");
2040 /* Ignore "BIO_should_retry". */
2041 } else if (r == 0) {
2042 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2046 printf("server wrote %d\n", r);
2052 /* Read from client. */
2054 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2056 if (!BIO_should_retry(s_ssl_bio)) {
2057 fprintf(stderr, "ERROR in SERVER\n");
2062 } else if (r == 0) {
2063 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2067 printf("server read %d\n", r);
2072 *s_time += (clock() - s_clock);
2075 while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2078 print_details(c_ssl, "DONE via TCP connect: ");
2079 # ifndef OPENSSL_NO_NEXTPROTONEG
2080 if (verify_npn(c_ssl, s_ssl) < 0) {
2085 if (verify_serverinfo() < 0) {
2086 fprintf(stderr, "Server info verify error\n");
2090 if (verify_alpn(c_ssl, s_ssl) < 0) {
2094 if (verify_servername(c_ssl, s_ssl) < 0) {
2099 if (custom_ext_error) {
2100 fprintf(stderr, "Custom extension error\n");
2105 # ifndef OPENSSL_NO_NEXTPROTONEG
2111 ERR_print_errors(bio_err);
2116 BIO_free(s_ssl_bio);
2117 BIO_free(c_ssl_bio);
2119 if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2120 ret = (err_in_client != 0) ? 0 : 1;
2121 else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2122 ret = (err_in_server != 0) ? 0 : 1;
2128 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
2129 clock_t *s_time, clock_t *c_time)
2131 long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
2132 BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
2133 BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
2135 int err_in_client = 0;
2136 int err_in_server = 0;
2138 size_t bufsiz = 256; /* small buffer for testing */
2140 if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
2142 if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
2145 s_ssl_bio = BIO_new(BIO_f_ssl());
2149 c_ssl_bio = BIO_new(BIO_f_ssl());
2153 SSL_set_connect_state(c_ssl);
2154 SSL_set_bio(c_ssl, client, client);
2155 (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
2157 SSL_set_accept_state(s_ssl);
2158 SSL_set_bio(s_ssl, server, server);
2159 (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
2163 * c_ssl_bio: SSL filter BIO
2165 * client: pseudo-I/O for SSL library
2167 * client_io: client's SSL communication; usually to be
2168 * relayed over some I/O facility, but in this
2169 * test program, we're the server, too:
2171 * server_io: server's SSL communication
2173 * server: pseudo-I/O for SSL library
2175 * s_ssl_bio: SSL filter BIO
2177 * The client and the server each employ a "BIO pair":
2178 * client + client_io, server + server_io.
2179 * BIO pairs are symmetric. A BIO pair behaves similar
2180 * to a non-blocking socketpair (but both endpoints must
2181 * be handled by the same thread).
2182 * [Here we could connect client and server to the ends
2183 * of a single BIO pair, but then this code would be less
2184 * suitable as an example for BIO pairs in general.]
2186 * Useful functions for querying the state of BIO pair endpoints:
2188 * BIO_ctrl_pending(bio) number of bytes we can read now
2189 * BIO_ctrl_get_read_request(bio) number of bytes needed to fulfil
2190 * other side's read attempt
2191 * BIO_ctrl_get_write_guarantee(bio) number of bytes we can write now
2193 * ..._read_request is never more than ..._write_guarantee;
2194 * it depends on the application which one you should use.
2198 * We have non-blocking behaviour throughout this test program, but
2199 * can be sure that there is *some* progress in each iteration; so we
2200 * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
2201 * we just try everything in each iteration
2207 char cbuf[1024 * 8];
2209 clock_t c_clock = clock();
2211 memset(cbuf, 0, sizeof(cbuf));
2214 if (SSL_in_init(c_ssl))
2215 printf("client waiting in SSL_connect - %s\n",
2216 SSL_state_string_long(c_ssl));
2219 /* Write to server. */
2221 if (cw_num > (long)sizeof cbuf)
2225 r = BIO_write(c_ssl_bio, cbuf, i);
2227 if (!BIO_should_retry(c_ssl_bio)) {
2228 fprintf(stderr, "ERROR in CLIENT\n");
2233 * BIO_should_retry(...) can just be ignored here. The
2234 * library expects us to call BIO_write with the same
2235 * arguments again, and that's what we will do in the
2238 } else if (r == 0) {
2239 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2243 printf("client wrote %d\n", r);
2249 /* Read from server. */
2251 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
2253 if (!BIO_should_retry(c_ssl_bio)) {
2254 fprintf(stderr, "ERROR in CLIENT\n");
2259 * Again, "BIO_should_retry" can be ignored.
2261 } else if (r == 0) {
2262 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2266 printf("client read %d\n", r);
2272 * c_time and s_time increments will typically be very small
2273 * (depending on machine speed and clock tick intervals), but
2274 * sampling over a large number of connections should result in
2275 * fairly accurate figures. We cannot guarantee a lot, however
2276 * -- if each connection lasts for exactly one clock tick, it
2277 * will be counted only for the client or only for the server or
2280 *c_time += (clock() - c_clock);
2286 char sbuf[1024 * 8];
2288 clock_t s_clock = clock();
2290 memset(sbuf, 0, sizeof(sbuf));
2293 if (SSL_in_init(s_ssl))
2294 printf("server waiting in SSL_accept - %s\n",
2295 SSL_state_string_long(s_ssl));
2298 /* Write to client. */
2300 if (sw_num > (long)sizeof sbuf)
2304 r = BIO_write(s_ssl_bio, sbuf, i);
2306 if (!BIO_should_retry(s_ssl_bio)) {
2307 fprintf(stderr, "ERROR in SERVER\n");
2311 /* Ignore "BIO_should_retry". */
2312 } else if (r == 0) {
2313 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2317 printf("server wrote %d\n", r);
2323 /* Read from client. */
2325 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2327 if (!BIO_should_retry(s_ssl_bio)) {
2328 fprintf(stderr, "ERROR in SERVER\n");
2333 } else if (r == 0) {
2334 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2338 printf("server read %d\n", r);
2343 *s_time += (clock() - s_clock);
2347 /* "I/O" BETWEEN CLIENT AND SERVER. */
2350 BIO *io1 = server_io, *io2 = client_io;
2352 * we use the non-copying interface for io1 and the standard
2353 * BIO_write/BIO_read interface for io2
2356 static int prev_progress = 1;
2364 r1 = BIO_ctrl_pending(io1);
2365 r2 = BIO_ctrl_get_write_guarantee(io2);
2373 if (INT_MAX < num) /* yeah, right */
2376 r = BIO_nread(io1, &dataptr, (int)num);
2378 assert(r <= (int)num);
2380 * possibly r < num (non-contiguous data)
2383 r = BIO_write(io2, dataptr, (int)num);
2384 if (r != (int)num) { /* can't happen */
2385 fprintf(stderr, "ERROR: BIO_write could not write "
2386 "BIO_ctrl_get_write_guarantee() bytes");
2392 printf((io1 == client_io) ?
2393 "C->S relaying: %d bytes\n" :
2394 "S->C relaying: %d bytes\n", (int)num);
2404 r1 = BIO_ctrl_pending(io2);
2405 r2 = BIO_ctrl_get_read_request(io1);
2407 * here we could use ..._get_write_guarantee instead of
2408 * ..._get_read_request, but by using the latter we test
2409 * restartability of the SSL implementation more thoroughly
2421 --num; /* test restartability even more thoroughly */
2423 r = BIO_nwrite0(io1, &dataptr);
2427 r = BIO_read(io2, dataptr, (int)num);
2428 if (r != (int)num) { /* can't happen */
2429 fprintf(stderr, "ERROR: BIO_read could not read "
2430 "BIO_ctrl_pending() bytes");
2434 r = BIO_nwrite(io1, &dataptr, (int)num);
2435 if (r != (int)num) { /* can't happen */
2436 fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
2437 "BIO_nwrite0() bytes");
2442 printf((io2 == client_io) ?
2443 "C->S relaying: %d bytes\n" :
2444 "S->C relaying: %d bytes\n", (int)num);
2446 } /* no loop, BIO_ctrl_get_read_request now
2447 * returns 0 anyway */
2449 if (!progress && !prev_progress)
2450 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0) {
2451 fprintf(stderr, "ERROR: got stuck\n");
2452 fprintf(stderr, " ERROR.\n");
2455 prev_progress = progress;
2458 while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2461 print_details(c_ssl, "DONE via BIO pair: ");
2462 #ifndef OPENSSL_NO_NEXTPROTONEG
2463 if (verify_npn(c_ssl, s_ssl) < 0) {
2468 if (verify_serverinfo() < 0) {
2469 fprintf(stderr, "Server info verify error\n");
2473 if (verify_alpn(c_ssl, s_ssl) < 0) {
2477 if (verify_servername(c_ssl, s_ssl) < 0) {
2482 if (custom_ext_error) {
2483 fprintf(stderr, "Custom extension error\n");
2488 #ifndef OPENSSL_NO_NEXTPROTONEG
2494 ERR_print_errors(bio_err);
2497 BIO_free(server_io);
2499 BIO_free(client_io);
2500 BIO_free(s_ssl_bio);
2501 BIO_free(c_ssl_bio);
2503 if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2504 ret = (err_in_client != 0) ? 0 : 1;
2505 else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2506 ret = (err_in_server != 0) ? 0 : 1;
2516 int doit(SSL *s_ssl, SSL *c_ssl, long count)
2518 char *cbuf = NULL, *sbuf = NULL;
2520 long cw_num = count, cr_num = count;
2521 long sw_num = count, sr_num = count;
2527 int c_r, c_w, s_r, s_w;
2530 int c_write, s_write;
2531 int do_server = 0, do_client = 0;
2532 int max_frag = 5 * 1024;
2533 int err_in_client = 0;
2534 int err_in_server = 0;
2536 bufsiz = count > 40 * 1024 ? 40 * 1024 : count;
2538 if ((cbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2540 if ((sbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2543 c_to_s = BIO_new(BIO_s_mem());
2544 s_to_c = BIO_new(BIO_s_mem());
2545 if ((s_to_c == NULL) || (c_to_s == NULL)) {
2546 ERR_print_errors(bio_err);
2550 c_bio = BIO_new(BIO_f_ssl());
2551 s_bio = BIO_new(BIO_f_ssl());
2552 if ((c_bio == NULL) || (s_bio == NULL)) {
2553 ERR_print_errors(bio_err);
2557 SSL_set_connect_state(c_ssl);
2558 SSL_set_bio(c_ssl, s_to_c, c_to_s);
2559 SSL_set_max_send_fragment(c_ssl, max_frag);
2560 BIO_set_ssl(c_bio, c_ssl, BIO_NOCLOSE);
2563 * We've just given our ref to these BIOs to c_ssl. We need another one to
2566 if (!BIO_up_ref(c_to_s)) {
2567 /* c_to_s and s_to_c will get freed when we free c_ssl */
2572 if (!BIO_up_ref(s_to_c)) {
2573 /* s_to_c will get freed when we free c_ssl */
2578 SSL_set_accept_state(s_ssl);
2579 SSL_set_bio(s_ssl, c_to_s, s_to_c);
2581 /* We've used up all our refs to these now */
2585 SSL_set_max_send_fragment(s_ssl, max_frag);
2586 BIO_set_ssl(s_bio, s_ssl, BIO_NOCLOSE);
2592 c_write = 1, s_write = 0;
2594 /* We can always do writes */
2599 i = (int)BIO_pending(s_bio);
2600 if ((i && s_r) || s_w)
2603 i = (int)BIO_pending(c_bio);
2604 if ((i && c_r) || c_w)
2607 if (do_server && debug) {
2608 if (SSL_in_init(s_ssl))
2609 printf("server waiting in SSL_accept - %s\n",
2610 SSL_state_string_long(s_ssl));
2613 if (do_client && debug) {
2614 if (SSL_in_init(c_ssl))
2615 printf("client waiting in SSL_connect - %s\n",
2616 SSL_state_string_long(c_ssl));
2619 if (!do_client && !do_server) {
2620 fprintf(stdout, "ERROR IN STARTUP\n");
2621 ERR_print_errors(bio_err);
2624 if (do_client && !(done & C_DONE)) {
2626 j = (cw_num > bufsiz) ? (int)bufsiz : (int)cw_num;
2627 i = BIO_write(c_bio, cbuf, j);
2631 if (BIO_should_retry(c_bio)) {
2632 if (BIO_should_read(c_bio))
2634 if (BIO_should_write(c_bio))
2637 fprintf(stderr, "ERROR in CLIENT\n");
2639 ERR_print_errors(bio_err);
2642 } else if (i == 0) {
2643 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2647 printf("client wrote %d\n", i);
2652 if (max_frag > 1029)
2653 SSL_set_max_send_fragment(c_ssl, max_frag -= 5);
2656 i = BIO_read(c_bio, cbuf, bufsiz);
2660 if (BIO_should_retry(c_bio)) {
2661 if (BIO_should_read(c_bio))
2663 if (BIO_should_write(c_bio))
2666 fprintf(stderr, "ERROR in CLIENT\n");
2668 ERR_print_errors(bio_err);
2671 } else if (i == 0) {
2672 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2676 printf("client read %d\n", i);
2685 done = S_DONE | C_DONE;
2691 if (do_server && !(done & S_DONE)) {
2693 i = BIO_read(s_bio, sbuf, bufsiz);
2697 if (BIO_should_retry(s_bio)) {
2698 if (BIO_should_read(s_bio))
2700 if (BIO_should_write(s_bio))
2703 fprintf(stderr, "ERROR in SERVER\n");
2705 ERR_print_errors(bio_err);
2708 } else if (i == 0) {
2709 ERR_print_errors(bio_err);
2711 "SSL SERVER STARTUP FAILED in SSL_read\n");
2715 printf("server read %d\n", i);
2728 j = (sw_num > bufsiz) ? (int)bufsiz : (int)sw_num;
2729 i = BIO_write(s_bio, sbuf, j);
2733 if (BIO_should_retry(s_bio)) {
2734 if (BIO_should_read(s_bio))
2736 if (BIO_should_write(s_bio))
2739 fprintf(stderr, "ERROR in SERVER\n");
2741 ERR_print_errors(bio_err);
2744 } else if (i == 0) {
2745 ERR_print_errors(bio_err);
2747 "SSL SERVER STARTUP FAILED in SSL_write\n");
2751 printf("server wrote %d\n", i);
2757 if (max_frag > 1029)
2758 SSL_set_max_send_fragment(s_ssl, max_frag -= 5);
2763 if ((done & S_DONE) && (done & C_DONE))
2768 print_details(c_ssl, "DONE: ");
2769 #ifndef OPENSSL_NO_NEXTPROTONEG
2770 if (verify_npn(c_ssl, s_ssl) < 0) {
2775 if (verify_serverinfo() < 0) {
2776 fprintf(stderr, "Server info verify error\n");
2780 if (custom_ext_error) {
2781 fprintf(stderr, "Custom extension error\n");
2789 BIO_free_all(c_bio);
2790 BIO_free_all(s_bio);
2794 if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2795 ret = (err_in_client != 0) ? 0 : 1;
2796 else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2797 ret = (err_in_server != 0) ? 0 : 1;
2802 static int verify_callback(int ok, X509_STORE_CTX *ctx)
2806 s = X509_NAME_oneline(X509_get_subject_name(X509_STORE_CTX_get_current_cert(ctx)),
2810 printf("depth=%d %s\n", X509_STORE_CTX_get_error_depth(ctx), buf);
2812 fprintf(stderr, "depth=%d error=%d %s\n",
2813 X509_STORE_CTX_get_error_depth(ctx),
2814 X509_STORE_CTX_get_error(ctx), buf);
2819 int i = X509_STORE_CTX_get_error(ctx);
2823 fprintf(stderr, "Error string: %s\n",
2824 X509_verify_cert_error_string(i));
2826 case X509_V_ERR_CERT_NOT_YET_VALID:
2827 case X509_V_ERR_CERT_HAS_EXPIRED:
2828 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2837 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2840 struct app_verify_arg *cb_arg = arg;
2842 if (cb_arg->app_verify) {
2843 char *s = NULL, buf[256];
2844 X509 *c = X509_STORE_CTX_get0_cert(ctx);
2846 printf("In app_verify_callback, allowing cert. ");
2847 printf("Arg is: %s\n", cb_arg->string);
2848 printf("Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2849 (void *)ctx, (void *)c);
2851 s = X509_NAME_oneline(X509_get_subject_name(c), buf, 256);
2853 printf("cert depth=%d %s\n",
2854 X509_STORE_CTX_get_error_depth(ctx), buf);
2859 ok = X509_verify_cert(ctx);
2864 #ifndef OPENSSL_NO_DH
2866 * These DH parameters have been generated as follows:
2867 * $ openssl dhparam -C -noout 512
2868 * $ openssl dhparam -C -noout 1024
2869 * $ openssl dhparam -C -noout -dsaparam 1024
2870 * (The third function has been renamed to avoid name conflicts.)
2872 static DH *get_dh512()
2874 static unsigned char dh512_p[] = {
2875 0xCB, 0xC8, 0xE1, 0x86, 0xD0, 0x1F, 0x94, 0x17, 0xA6, 0x99, 0xF0,
2877 0x1F, 0x0D, 0xAC, 0xB6, 0x25, 0x3E, 0x06, 0x39, 0xCA, 0x72, 0x04,
2879 0x6E, 0xDA, 0xC0, 0x61, 0xE6, 0x7A, 0x77, 0x25, 0xE8, 0x3B, 0xB9,
2881 0x9A, 0xB6, 0xB5, 0xFE, 0x99, 0x0B, 0xA1, 0x93, 0x4E, 0x35, 0x33,
2883 0xE1, 0xF1, 0x13, 0x4F, 0x59, 0x1A, 0xD2, 0x57, 0xC0, 0x26, 0x21,
2885 0x02, 0xC5, 0xAE, 0x23,
2887 static unsigned char dh512_g[] = {
2893 if ((dh = DH_new()) == NULL)
2895 p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
2896 g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
2897 if ((p == NULL) || (g == NULL) || !DH_set0_pqg(dh, p, NULL, g)) {
2906 static DH *get_dh1024()
2908 static unsigned char dh1024_p[] = {
2909 0xF8, 0x81, 0x89, 0x7D, 0x14, 0x24, 0xC5, 0xD1, 0xE6, 0xF7, 0xBF,
2911 0xE4, 0x90, 0xF4, 0xFC, 0x73, 0xFB, 0x34, 0xB5, 0xFA, 0x4C, 0x56,
2913 0xEA, 0xA7, 0xE9, 0xC0, 0xC0, 0xCE, 0x89, 0xE1, 0xFA, 0x63, 0x3F,
2915 0x6B, 0x32, 0x66, 0xF1, 0xD1, 0x7B, 0xB0, 0x00, 0x8F, 0xCA, 0x87,
2917 0xAE, 0x98, 0x89, 0x26, 0x17, 0xC2, 0x05, 0xD2, 0xEC, 0x08, 0xD0,
2919 0xFF, 0x17, 0x52, 0x8C, 0xC5, 0x07, 0x93, 0x03, 0xB1, 0xF6, 0x2F,
2921 0x1C, 0x52, 0x47, 0x27, 0x1B, 0xDB, 0xD1, 0x8D, 0x9D, 0x69, 0x1D,
2923 0x4B, 0x32, 0x81, 0xAA, 0x7F, 0x00, 0xC8, 0xDC, 0xE6, 0xD9, 0xCC,
2925 0x11, 0x2D, 0x37, 0x34, 0x6C, 0xEA, 0x02, 0x97, 0x4B, 0x0E, 0xBB,
2927 0x71, 0x33, 0x09, 0x15, 0xFD, 0xDD, 0x23, 0x87, 0x07, 0x5E, 0x89,
2929 0x6B, 0x7C, 0x5F, 0xEC, 0xA6, 0x24, 0xDC, 0x53,
2931 static unsigned char dh1024_g[] = {
2937 if ((dh = DH_new()) == NULL)
2939 p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
2940 g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
2941 if ((p == NULL) || (g == NULL) || !DH_set0_pqg(dh, p, NULL, g)) {
2950 static DH *get_dh1024dsa()
2952 static unsigned char dh1024_p[] = {
2953 0xC8, 0x00, 0xF7, 0x08, 0x07, 0x89, 0x4D, 0x90, 0x53, 0xF3, 0xD5,
2955 0x21, 0x1B, 0xF7, 0x31, 0xA6, 0xA2, 0xDA, 0x23, 0x9A, 0xC7, 0x87,
2957 0x3B, 0x47, 0xB6, 0x8C, 0x04, 0x6F, 0xFF, 0xC6, 0x9B, 0xB8, 0x65,
2959 0xC2, 0x5F, 0x31, 0x83, 0x4A, 0xA7, 0x5F, 0x2F, 0x88, 0x38, 0xB6,
2961 0xCF, 0xD9, 0x87, 0x6D, 0x6F, 0x9F, 0xDA, 0xAC, 0xA6, 0x48, 0xAF,
2963 0x33, 0x84, 0x37, 0x5B, 0x82, 0x4A, 0x31, 0x5D, 0xE7, 0xBD, 0x52,
2965 0xA1, 0x77, 0xBF, 0x10, 0x9E, 0x37, 0xEA, 0x64, 0xFA, 0xCA, 0x28,
2967 0x9D, 0x3B, 0xD2, 0x6E, 0x09, 0x5C, 0x68, 0xC7, 0x45, 0x90, 0xFD,
2969 0x70, 0xC9, 0x3A, 0xBB, 0xDF, 0xD4, 0x21, 0x0F, 0xC4, 0x6A, 0x3C,
2971 0x61, 0xCF, 0x3F, 0xD6, 0x13, 0xF1, 0x5F, 0xBC, 0xCF, 0xBC, 0x26,
2973 0xBC, 0x0B, 0xBD, 0xAB, 0x5D, 0xC9, 0x54, 0x39,
2975 static unsigned char dh1024_g[] = {
2976 0x3B, 0x40, 0x86, 0xE7, 0xF3, 0x6C, 0xDE, 0x67, 0x1C, 0xCC, 0x80,
2978 0x5A, 0xDF, 0xFE, 0xBD, 0x20, 0x27, 0x74, 0x6C, 0x24, 0xC9, 0x03,
2980 0xE1, 0x8D, 0xC3, 0x7D, 0x98, 0x27, 0x40, 0x08, 0xB8, 0x8C, 0x6A,
2982 0xBB, 0x1A, 0x3A, 0xD6, 0x86, 0x83, 0x5E, 0x72, 0x41, 0xCE, 0x85,
2984 0xD2, 0xB3, 0xFC, 0x13, 0xCE, 0x37, 0x81, 0x9E, 0x4C, 0x1C, 0x7B,
2986 0xD3, 0xE6, 0xA6, 0x00, 0xF5, 0x5A, 0x95, 0x43, 0x5E, 0x81, 0xCF,
2988 0xA2, 0x23, 0xFC, 0x36, 0xA7, 0x5D, 0x7A, 0x4C, 0x06, 0x91, 0x6E,
2990 0x57, 0xEE, 0x36, 0xCB, 0x06, 0xEA, 0xF5, 0x3D, 0x95, 0x49, 0xCB,
2992 0xDD, 0x81, 0xDF, 0x80, 0x09, 0x4A, 0x97, 0x4D, 0xA8, 0x22, 0x72,
2994 0x7F, 0xC4, 0x70, 0x56, 0x70, 0xE8, 0x20, 0x10, 0x18, 0x8F, 0x2E,
2996 0x07, 0xE7, 0x68, 0x1A, 0x82, 0x5D, 0x32, 0xA2,
3001 if ((dh = DH_new()) == NULL)
3003 p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
3004 g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
3005 if ((p == NULL) || (g == NULL) || !DH_set0_pqg(dh, p, NULL, g)) {
3011 DH_set_length(dh, 160);
3016 #ifndef OPENSSL_NO_PSK
3017 /* convert the PSK key (psk_key) in ascii to binary (psk) */
3018 static int psk_key2bn(const char *pskkey, unsigned char *psk,
3019 unsigned int max_psk_len)
3024 ret = BN_hex2bn(&bn, pskkey);
3026 BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
3031 if (BN_num_bytes(bn) > (int)max_psk_len) {
3033 "psk buffer of callback is too small (%d) for key (%d)\n",
3034 max_psk_len, BN_num_bytes(bn));
3038 ret = BN_bn2bin(bn, psk);
3043 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
3045 unsigned int max_identity_len,
3047 unsigned int max_psk_len)
3050 unsigned int psk_len = 0;
3052 ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3056 fprintf(stderr, "client: created identity '%s' len=%d\n", identity,
3058 ret = psk_key2bn(psk_key, psk, max_psk_len);
3066 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3068 unsigned int max_psk_len)
3070 unsigned int psk_len = 0;
3072 if (strcmp(identity, "Client_identity") != 0) {
3073 BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3076 psk_len = psk_key2bn(psk_key, psk, max_psk_len);