]> git.ipfire.org Git - thirdparty/openssl.git/blob - test/ssltest_old.c
projects / thirdparty / openssl.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
More typo fixes
[thirdparty/openssl.git] / test / ssltest_old.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 /* ====================================================================
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.
14 */
15 /* ====================================================================
16 * Copyright 2005 Nokia. All rights reserved.
17 *
18 * The portions of the attached software ("Contribution") is developed by
19 * Nokia Corporation and is licensed pursuant to the OpenSSL open source
20 * license.
21 *
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.
25 *
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.
29 *
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.
34 *
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
39 * OTHERWISE.
40 */
41
42 /* Or gethostname won't be declared properly on Linux and GNU platforms. */
43 #ifndef _BSD_SOURCE
44 # define _BSD_SOURCE 1
45 #endif
46 #ifndef _DEFAULT_SOURCE
47 # define _DEFAULT_SOURCE 1
48 #endif
49
50 #include <assert.h>
51 #include <errno.h>
52 #include <limits.h>
53 #include <stdio.h>
54 #include <stdlib.h>
55 #include <string.h>
56 #include <time.h>
57
58 #define USE_SOCKETS
59 #include "e_os.h"
60
61 #ifdef OPENSSL_SYS_VMS
62 /*
63 * Or isascii won't be declared properly on VMS (at least with DECompHP C).
64 */
65 # define _XOPEN_SOURCE 500
66 #endif
67
68 #include <ctype.h>
69
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>
80 #endif
81 #ifndef OPENSSL_NO_DSA
82 # include <openssl/dsa.h>
83 #endif
84 #ifndef OPENSSL_NO_DH
85 # include <openssl/dh.h>
86 #endif
87 #include <openssl/bn.h>
88 #ifndef OPENSSL_NO_CT
89 # include <openssl/ct.h>
90 #endif
91
92 /*
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
96 * get screwed...
97 */
98 #define _XOPEN_SOURCE_EXTENDED 1
99
100 #ifdef OPENSSL_SYS_WINDOWS
101 # include <winsock.h>
102 #else
103 # include OPENSSL_UNISTD
104 #endif
105
106 static SSL_CTX *s_ctx = NULL;
107 static SSL_CTX *s_ctx2 = NULL;
108
109 /*
110 * There is really no standard for this, so let's assign something
111 * only for this test
112 */
113 #define COMP_ZLIB 1
114
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 {
119 char *string;
120 int app_verify;
121 };
122
123 #ifndef OPENSSL_NO_DH
124 static DH *get_dh512(void);
125 static DH *get_dh1024(void);
126 static DH *get_dh1024dsa(void);
127 #endif
128
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,
132 char *identity,
133 unsigned int max_identity_len,
134 unsigned char *psk,
135 unsigned int max_psk_len);
136 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
137 unsigned char *psk,
138 unsigned int max_psk_len);
139 #endif
140
141 static BIO *bio_err = NULL;
142 static BIO *bio_stdout = NULL;
143
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;
150
151 static int cb_client_npn(SSL *s, unsigned char **out, unsigned char *outlen,
152 const unsigned char *in, unsigned int inlen,
153 void *arg)
154 {
155 /*
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.
159 */
160 *out = (unsigned char *)NEXT_PROTO_STRING + 1;
161 *outlen = sizeof(NEXT_PROTO_STRING) - 2;
162 return SSL_TLSEXT_ERR_OK;
163 }
164
165 static int cb_server_npn(SSL *s, const unsigned char **data,
166 unsigned int *len, void *arg)
167 {
168 *data = (const unsigned char *)NEXT_PROTO_STRING;
169 *len = sizeof(NEXT_PROTO_STRING) - 1;
170 return SSL_TLSEXT_ERR_OK;
171 }
172
173 static int cb_server_rejects_npn(SSL *s, const unsigned char **data,
174 unsigned int *len, void *arg)
175 {
176 return SSL_TLSEXT_ERR_NOACK;
177 }
178
179 static int verify_npn(SSL *client, SSL *server)
180 {
181 const unsigned char *client_s;
182 unsigned client_len;
183 const unsigned char *server_s;
184 unsigned server_len;
185
186 SSL_get0_next_proto_negotiated(client, &client_s, &client_len);
187 SSL_get0_next_proto_negotiated(server, &server_s, &server_len);
188
189 if (client_len) {
190 BIO_printf(bio_stdout, "Client NPN: ");
191 BIO_write(bio_stdout, client_s, client_len);
192 BIO_printf(bio_stdout, "\n");
193 }
194
195 if (server_len) {
196 BIO_printf(bio_stdout, "Server NPN: ");
197 BIO_write(bio_stdout, server_s, server_len);
198 BIO_printf(bio_stdout, "\n");
199 }
200
201 /*
202 * If an NPN string was returned, it must be the protocol that we
203 * expected to negotiate.
204 */
205 if (client_len && (client_len != sizeof(NEXT_PROTO_STRING) - 2 ||
206 memcmp(client_s, NEXT_PROTO_STRING + 1, client_len)))
207 return -1;
208 if (server_len && (server_len != sizeof(NEXT_PROTO_STRING) - 2 ||
209 memcmp(server_s, NEXT_PROTO_STRING + 1, server_len)))
210 return -1;
211
212 if (!npn_client && client_len)
213 return -1;
214 if (!npn_server && server_len)
215 return -1;
216 if (npn_server_reject && server_len)
217 return -1;
218 if (npn_client && npn_server && (!client_len || !server_len))
219 return -1;
220
221 return 0;
222 }
223 #endif
224
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;
245
246 static int servername_cb(SSL *s, int *ad, void *arg)
247 {
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;
252 }
253
254 if (servername) {
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);
259 }
260 }
261 return SSL_TLSEXT_ERR_OK;
262 }
263 static int verify_servername(SSL *client, SSL *server)
264 {
265 /* just need to see if sn_context is what we expect */
266 SSL_CTX* ctx = SSL_get_SSL_CTX(server);
267 if (sn_expect == 0)
268 return 0;
269 if (sn_expect == 1 && ctx == s_ctx)
270 return 0;
271 if (sn_expect == 2 && ctx == s_ctx2)
272 return 0;
273 BIO_printf(bio_stdout, "Servername: expected context %d\n", sn_expect);
274 if (ctx == s_ctx2)
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");
278 else
279 BIO_printf(bio_stdout, "Servername: context is unknown\n");
280 return -1;
281 }
282
283
284 /*-
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"
289 *
290 * returns: a malloced buffer or NULL on failure.
291 */
292 static unsigned char *next_protos_parse(size_t *outlen,
293 const char *in)
294 {
295 size_t len;
296 unsigned char *out;
297 size_t i, start = 0;
298
299 len = strlen(in);
300 if (len >= 65535)
301 return NULL;
302
303 out = OPENSSL_malloc(strlen(in) + 1);
304 if (!out)
305 return NULL;
306
307 for (i = 0; i <= len; ++i) {
308 if (i == len || in[i] == ',') {
309 if (i - start > 255) {
310 OPENSSL_free(out);
311 return NULL;
312 }
313 out[start] = i - start;
314 start = i + 1;
315 } else
316 out[i + 1] = in[i];
317 }
318
319 *outlen = len + 1;
320 return out;
321 }
322
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)
326 {
327 unsigned char *protos;
328 size_t protos_len;
329 char* alpn_str = arg;
330
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",
334 alpn_str);
335 abort();
336 }
337
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;
343 }
344
345 /*
346 * Make a copy of the selected protocol which will be freed in
347 * verify_alpn.
348 */
349 alpn_selected = OPENSSL_malloc(*outlen);
350 memcpy(alpn_selected, *out, *outlen);
351 *out = alpn_selected;
352
353 OPENSSL_free(protos);
354 return SSL_TLSEXT_ERR_OK;
355 }
356
357 static int verify_alpn(SSL *client, SSL *server)
358 {
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);
363
364 OPENSSL_free(alpn_selected);
365 alpn_selected = NULL;
366
367 if (client_proto_len != server_proto_len) {
368 BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");
369 goto err;
370 }
371
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");
375 goto err;
376 }
377
378 if (client_proto_len > 0 && alpn_expected == NULL) {
379 BIO_printf(bio_stdout, "ALPN unexpectedly negotiated\n");
380 goto err;
381 }
382
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",
388 alpn_expected);
389 goto err;
390 }
391
392 return 0;
393
394 err:
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: '",
401 alpn_client);
402 if (SSL_get_SSL_CTX(server) == s_ctx2) {
403 BIO_printf(bio_stdout, "%s'\n",
404 alpn_server2);
405 } else {
406 BIO_printf(bio_stdout, "%s'\n",
407 alpn_server);
408 }
409 return -1;
410 }
411
412 /*
413 * WARNING : below extension types are *NOT* IETF assigned, and could
414 * conflict if these types are reassigned and handled specially by OpenSSL
415 * in the future
416 */
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
422
423 static const char custom_ext_cli_string[] = "abc";
424 static const char custom_ext_srv_string[] = "defg";
425
426 /* These set from cmdline */
427 static char *serverinfo_file = NULL;
428 static int serverinfo_sct = 0;
429 static int serverinfo_tack = 0;
430
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;
435
436 /* This set from cmdline */
437 static int custom_ext = 0;
438
439 /* This set based on extension callbacks */
440 static int custom_ext_error = 0;
441
442 static int serverinfo_cli_parse_cb(SSL *s, unsigned int ext_type,
443 const unsigned char *in, size_t inlen,
444 int *al, void *arg)
445 {
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++;
450 else
451 serverinfo_other_seen++;
452 return 1;
453 }
454
455 static int verify_serverinfo()
456 {
457 if (serverinfo_sct != serverinfo_sct_seen)
458 return -1;
459 if (serverinfo_tack != serverinfo_tack_seen)
460 return -1;
461 if (serverinfo_other_seen)
462 return -1;
463 return 0;
464 }
465
466 /*-
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
472 */
473
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)
477 {
478 if (ext_type != CUSTOM_EXT_TYPE_0)
479 custom_ext_error = 1;
480 return 0; /* Don't send an extension */
481 }
482
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)
486 {
487 return 1;
488 }
489
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)
493 {
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" */
499 }
500
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)
504 {
505 return 1;
506 }
507
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)
511 {
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" */
517 }
518
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)
522 {
523 if (ext_type != CUSTOM_EXT_TYPE_2)
524 custom_ext_error = 1;
525 if (inlen != 0)
526 custom_ext_error = 1; /* Should be empty response */
527 return 1;
528 }
529
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)
533 {
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" */
539 }
540
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)
544 {
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" */
551 return 1;
552 }
553
554 /*
555 * custom_ext_0_cli_add_cb returns 0 - the server won't receive a callback
556 * for this extension
557 */
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)
561 {
562 custom_ext_error = 1;
563 return 1;
564 }
565
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)
570 {
571 /* Error: should not have been called */
572 custom_ext_error = 1;
573 return 0; /* Don't send an extension */
574 }
575
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)
579 {
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;
587 return 1;
588 }
589
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)
593 {
594 return 0; /* Don't send an extension */
595 }
596
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)
600 {
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;
608 return 1;
609 }
610
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)
614 {
615 *out = NULL;
616 *outlen = 0;
617 return 1; /* Send empty extension */
618 }
619
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)
623 {
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;
631 return 1;
632 }
633
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)
637 {
638 *out = (const unsigned char *)custom_ext_srv_string;
639 *outlen = strlen(custom_ext_srv_string);
640 return 1; /* Send "defg" */
641 }
642
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";
648
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,
652 clock_t *c_time);
653 int doit(SSL *s_ssl, SSL *c_ssl, long bytes);
654
655 static void sv_usage(void)
656 {
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");
665 fprintf(stderr,
666 " -bytes <val> - number of bytes to swap between client/server\n");
667 #ifndef OPENSSL_NO_DH
668 fprintf(stderr,
669 " -dhe512 - use 512 bit key for DHE (to test failure)\n");
670 fprintf(stderr,
671 " -dhe1024 - use 1024 bit key (safe prime) for DHE (default, no-op)\n");
672 fprintf(stderr,
673 " -dhe1024dsa - use 1024 bit key (with 160-bit subprime) for DHE\n");
674 fprintf(stderr, " -no_dhe - disable DHE\n");
675 #endif
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");
678 #endif
679 #ifndef OPENSSL_NO_PSK
680 fprintf(stderr, " -psk arg - PSK in hex (without 0x)\n");
681 #endif
682 #ifndef OPENSSL_NO_SSL3
683 fprintf(stderr, " -ssl3 - use SSLv3\n");
684 #endif
685 #ifndef OPENSSL_NO_TLS1
686 fprintf(stderr, " -tls1 - use TLSv1\n");
687 #endif
688 #ifndef OPENSSL_NO_DTLS
689 fprintf(stderr, " -dtls - use DTLS\n");
690 #ifndef OPENSSL_NO_DTLS1
691 fprintf(stderr, " -dtls1 - use DTLSv1\n");
692 #endif
693 #ifndef OPENSSL_NO_DTLS1_2
694 fprintf(stderr, " -dtls12 - use DTLSv1.2\n");
695 #endif
696 #endif
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");
700 fprintf(stderr,
701 " -key arg - Server key file (default: same as -cert)\n");
702 fprintf(stderr, " -c_cert arg - Client certificate file\n");
703 fprintf(stderr,
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");
710 fprintf(stderr,
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");
717 #endif
718 fprintf(stderr, " -serverinfo_file file - have server use this file\n");
719 fprintf(stderr, " -serverinfo_sct - have client offer and expect SCT\n");
720 fprintf(stderr,
721 " -serverinfo_tack - have client offer and expect TACK\n");
722 fprintf(stderr,
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");
728 fprintf(stderr,
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");
739 #endif
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");
751 }
752
753 static void print_key_details(BIO *out, EVP_PKEY *key)
754 {
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);
759 int nid;
760 const char *cname;
761 nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
762 EC_KEY_free(ec);
763 cname = EC_curve_nid2nist(nid);
764 if (!cname)
765 cname = OBJ_nid2sn(nid);
766 BIO_printf(out, "%d bits EC (%s)", EVP_PKEY_bits(key), cname);
767 } else
768 #endif
769 {
770 const char *algname;
771 switch (keyid) {
772 case EVP_PKEY_RSA:
773 algname = "RSA";
774 break;
775 case EVP_PKEY_DSA:
776 algname = "DSA";
777 break;
778 case EVP_PKEY_DH:
779 algname = "DH";
780 break;
781 default:
782 algname = OBJ_nid2sn(keyid);
783 break;
784 }
785 BIO_printf(out, "%d bits %s", EVP_PKEY_bits(key), algname);
786 }
787 }
788
789 static void print_details(SSL *c_ssl, const char *prefix)
790 {
791 const SSL_CIPHER *ciph;
792 int mdnid;
793 X509 *cert;
794 EVP_PKEY *pkey;
795
796 ciph = SSL_get_current_cipher(c_ssl);
797 BIO_printf(bio_stdout, "%s%s, cipher %s %s",
798 prefix,
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);
802 if (cert != NULL) {
803 EVP_PKEY* pubkey = X509_get0_pubkey(cert);
804
805 if (pubkey != NULL) {
806 BIO_puts(bio_stdout, ", ");
807 print_key_details(bio_stdout, pubkey);
808 }
809 X509_free(cert);
810 }
811 if (SSL_get_server_tmp_key(c_ssl, &pkey)) {
812 BIO_puts(bio_stdout, ", temp key: ");
813 print_key_details(bio_stdout, pkey);
814 EVP_PKEY_free(pkey);
815 }
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");
819 }
820
821 /*
822 * protocol_from_string - converts a protocol version string to a number
823 *
824 * Returns -1 on failure or the version on success
825 */
826 static int protocol_from_string(const char *value)
827 {
828 struct protocol_versions {
829 const char *name;
830 int version;
831 };
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}};
840 size_t i;
841 size_t n = OSSL_NELEM(versions);
842
843 for (i = 0; i < n; i++)
844 if (strcmp(versions[i].name, value) == 0)
845 return versions[i].version;
846 return -1;
847 }
848
849 static SSL_SESSION *read_session(const char *filename)
850 {
851 SSL_SESSION *sess;
852 BIO *f = BIO_new_file(filename, "r");
853
854 if (f == NULL) {
855 BIO_printf(bio_err, "Can't open session file %s\n", filename);
856 ERR_print_errors(bio_err);
857 return NULL;
858 }
859 sess = PEM_read_bio_SSL_SESSION(f, NULL, 0, NULL);
860 if (sess == NULL) {
861 BIO_printf(bio_err, "Can't parse session file %s\n", filename);
862 ERR_print_errors(bio_err);
863 }
864 BIO_free(f);
865 return sess;
866 }
867
868 static int write_session(const char *filename, SSL_SESSION *sess)
869 {
870 BIO *f = BIO_new_file(filename, "w");
871
872 if (sess == NULL) {
873 BIO_printf(bio_err, "No session information\n");
874 return 0;
875 }
876 if (f == NULL) {
877 BIO_printf(bio_err, "Can't open session file %s\n", filename);
878 ERR_print_errors(bio_err);
879 return 0;
880 }
881 PEM_write_bio_SSL_SESSION(f, sess);
882 BIO_free(f);
883 return 1;
884 }
885
886 /*
887 * set_protocol_version - Sets protocol version minimum or maximum
888 *
889 * Returns 0 on failure and 1 on success
890 */
891 static int set_protocol_version(const char *version, SSL *ssl, int setting)
892 {
893 if (version != NULL) {
894 int ver = protocol_from_string(version);
895 if (ver < 0) {
896 BIO_printf(bio_err, "Error parsing: %s\n", version);
897 return 0;
898 }
899 return SSL_ctrl(ssl, setting, ver, NULL);
900 }
901 return 1;
902 }
903
904 int main(int argc, char *argv[])
905 {
906 const char *CApath = NULL, *CAfile = NULL;
907 int badop = 0;
908 enum { BIO_MEM, BIO_PAIR, BIO_IPV4, BIO_IPV6 } bio_type = BIO_MEM;
909 int force = 0;
910 int dtls1 = 0, dtls12 = 0, dtls = 0, tls1 = 0, tls1_2 = 0, ssl3 = 0, ret = 1;
911 int client_auth = 0;
912 int server_auth = 0, i;
913 struct app_verify_arg app_verify_arg =
914 { APP_CALLBACK_STRING, 0 };
915 char *p;
916 SSL_CTX *c_ctx = NULL;
917 const SSL_METHOD *meth = NULL;
918 SSL *c_ssl, *s_ssl;
919 int number = 1, reuse = 0;
920 int should_reuse = -1;
921 int no_ticket = 0;
922 long bytes = 256L;
923 #ifndef OPENSSL_NO_DH
924 DH *dh;
925 int dhe512 = 0, dhe1024dsa = 0;
926 #endif
927 int no_dhe = 0;
928 int no_psk = 0;
929 int print_time = 0;
930 clock_t s_time = 0, c_time = 0;
931 #ifndef OPENSSL_NO_COMP
932 int n, comp = 0;
933 COMP_METHOD *cm = NULL;
934 STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
935 #endif
936 int no_protocol;
937 int min_version = 0, max_version = 0;
938 #ifndef OPENSSL_NO_CT
939 /*
940 * Disable CT validation by default, because it will interfere with
941 * anything using custom extension handlers to deal with SCT extensions.
942 */
943 int ct_validation = 0;
944 #endif
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;
948
949 verbose = 0;
950 debug = 0;
951 cipher = 0;
952
953 bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
954
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);
959
960 RAND_seed(rnd_seed, sizeof rnd_seed);
961
962 bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);
963
964 s_cctx = SSL_CONF_CTX_new();
965 s_cctx2 = SSL_CONF_CTX_new();
966 c_cctx = SSL_CONF_CTX_new();
967
968 if (!s_cctx || !c_cctx || !s_cctx2) {
969 ERR_print_errors(bio_err);
970 goto end;
971 }
972
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);
983 goto end;
984 }
985 if (!SSL_CONF_CTX_set1_prefix(s_cctx2, "-s_")) {
986 ERR_print_errors(bio_err);
987 goto end;
988 }
989
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);
996 goto end;
997 }
998
999 argc--;
1000 argv++;
1001
1002 while (argc >= 1) {
1003 if (strcmp(*argv, "-F") == 0) {
1004 fprintf(stderr,
1005 "not compiled with FIPS support, so exiting without running.\n");
1006 EXIT(0);
1007 } else if (strcmp(*argv, "-server_auth") == 0)
1008 server_auth = 1;
1009 else if (strcmp(*argv, "-client_auth") == 0)
1010 client_auth = 1;
1011 else if (strcmp(*argv, "-v") == 0)
1012 verbose = 1;
1013 else if (strcmp(*argv, "-d") == 0)
1014 debug = 1;
1015 else if (strcmp(*argv, "-reuse") == 0)
1016 reuse = 1;
1017 else if (strcmp(*argv, "-dhe512") == 0) {
1018 #ifndef OPENSSL_NO_DH
1019 dhe512 = 1;
1020 #else
1021 fprintf(stderr,
1022 "ignoring -dhe512, since I'm compiled without DH\n");
1023 #endif
1024 } else if (strcmp(*argv, "-dhe1024dsa") == 0) {
1025 #ifndef OPENSSL_NO_DH
1026 dhe1024dsa = 1;
1027 #else
1028 fprintf(stderr,
1029 "ignoring -dhe1024dsa, since I'm compiled without DH\n");
1030 #endif
1031 } else if (strcmp(*argv, "-no_dhe") == 0)
1032 no_dhe = 1;
1033 else if (strcmp(*argv, "-no_ecdhe") == 0)
1034 /* obsolete */;
1035 else if (strcmp(*argv, "-psk") == 0) {
1036 if (--argc < 1)
1037 goto bad;
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);
1042 goto bad;
1043 }
1044 #else
1045 no_psk = 1;
1046 #endif
1047 }
1048 else if (strcmp(*argv, "-tls1_2") == 0) {
1049 tls1_2 = 1;
1050 } else if (strcmp(*argv, "-tls1") == 0) {
1051 tls1 = 1;
1052 } else if (strcmp(*argv, "-ssl3") == 0) {
1053 ssl3 = 1;
1054 } else if (strcmp(*argv, "-dtls1") == 0) {
1055 dtls1 = 1;
1056 } else if (strcmp(*argv, "-dtls12") == 0) {
1057 dtls12 = 1;
1058 } else if (strcmp(*argv, "-dtls") == 0) {
1059 dtls = 1;
1060 } else if (strncmp(*argv, "-num", 4) == 0) {
1061 if (--argc < 1)
1062 goto bad;
1063 number = atoi(*(++argv));
1064 if (number == 0)
1065 number = 1;
1066 } else if (strcmp(*argv, "-bytes") == 0) {
1067 if (--argc < 1)
1068 goto bad;
1069 bytes = atol(*(++argv));
1070 if (bytes == 0L)
1071 bytes = 1L;
1072 i = strlen(argv[0]);
1073 if (argv[0][i - 1] == 'k')
1074 bytes *= 1024L;
1075 if (argv[0][i - 1] == 'm')
1076 bytes *= 1024L * 1024L;
1077 } else if (strcmp(*argv, "-cipher") == 0) {
1078 if (--argc < 1)
1079 goto bad;
1080 cipher = *(++argv);
1081 } else if (strcmp(*argv, "-CApath") == 0) {
1082 if (--argc < 1)
1083 goto bad;
1084 CApath = *(++argv);
1085 } else if (strcmp(*argv, "-CAfile") == 0) {
1086 if (--argc < 1)
1087 goto bad;
1088 CAfile = *(++argv);
1089 } else if (strcmp(*argv, "-bio_pair") == 0) {
1090 bio_type = BIO_PAIR;
1091 }
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;
1097 }
1098 #endif
1099 else if (strcmp(*argv, "-f") == 0) {
1100 force = 1;
1101 } else if (strcmp(*argv, "-time") == 0) {
1102 print_time = 1;
1103 }
1104 #ifndef OPENSSL_NO_CT
1105 else if (strcmp(*argv, "-noct") == 0) {
1106 ct_validation = 0;
1107 }
1108 else if (strcmp(*argv, "-ct") == 0) {
1109 ct_validation = 1;
1110 }
1111 #endif
1112 #ifndef OPENSSL_NO_COMP
1113 else if (strcmp(*argv, "-zlib") == 0) {
1114 comp = COMP_ZLIB;
1115 }
1116 #endif
1117 else if (strcmp(*argv, "-app_verify") == 0) {
1118 app_verify_arg.app_verify = 1;
1119 }
1120 #ifndef OPENSSL_NO_NEXTPROTONEG
1121 else if (strcmp(*argv, "-npn_client") == 0) {
1122 npn_client = 1;
1123 } else if (strcmp(*argv, "-npn_server") == 0) {
1124 npn_server = 1;
1125 } else if (strcmp(*argv, "-npn_server_reject") == 0) {
1126 npn_server_reject = 1;
1127 }
1128 #endif
1129 else if (strcmp(*argv, "-serverinfo_sct") == 0) {
1130 serverinfo_sct = 1;
1131 } else if (strcmp(*argv, "-serverinfo_tack") == 0) {
1132 serverinfo_tack = 1;
1133 } else if (strcmp(*argv, "-serverinfo_file") == 0) {
1134 if (--argc < 1)
1135 goto bad;
1136 serverinfo_file = *(++argv);
1137 } else if (strcmp(*argv, "-custom_ext") == 0) {
1138 custom_ext = 1;
1139 } else if (strcmp(*argv, "-alpn_client") == 0) {
1140 if (--argc < 1)
1141 goto bad;
1142 alpn_client = *(++argv);
1143 } else if (strcmp(*argv, "-alpn_server") == 0 ||
1144 strcmp(*argv, "-alpn_server1") == 0) {
1145 if (--argc < 1)
1146 goto bad;
1147 alpn_server = *(++argv);
1148 } else if (strcmp(*argv, "-alpn_server2") == 0) {
1149 if (--argc < 1)
1150 goto bad;
1151 alpn_server2 = *(++argv);
1152 } else if (strcmp(*argv, "-alpn_expected") == 0) {
1153 if (--argc < 1)
1154 goto bad;
1155 alpn_expected = *(++argv);
1156 } else if (strcmp(*argv, "-server_min_proto") == 0) {
1157 if (--argc < 1)
1158 goto bad;
1159 server_min_proto = *(++argv);
1160 } else if (strcmp(*argv, "-server_max_proto") == 0) {
1161 if (--argc < 1)
1162 goto bad;
1163 server_max_proto = *(++argv);
1164 } else if (strcmp(*argv, "-client_min_proto") == 0) {
1165 if (--argc < 1)
1166 goto bad;
1167 client_min_proto = *(++argv);
1168 } else if (strcmp(*argv, "-client_max_proto") == 0) {
1169 if (--argc < 1)
1170 goto bad;
1171 client_max_proto = *(++argv);
1172 } else if (strcmp(*argv, "-should_negotiate") == 0) {
1173 if (--argc < 1)
1174 goto bad;
1175 should_negotiate = *(++argv);
1176 } else if (strcmp(*argv, "-sn_client") == 0) {
1177 if (--argc < 1)
1178 goto bad;
1179 sn_client = *(++argv);
1180 } else if (strcmp(*argv, "-sn_server1") == 0) {
1181 if (--argc < 1)
1182 goto bad;
1183 sn_server1 = *(++argv);
1184 } else if (strcmp(*argv, "-sn_server2") == 0) {
1185 if (--argc < 1)
1186 goto bad;
1187 sn_server2 = *(++argv);
1188 } else if (strcmp(*argv, "-sn_expect1") == 0) {
1189 sn_expect = 1;
1190 } else if (strcmp(*argv, "-sn_expect2") == 0) {
1191 sn_expect = 2;
1192 } else if (strcmp(*argv, "-server_sess_out") == 0) {
1193 if (--argc < 1)
1194 goto bad;
1195 server_sess_out = *(++argv);
1196 } else if (strcmp(*argv, "-server_sess_in") == 0) {
1197 if (--argc < 1)
1198 goto bad;
1199 server_sess_in = *(++argv);
1200 } else if (strcmp(*argv, "-client_sess_out") == 0) {
1201 if (--argc < 1)
1202 goto bad;
1203 client_sess_out = *(++argv);
1204 } else if (strcmp(*argv, "-client_sess_in") == 0) {
1205 if (--argc < 1)
1206 goto bad;
1207 client_sess_in = *(++argv);
1208 } else if (strcmp(*argv, "-should_reuse") == 0) {
1209 if (--argc < 1)
1210 goto bad;
1211 should_reuse = !!atoi(*(++argv));
1212 } else if (strcmp(*argv, "-no_ticket") == 0) {
1213 no_ticket = 1;
1214 } else {
1215 int rv;
1216 arg = argv[0];
1217 argn = argv[1];
1218 /* Try to process command using SSL_CONF */
1219 rv = SSL_CONF_cmd_argv(c_cctx, &argc, &argv);
1220 /* If not processed try server */
1221 if (rv == 0)
1222 rv = SSL_CONF_cmd_argv(s_cctx, &argc, &argv);
1223 /* Recognised: store it for later use */
1224 if (rv > 0) {
1225 if (rv == 1)
1226 argn = NULL;
1227 if (!conf_args) {
1228 conf_args = sk_OPENSSL_STRING_new_null();
1229 if (!conf_args)
1230 goto end;
1231 }
1232 if (!sk_OPENSSL_STRING_push(conf_args, arg))
1233 goto end;
1234 if (!sk_OPENSSL_STRING_push(conf_args, argn))
1235 goto end;
1236 continue;
1237 }
1238 if (rv == -3)
1239 BIO_printf(bio_err, "Missing argument for %s\n", arg);
1240 else if (rv < 0)
1241 BIO_printf(bio_err, "Error with command %s\n", arg);
1242 else if (rv == 0)
1243 BIO_printf(bio_err, "unknown option %s\n", arg);
1244 badop = 1;
1245 break;
1246 }
1247 argc--;
1248 argv++;
1249 }
1250 if (badop) {
1251 bad:
1252 sv_usage();
1253 goto end;
1254 }
1255
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 "
1258 "be requested.\n");
1259 EXIT(1);
1260 }
1261
1262 #ifdef OPENSSL_NO_SSL3
1263 if (ssl3)
1264 no_protocol = 1;
1265 else
1266 #endif
1267 #ifdef OPENSSL_NO_TLS1
1268 if (tls1)
1269 no_protocol = 1;
1270 else
1271 #endif
1272 #ifdef OPENSSL_NO_TLS1_2
1273 if (tls1_2)
1274 no_protocol = 1;
1275 else
1276 #endif
1277 #if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1)
1278 if (dtls1)
1279 no_protocol = 1;
1280 else
1281 #endif
1282 #if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1_2)
1283 if (dtls12)
1284 no_protocol = 1;
1285 else
1286 #endif
1287 no_protocol = 0;
1288
1289 /*
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.
1293 */
1294 if (no_protocol) {
1295 fprintf(stderr, "Testing was requested for a disabled protocol. "
1296 "Skipping tests.\n");
1297 ret = 0;
1298 goto end;
1299 }
1300
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");
1307 EXIT(1);
1308 }
1309
1310 if (print_time) {
1311 if (bio_type != BIO_PAIR) {
1312 fprintf(stderr, "Using BIO pair (-bio_pair)\n");
1313 bio_type = BIO_PAIR;
1314 }
1315 if (number < 50 && !force)
1316 fprintf(stderr,
1317 "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
1318 }
1319
1320 #ifndef OPENSSL_NO_COMP
1321 if (comp == COMP_ZLIB)
1322 cm = COMP_zlib();
1323 if (cm != NULL) {
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);
1328 }
1329 } else {
1330 fprintf(stderr,
1331 "Warning: %s compression not supported\n",
1332 comp == COMP_ZLIB ? "zlib" : "unknown");
1333 ERR_print_errors_fp(stderr);
1334 }
1335 }
1336 ssl_comp_methods = SSL_COMP_get_compression_methods();
1337 n = sk_SSL_COMP_num(ssl_comp_methods);
1338 if (n) {
1339 int j;
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));
1344 }
1345 printf("\n");
1346 }
1347 #endif
1348
1349 #ifndef OPENSSL_NO_TLS
1350 meth = TLS_method();
1351 if (ssl3) {
1352 min_version = SSL3_VERSION;
1353 max_version = SSL3_VERSION;
1354 } else if (tls1) {
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;
1360 }
1361 #endif
1362 #ifndef OPENSSL_NO_DTLS
1363 if (dtls || dtls1 || dtls12)
1364 meth = DTLS_method();
1365 if (dtls1) {
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;
1371 }
1372 #endif
1373
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);
1379 goto end;
1380 }
1381 /*
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.
1385 */
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);
1389
1390 if (no_ticket) {
1391 SSL_CTX_set_options(c_ctx, SSL_OP_NO_TICKET);
1392 SSL_CTX_set_options(s_ctx, SSL_OP_NO_TICKET);
1393 }
1394
1395 if (SSL_CTX_set_min_proto_version(c_ctx, min_version) == 0)
1396 goto end;
1397 if (SSL_CTX_set_max_proto_version(c_ctx, max_version) == 0)
1398 goto end;
1399 if (SSL_CTX_set_min_proto_version(s_ctx, min_version) == 0)
1400 goto end;
1401 if (SSL_CTX_set_max_proto_version(s_ctx, max_version) == 0)
1402 goto end;
1403
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);
1409 goto end;
1410 }
1411 }
1412
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);
1417 goto end;
1418 }
1419 #endif
1420
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);
1425
1426 for (i = 0; i < sk_OPENSSL_STRING_num(conf_args); i += 2) {
1427 int rv;
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 */
1432 if (rv == -2) {
1433 rv = SSL_CONF_cmd(s_cctx2, arg, argn);
1434 if (rv > 0)
1435 rv = SSL_CONF_cmd(s_cctx, arg, argn);
1436 }
1437 if (rv <= 0) {
1438 BIO_printf(bio_err, "Error processing %s %s\n",
1439 arg, argn ? argn : "");
1440 ERR_print_errors(bio_err);
1441 goto end;
1442 }
1443 }
1444
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);
1448 goto end;
1449 }
1450 #ifndef OPENSSL_NO_DH
1451 if (!no_dhe) {
1452 if (dhe1024dsa) {
1453 dh = get_dh1024dsa();
1454 } else if (dhe512)
1455 dh = get_dh512();
1456 else
1457 dh = get_dh1024();
1458 SSL_CTX_set_tmp_dh(s_ctx, dh);
1459 SSL_CTX_set_tmp_dh(s_ctx2, dh);
1460 DH_free(dh);
1461 }
1462 #else
1463 (void)no_dhe;
1464 #endif
1465
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);
1473 }
1474
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);
1480 }
1481 #endif
1482
1483 if (client_auth) {
1484 printf("client authentication\n");
1485 SSL_CTX_set_verify(s_ctx,
1486 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1487 verify_callback);
1488 SSL_CTX_set_verify(s_ctx2,
1489 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1490 verify_callback);
1491 SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback,
1492 &app_verify_arg);
1493 SSL_CTX_set_cert_verify_callback(s_ctx2, app_verify_callback,
1494 &app_verify_arg);
1495 }
1496 if (server_auth) {
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,
1500 &app_verify_arg);
1501 }
1502
1503 {
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);
1510 goto end;
1511 }
1512 }
1513
1514 /* Use PSK only if PSK key is given */
1515 if (psk_key != NULL) {
1516 /*
1517 * no_psk is used to avoid putting psk command to openssl tool
1518 */
1519 if (no_psk) {
1520 /*
1521 * if PSK is not compiled in and psk key is given, do nothing and
1522 * exit successfully
1523 */
1524 ret = 0;
1525 goto end;
1526 }
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);
1531 if (debug)
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);
1537 goto end;
1538 }
1539 #endif
1540 }
1541
1542 #ifndef OPENSSL_NO_NEXTPROTONEG
1543 if (npn_client) {
1544 SSL_CTX_set_next_proto_select_cb(c_ctx, cb_client_npn, NULL);
1545 }
1546 if (npn_server) {
1547 if (npn_server_reject) {
1548 BIO_printf(bio_err,
1549 "Can't have both -npn_server and -npn_server_reject\n");
1550 goto end;
1551 }
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);
1554 }
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);
1558 }
1559 #endif
1560
1561 if (serverinfo_sct) {
1562 if (!SSL_CTX_add_client_custom_ext(c_ctx,
1563 TLSEXT_TYPE_signed_certificate_timestamp,
1564 NULL, NULL, NULL,
1565 serverinfo_cli_parse_cb, NULL)) {
1566 BIO_printf(bio_err, "Error adding SCT extension\n");
1567 goto end;
1568 }
1569 }
1570 if (serverinfo_tack) {
1571 if (!SSL_CTX_add_client_custom_ext(c_ctx, TACK_EXT_TYPE,
1572 NULL, NULL, NULL,
1573 serverinfo_cli_parse_cb, NULL)) {
1574 BIO_printf(bio_err, "Error adding TACK extension\n");
1575 goto end;
1576 }
1577 }
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");
1582 goto end;
1583 }
1584
1585 if (custom_ext) {
1586 if (!SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_0,
1587 custom_ext_0_cli_add_cb,
1588 NULL, NULL,
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,
1592 NULL, NULL,
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,
1596 NULL, NULL,
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,
1600 NULL, NULL,
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,
1604 NULL, NULL,
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,
1608 NULL, NULL,
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,
1612 NULL, NULL,
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,
1616 NULL, NULL,
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,
1620 NULL, NULL,
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,
1624 NULL, NULL,
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,
1628 NULL, NULL,
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,
1632 NULL, NULL,
1633 custom_ext_3_srv_parse_cb, NULL)) {
1634 BIO_printf(bio_err, "Error setting custom extensions\n");
1635 goto end;
1636 }
1637 }
1638
1639 if (alpn_server)
1640 SSL_CTX_set_alpn_select_cb(s_ctx, cb_server_alpn, alpn_server);
1641 if (alpn_server2)
1642 SSL_CTX_set_alpn_select_cb(s_ctx2, cb_server_alpn, alpn_server2);
1643
1644 if (alpn_client) {
1645 size_t alpn_len;
1646 unsigned char *alpn = next_protos_parse(&alpn_len, alpn_client);
1647
1648 if (alpn == NULL) {
1649 BIO_printf(bio_err, "Error parsing -alpn_client argument\n");
1650 goto end;
1651 }
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");
1655 OPENSSL_free(alpn);
1656 goto end;
1657 }
1658 OPENSSL_free(alpn);
1659 }
1660
1661 if (server_sess_in != NULL) {
1662 server_sess = read_session(server_sess_in);
1663 if (server_sess == NULL)
1664 goto end;
1665 }
1666 if (client_sess_in != NULL) {
1667 client_sess = read_session(client_sess_in);
1668 if (client_sess == NULL)
1669 goto end;
1670 }
1671
1672 if (server_sess_out != NULL || server_sess_in != NULL) {
1673 char *keys;
1674 long size;
1675
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);
1680 OPENSSL_free(keys);
1681 }
1682
1683 if (sn_server1 != NULL || sn_server2 != NULL)
1684 SSL_CTX_set_tlsext_servername_callback(s_ctx, servername_cb);
1685
1686 c_ssl = SSL_new(c_ctx);
1687 s_ssl = SSL_new(s_ctx);
1688
1689 if (sn_client)
1690 SSL_set_tlsext_host_name(c_ssl, sn_client);
1691
1692 if (!set_protocol_version(server_min_proto, s_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1693 goto end;
1694 if (!set_protocol_version(server_max_proto, s_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1695 goto end;
1696 if (!set_protocol_version(client_min_proto, c_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1697 goto end;
1698 if (!set_protocol_version(client_max_proto, c_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1699 goto end;
1700
1701 if (server_sess) {
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);
1705 goto end;
1706 }
1707 }
1708
1709 BIO_printf(bio_stdout, "Doing handshakes=%d bytes=%ld\n", number, bytes);
1710 for (i = 0; i < number; i++) {
1711 if (!reuse) {
1712 if (!SSL_set_session(c_ssl, NULL)) {
1713 BIO_printf(bio_err, "Failed to set session\n");
1714 goto end;
1715 }
1716 }
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);
1721 goto end;
1722 }
1723 }
1724 switch (bio_type) {
1725 case BIO_MEM:
1726 ret = doit(s_ssl, c_ssl, bytes);
1727 break;
1728 case BIO_PAIR:
1729 ret = doit_biopair(s_ssl, c_ssl, bytes, &s_time, &c_time);
1730 break;
1731 #ifndef OPENSSL_NO_SOCK
1732 case BIO_IPV4:
1733 ret = doit_localhost(s_ssl, c_ssl, BIO_FAMILY_IPV4,
1734 bytes, &s_time, &c_time);
1735 break;
1736 case BIO_IPV6:
1737 ret = doit_localhost(s_ssl, c_ssl, BIO_FAMILY_IPV6,
1738 bytes, &s_time, &c_time);
1739 break;
1740 #else
1741 case BIO_IPV4:
1742 case BIO_IPV6:
1743 ret = 1;
1744 goto err;
1745 #endif
1746 }
1747 if (ret) break;
1748 }
1749
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);
1754 if (version < 0) {
1755 BIO_printf(bio_err, "Error parsing: %s\n", should_negotiate);
1756 ret = 1;
1757 goto err;
1758 }
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));
1762 ret = 1;
1763 goto err;
1764 }
1765 }
1766
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));
1773 ret = 1;
1774 goto err;
1775 }
1776 }
1777
1778 if (server_sess_out != NULL) {
1779 if (write_session(server_sess_out, SSL_get_session(s_ssl)) == 0) {
1780 ret = 1;
1781 goto err;
1782 }
1783 }
1784 if (client_sess_out != NULL) {
1785 if (write_session(client_sess_out, SSL_get_session(c_ssl)) == 0) {
1786 ret = 1;
1787 goto err;
1788 }
1789 }
1790
1791 if (!verbose) {
1792 print_details(c_ssl, "");
1793 }
1794 if (print_time) {
1795 #ifdef CLOCKS_PER_SEC
1796 /*
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
1800 */
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);
1805 #else
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);
1810 #endif
1811 }
1812
1813 err:
1814 SSL_free(s_ssl);
1815 SSL_free(c_ssl);
1816
1817 end:
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);
1825
1826 BIO_free(bio_stdout);
1827
1828 SSL_SESSION_free(server_sess);
1829 SSL_SESSION_free(client_sess);
1830
1831 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
1832 if (CRYPTO_mem_leaks(bio_err) <= 0)
1833 ret = 1;
1834 #endif
1835 BIO_free(bio_err);
1836 EXIT(ret);
1837 }
1838
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)
1842 {
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;
1846 char addr_str[40];
1847 int ret = 1;
1848 int err_in_client = 0;
1849 int err_in_server = 0;
1850
1851 acpt = BIO_new_accept("0");
1852 if (acpt == NULL)
1853 goto err;
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)
1857 goto err;
1858
1859 BIO_snprintf(addr_str, sizeof(addr_str), ":%s", BIO_get_accept_port(acpt));
1860
1861 client = BIO_new_connect(addr_str);
1862 BIO_set_conn_ip_family(client, family);
1863 if (!client)
1864 goto err;
1865
1866 if (BIO_set_nbio(client, 1) <= 0)
1867 goto err;
1868 if (BIO_set_nbio(acpt, 1) <= 0)
1869 goto err;
1870
1871 {
1872 int st_connect = 0, st_accept = 0;
1873
1874 while(!st_connect || !st_accept) {
1875 if (!st_connect) {
1876 if (BIO_do_connect(client) <= 0) {
1877 if (!BIO_should_retry(client))
1878 goto err;
1879 } else {
1880 st_connect = 1;
1881 }
1882 }
1883 if (!st_accept) {
1884 if (BIO_do_accept(acpt) <= 0) {
1885 if (!BIO_should_retry(acpt))
1886 goto err;
1887 } else {
1888 st_accept = 1;
1889 }
1890 }
1891 }
1892 }
1893 /* We're not interested in accepting further connects */
1894 server = BIO_pop(acpt);
1895 BIO_free_all(acpt);
1896 acpt = NULL;
1897
1898 s_ssl_bio = BIO_new(BIO_f_ssl());
1899 if (!s_ssl_bio)
1900 goto err;
1901
1902 c_ssl_bio = BIO_new(BIO_f_ssl());
1903 if (!c_ssl_bio)
1904 goto err;
1905
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);
1909
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);
1913
1914 do {
1915 /*-
1916 * c_ssl_bio: SSL filter BIO
1917 *
1918 * client: I/O for SSL library
1919 *
1920 *
1921 * server: I/O for SSL library
1922 *
1923 * s_ssl_bio: SSL filter BIO
1924 */
1925
1926 /*
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
1931 */
1932
1933 {
1934 /* CLIENT */
1935
1936 char cbuf[1024 * 8];
1937 int i, r;
1938 clock_t c_clock = clock();
1939
1940 memset(cbuf, 0, sizeof(cbuf));
1941
1942 if (debug)
1943 if (SSL_in_init(c_ssl))
1944 printf("client waiting in SSL_connect - %s\n",
1945 SSL_state_string_long(c_ssl));
1946
1947 if (cw_num > 0) {
1948 /* Write to server. */
1949
1950 if (cw_num > (long)sizeof cbuf)
1951 i = sizeof cbuf;
1952 else
1953 i = (int)cw_num;
1954 r = BIO_write(c_ssl_bio, cbuf, i);
1955 if (r < 0) {
1956 if (!BIO_should_retry(c_ssl_bio)) {
1957 fprintf(stderr, "ERROR in CLIENT\n");
1958 err_in_client = 1;
1959 goto err;
1960 }
1961 /*
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
1965 * next iteration.
1966 */
1967 } else if (r == 0) {
1968 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1969 goto err;
1970 } else {
1971 if (debug)
1972 printf("client wrote %d\n", r);
1973 cw_num -= r;
1974 }
1975 }
1976
1977 if (cr_num > 0) {
1978 /* Read from server. */
1979
1980 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1981 if (r < 0) {
1982 if (!BIO_should_retry(c_ssl_bio)) {
1983 fprintf(stderr, "ERROR in CLIENT\n");
1984 err_in_client = 1;
1985 goto err;
1986 }
1987 /*
1988 * Again, "BIO_should_retry" can be ignored.
1989 */
1990 } else if (r == 0) {
1991 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1992 goto err;
1993 } else {
1994 if (debug)
1995 printf("client read %d\n", r);
1996 cr_num -= r;
1997 }
1998 }
1999
2000 /*
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
2007 * even not at all.
2008 */
2009 *c_time += (clock() - c_clock);
2010 }
2011
2012 {
2013 /* SERVER */
2014
2015 char sbuf[1024 * 8];
2016 int i, r;
2017 clock_t s_clock = clock();
2018
2019 memset(sbuf, 0, sizeof(sbuf));
2020
2021 if (debug)
2022 if (SSL_in_init(s_ssl))
2023 printf("server waiting in SSL_accept - %s\n",
2024 SSL_state_string_long(s_ssl));
2025
2026 if (sw_num > 0) {
2027 /* Write to client. */
2028
2029 if (sw_num > (long)sizeof sbuf)
2030 i = sizeof sbuf;
2031 else
2032 i = (int)sw_num;
2033 r = BIO_write(s_ssl_bio, sbuf, i);
2034 if (r < 0) {
2035 if (!BIO_should_retry(s_ssl_bio)) {
2036 fprintf(stderr, "ERROR in SERVER\n");
2037 err_in_server = 1;
2038 goto err;
2039 }
2040 /* Ignore "BIO_should_retry". */
2041 } else if (r == 0) {
2042 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2043 goto err;
2044 } else {
2045 if (debug)
2046 printf("server wrote %d\n", r);
2047 sw_num -= r;
2048 }
2049 }
2050
2051 if (sr_num > 0) {
2052 /* Read from client. */
2053
2054 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2055 if (r < 0) {
2056 if (!BIO_should_retry(s_ssl_bio)) {
2057 fprintf(stderr, "ERROR in SERVER\n");
2058 err_in_server = 1;
2059 goto err;
2060 }
2061 /* blah, blah */
2062 } else if (r == 0) {
2063 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2064 goto err;
2065 } else {
2066 if (debug)
2067 printf("server read %d\n", r);
2068 sr_num -= r;
2069 }
2070 }
2071
2072 *s_time += (clock() - s_clock);
2073 }
2074 }
2075 while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2076
2077 if (verbose)
2078 print_details(c_ssl, "DONE via TCP connect: ");
2079 # ifndef OPENSSL_NO_NEXTPROTONEG
2080 if (verify_npn(c_ssl, s_ssl) < 0) {
2081 ret = 1;
2082 goto end;
2083 }
2084 # endif
2085 if (verify_serverinfo() < 0) {
2086 fprintf(stderr, "Server info verify error\n");
2087 ret = 1;
2088 goto err;
2089 }
2090 if (verify_alpn(c_ssl, s_ssl) < 0) {
2091 ret = 1;
2092 goto err;
2093 }
2094 if (verify_servername(c_ssl, s_ssl) < 0) {
2095 ret = 1;
2096 goto err;
2097 }
2098
2099 if (custom_ext_error) {
2100 fprintf(stderr, "Custom extension error\n");
2101 ret = 1;
2102 goto err;
2103 }
2104
2105 # ifndef OPENSSL_NO_NEXTPROTONEG
2106 end:
2107 # endif
2108 ret = 0;
2109
2110 err:
2111 ERR_print_errors(bio_err);
2112
2113 BIO_free_all(acpt);
2114 BIO_free(server);
2115 BIO_free(client);
2116 BIO_free(s_ssl_bio);
2117 BIO_free(c_ssl_bio);
2118
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;
2123
2124 return ret;
2125 }
2126 #endif
2127
2128 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
2129 clock_t *s_time, clock_t *c_time)
2130 {
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;
2134 int ret = 1;
2135 int err_in_client = 0;
2136 int err_in_server = 0;
2137
2138 size_t bufsiz = 256; /* small buffer for testing */
2139
2140 if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
2141 goto err;
2142 if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
2143 goto err;
2144
2145 s_ssl_bio = BIO_new(BIO_f_ssl());
2146 if (!s_ssl_bio)
2147 goto err;
2148
2149 c_ssl_bio = BIO_new(BIO_f_ssl());
2150 if (!c_ssl_bio)
2151 goto err;
2152
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);
2156
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);
2160
2161 do {
2162 /*-
2163 * c_ssl_bio: SSL filter BIO
2164 *
2165 * client: pseudo-I/O for SSL library
2166 *
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:
2170 *
2171 * server_io: server's SSL communication
2172 *
2173 * server: pseudo-I/O for SSL library
2174 *
2175 * s_ssl_bio: SSL filter BIO
2176 *
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.]
2185 *
2186 * Useful functions for querying the state of BIO pair endpoints:
2187 *
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
2192 *
2193 * ..._read_request is never more than ..._write_guarantee;
2194 * it depends on the application which one you should use.
2195 */
2196
2197 /*
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
2202 */
2203
2204 {
2205 /* CLIENT */
2206
2207 char cbuf[1024 * 8];
2208 int i, r;
2209 clock_t c_clock = clock();
2210
2211 memset(cbuf, 0, sizeof(cbuf));
2212
2213 if (debug)
2214 if (SSL_in_init(c_ssl))
2215 printf("client waiting in SSL_connect - %s\n",
2216 SSL_state_string_long(c_ssl));
2217
2218 if (cw_num > 0) {
2219 /* Write to server. */
2220
2221 if (cw_num > (long)sizeof cbuf)
2222 i = sizeof cbuf;
2223 else
2224 i = (int)cw_num;
2225 r = BIO_write(c_ssl_bio, cbuf, i);
2226 if (r < 0) {
2227 if (!BIO_should_retry(c_ssl_bio)) {
2228 fprintf(stderr, "ERROR in CLIENT\n");
2229 err_in_client = 1;
2230 goto err;
2231 }
2232 /*
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
2236 * next iteration.
2237 */
2238 } else if (r == 0) {
2239 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2240 goto err;
2241 } else {
2242 if (debug)
2243 printf("client wrote %d\n", r);
2244 cw_num -= r;
2245 }
2246 }
2247
2248 if (cr_num > 0) {
2249 /* Read from server. */
2250
2251 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
2252 if (r < 0) {
2253 if (!BIO_should_retry(c_ssl_bio)) {
2254 fprintf(stderr, "ERROR in CLIENT\n");
2255 err_in_client = 1;
2256 goto err;
2257 }
2258 /*
2259 * Again, "BIO_should_retry" can be ignored.
2260 */
2261 } else if (r == 0) {
2262 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2263 goto err;
2264 } else {
2265 if (debug)
2266 printf("client read %d\n", r);
2267 cr_num -= r;
2268 }
2269 }
2270
2271 /*
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
2278 * even not at all.
2279 */
2280 *c_time += (clock() - c_clock);
2281 }
2282
2283 {
2284 /* SERVER */
2285
2286 char sbuf[1024 * 8];
2287 int i, r;
2288 clock_t s_clock = clock();
2289
2290 memset(sbuf, 0, sizeof(sbuf));
2291
2292 if (debug)
2293 if (SSL_in_init(s_ssl))
2294 printf("server waiting in SSL_accept - %s\n",
2295 SSL_state_string_long(s_ssl));
2296
2297 if (sw_num > 0) {
2298 /* Write to client. */
2299
2300 if (sw_num > (long)sizeof sbuf)
2301 i = sizeof sbuf;
2302 else
2303 i = (int)sw_num;
2304 r = BIO_write(s_ssl_bio, sbuf, i);
2305 if (r < 0) {
2306 if (!BIO_should_retry(s_ssl_bio)) {
2307 fprintf(stderr, "ERROR in SERVER\n");
2308 err_in_server = 1;
2309 goto err;
2310 }
2311 /* Ignore "BIO_should_retry". */
2312 } else if (r == 0) {
2313 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2314 goto err;
2315 } else {
2316 if (debug)
2317 printf("server wrote %d\n", r);
2318 sw_num -= r;
2319 }
2320 }
2321
2322 if (sr_num > 0) {
2323 /* Read from client. */
2324
2325 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2326 if (r < 0) {
2327 if (!BIO_should_retry(s_ssl_bio)) {
2328 fprintf(stderr, "ERROR in SERVER\n");
2329 err_in_server = 1;
2330 goto err;
2331 }
2332 /* blah, blah */
2333 } else if (r == 0) {
2334 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2335 goto err;
2336 } else {
2337 if (debug)
2338 printf("server read %d\n", r);
2339 sr_num -= r;
2340 }
2341 }
2342
2343 *s_time += (clock() - s_clock);
2344 }
2345
2346 {
2347 /* "I/O" BETWEEN CLIENT AND SERVER. */
2348
2349 size_t r1, r2;
2350 BIO *io1 = server_io, *io2 = client_io;
2351 /*
2352 * we use the non-copying interface for io1 and the standard
2353 * BIO_write/BIO_read interface for io2
2354 */
2355
2356 static int prev_progress = 1;
2357 int progress = 0;
2358
2359 /* io1 to io2 */
2360 do {
2361 size_t num;
2362 int r;
2363
2364 r1 = BIO_ctrl_pending(io1);
2365 r2 = BIO_ctrl_get_write_guarantee(io2);
2366
2367 num = r1;
2368 if (r2 < num)
2369 num = r2;
2370 if (num) {
2371 char *dataptr;
2372
2373 if (INT_MAX < num) /* yeah, right */
2374 num = INT_MAX;
2375
2376 r = BIO_nread(io1, &dataptr, (int)num);
2377 assert(r > 0);
2378 assert(r <= (int)num);
2379 /*
2380 * possibly r < num (non-contiguous data)
2381 */
2382 num = r;
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");
2387 goto err;
2388 }
2389 progress = 1;
2390
2391 if (debug)
2392 printf((io1 == client_io) ?
2393 "C->S relaying: %d bytes\n" :
2394 "S->C relaying: %d bytes\n", (int)num);
2395 }
2396 }
2397 while (r1 && r2);
2398
2399 /* io2 to io1 */
2400 {
2401 size_t num;
2402 int r;
2403
2404 r1 = BIO_ctrl_pending(io2);
2405 r2 = BIO_ctrl_get_read_request(io1);
2406 /*
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
2410 */
2411 num = r1;
2412 if (r2 < num)
2413 num = r2;
2414 if (num) {
2415 char *dataptr;
2416
2417 if (INT_MAX < num)
2418 num = INT_MAX;
2419
2420 if (num > 1)
2421 --num; /* test restartability even more thoroughly */
2422
2423 r = BIO_nwrite0(io1, &dataptr);
2424 assert(r > 0);
2425 if (r < (int)num)
2426 num = r;
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");
2431 goto err;
2432 }
2433 progress = 1;
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");
2438 goto err;
2439 }
2440
2441 if (debug)
2442 printf((io2 == client_io) ?
2443 "C->S relaying: %d bytes\n" :
2444 "S->C relaying: %d bytes\n", (int)num);
2445 }
2446 } /* no loop, BIO_ctrl_get_read_request now
2447 * returns 0 anyway */
2448
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");
2453 goto err;
2454 }
2455 prev_progress = progress;
2456 }
2457 }
2458 while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2459
2460 if (verbose)
2461 print_details(c_ssl, "DONE via BIO pair: ");
2462 #ifndef OPENSSL_NO_NEXTPROTONEG
2463 if (verify_npn(c_ssl, s_ssl) < 0) {
2464 ret = 1;
2465 goto end;
2466 }
2467 #endif
2468 if (verify_serverinfo() < 0) {
2469 fprintf(stderr, "Server info verify error\n");
2470 ret = 1;
2471 goto err;
2472 }
2473 if (verify_alpn(c_ssl, s_ssl) < 0) {
2474 ret = 1;
2475 goto err;
2476 }
2477 if (verify_servername(c_ssl, s_ssl) < 0) {
2478 ret = 1;
2479 goto err;
2480 }
2481
2482 if (custom_ext_error) {
2483 fprintf(stderr, "Custom extension error\n");
2484 ret = 1;
2485 goto err;
2486 }
2487
2488 #ifndef OPENSSL_NO_NEXTPROTONEG
2489 end:
2490 #endif
2491 ret = 0;
2492
2493 err:
2494 ERR_print_errors(bio_err);
2495
2496 BIO_free(server);
2497 BIO_free(server_io);
2498 BIO_free(client);
2499 BIO_free(client_io);
2500 BIO_free(s_ssl_bio);
2501 BIO_free(c_ssl_bio);
2502
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;
2507
2508 return ret;
2509 }
2510
2511 #define W_READ 1
2512 #define W_WRITE 2
2513 #define C_DONE 1
2514 #define S_DONE 2
2515
2516 int doit(SSL *s_ssl, SSL *c_ssl, long count)
2517 {
2518 char *cbuf = NULL, *sbuf = NULL;
2519 long bufsiz;
2520 long cw_num = count, cr_num = count;
2521 long sw_num = count, sr_num = count;
2522 int ret = 1;
2523 BIO *c_to_s = NULL;
2524 BIO *s_to_c = NULL;
2525 BIO *c_bio = NULL;
2526 BIO *s_bio = NULL;
2527 int c_r, c_w, s_r, s_w;
2528 int i, j;
2529 int done = 0;
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;
2535
2536 bufsiz = count > 40 * 1024 ? 40 * 1024 : count;
2537
2538 if ((cbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2539 goto err;
2540 if ((sbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2541 goto err;
2542
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);
2547 goto err;
2548 }
2549
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);
2554 goto err;
2555 }
2556
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);
2561
2562 /*
2563 * We've just given our ref to these BIOs to c_ssl. We need another one to
2564 * give to s_ssl
2565 */
2566 if (!BIO_up_ref(c_to_s)) {
2567 /* c_to_s and s_to_c will get freed when we free c_ssl */
2568 c_to_s = NULL;
2569 s_to_c = NULL;
2570 goto err;
2571 }
2572 if (!BIO_up_ref(s_to_c)) {
2573 /* s_to_c will get freed when we free c_ssl */
2574 s_to_c = NULL;
2575 goto err;
2576 }
2577
2578 SSL_set_accept_state(s_ssl);
2579 SSL_set_bio(s_ssl, c_to_s, s_to_c);
2580
2581 /* We've used up all our refs to these now */
2582 c_to_s = NULL;
2583 s_to_c = NULL;
2584
2585 SSL_set_max_send_fragment(s_ssl, max_frag);
2586 BIO_set_ssl(s_bio, s_ssl, BIO_NOCLOSE);
2587
2588 c_r = 0;
2589 s_r = 1;
2590 c_w = 1;
2591 s_w = 0;
2592 c_write = 1, s_write = 0;
2593
2594 /* We can always do writes */
2595 for (;;) {
2596 do_server = 0;
2597 do_client = 0;
2598
2599 i = (int)BIO_pending(s_bio);
2600 if ((i && s_r) || s_w)
2601 do_server = 1;
2602
2603 i = (int)BIO_pending(c_bio);
2604 if ((i && c_r) || c_w)
2605 do_client = 1;
2606
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));
2611 }
2612
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));
2617 }
2618
2619 if (!do_client && !do_server) {
2620 fprintf(stdout, "ERROR IN STARTUP\n");
2621 ERR_print_errors(bio_err);
2622 goto err;
2623 }
2624 if (do_client && !(done & C_DONE)) {
2625 if (c_write) {
2626 j = (cw_num > bufsiz) ? (int)bufsiz : (int)cw_num;
2627 i = BIO_write(c_bio, cbuf, j);
2628 if (i < 0) {
2629 c_r = 0;
2630 c_w = 0;
2631 if (BIO_should_retry(c_bio)) {
2632 if (BIO_should_read(c_bio))
2633 c_r = 1;
2634 if (BIO_should_write(c_bio))
2635 c_w = 1;
2636 } else {
2637 fprintf(stderr, "ERROR in CLIENT\n");
2638 err_in_client = 1;
2639 ERR_print_errors(bio_err);
2640 goto err;
2641 }
2642 } else if (i == 0) {
2643 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2644 goto err;
2645 } else {
2646 if (debug)
2647 printf("client wrote %d\n", i);
2648 /* ok */
2649 s_r = 1;
2650 c_write = 0;
2651 cw_num -= i;
2652 if (max_frag > 1029)
2653 SSL_set_max_send_fragment(c_ssl, max_frag -= 5);
2654 }
2655 } else {
2656 i = BIO_read(c_bio, cbuf, bufsiz);
2657 if (i < 0) {
2658 c_r = 0;
2659 c_w = 0;
2660 if (BIO_should_retry(c_bio)) {
2661 if (BIO_should_read(c_bio))
2662 c_r = 1;
2663 if (BIO_should_write(c_bio))
2664 c_w = 1;
2665 } else {
2666 fprintf(stderr, "ERROR in CLIENT\n");
2667 err_in_client = 1;
2668 ERR_print_errors(bio_err);
2669 goto err;
2670 }
2671 } else if (i == 0) {
2672 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2673 goto err;
2674 } else {
2675 if (debug)
2676 printf("client read %d\n", i);
2677 cr_num -= i;
2678 if (sw_num > 0) {
2679 s_write = 1;
2680 s_w = 1;
2681 }
2682 if (cr_num <= 0) {
2683 s_write = 1;
2684 s_w = 1;
2685 done = S_DONE | C_DONE;
2686 }
2687 }
2688 }
2689 }
2690
2691 if (do_server && !(done & S_DONE)) {
2692 if (!s_write) {
2693 i = BIO_read(s_bio, sbuf, bufsiz);
2694 if (i < 0) {
2695 s_r = 0;
2696 s_w = 0;
2697 if (BIO_should_retry(s_bio)) {
2698 if (BIO_should_read(s_bio))
2699 s_r = 1;
2700 if (BIO_should_write(s_bio))
2701 s_w = 1;
2702 } else {
2703 fprintf(stderr, "ERROR in SERVER\n");
2704 err_in_server = 1;
2705 ERR_print_errors(bio_err);
2706 goto err;
2707 }
2708 } else if (i == 0) {
2709 ERR_print_errors(bio_err);
2710 fprintf(stderr,
2711 "SSL SERVER STARTUP FAILED in SSL_read\n");
2712 goto err;
2713 } else {
2714 if (debug)
2715 printf("server read %d\n", i);
2716 sr_num -= i;
2717 if (cw_num > 0) {
2718 c_write = 1;
2719 c_w = 1;
2720 }
2721 if (sr_num <= 0) {
2722 s_write = 1;
2723 s_w = 1;
2724 c_write = 0;
2725 }
2726 }
2727 } else {
2728 j = (sw_num > bufsiz) ? (int)bufsiz : (int)sw_num;
2729 i = BIO_write(s_bio, sbuf, j);
2730 if (i < 0) {
2731 s_r = 0;
2732 s_w = 0;
2733 if (BIO_should_retry(s_bio)) {
2734 if (BIO_should_read(s_bio))
2735 s_r = 1;
2736 if (BIO_should_write(s_bio))
2737 s_w = 1;
2738 } else {
2739 fprintf(stderr, "ERROR in SERVER\n");
2740 err_in_server = 1;
2741 ERR_print_errors(bio_err);
2742 goto err;
2743 }
2744 } else if (i == 0) {
2745 ERR_print_errors(bio_err);
2746 fprintf(stderr,
2747 "SSL SERVER STARTUP FAILED in SSL_write\n");
2748 goto err;
2749 } else {
2750 if (debug)
2751 printf("server wrote %d\n", i);
2752 sw_num -= i;
2753 s_write = 0;
2754 c_r = 1;
2755 if (sw_num <= 0)
2756 done |= S_DONE;
2757 if (max_frag > 1029)
2758 SSL_set_max_send_fragment(s_ssl, max_frag -= 5);
2759 }
2760 }
2761 }
2762
2763 if ((done & S_DONE) && (done & C_DONE))
2764 break;
2765 }
2766
2767 if (verbose)
2768 print_details(c_ssl, "DONE: ");
2769 #ifndef OPENSSL_NO_NEXTPROTONEG
2770 if (verify_npn(c_ssl, s_ssl) < 0) {
2771 ret = 1;
2772 goto err;
2773 }
2774 #endif
2775 if (verify_serverinfo() < 0) {
2776 fprintf(stderr, "Server info verify error\n");
2777 ret = 1;
2778 goto err;
2779 }
2780 if (custom_ext_error) {
2781 fprintf(stderr, "Custom extension error\n");
2782 ret = 1;
2783 goto err;
2784 }
2785 ret = 0;
2786 err:
2787 BIO_free(c_to_s);
2788 BIO_free(s_to_c);
2789 BIO_free_all(c_bio);
2790 BIO_free_all(s_bio);
2791 OPENSSL_free(cbuf);
2792 OPENSSL_free(sbuf);
2793
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;
2798
2799 return (ret);
2800 }
2801
2802 static int verify_callback(int ok, X509_STORE_CTX *ctx)
2803 {
2804 char *s, buf[256];
2805
2806 s = X509_NAME_oneline(X509_get_subject_name(X509_STORE_CTX_get_current_cert(ctx)),
2807 buf, sizeof buf);
2808 if (s != NULL) {
2809 if (ok)
2810 printf("depth=%d %s\n", X509_STORE_CTX_get_error_depth(ctx), buf);
2811 else {
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);
2815 }
2816 }
2817
2818 if (ok == 0) {
2819 int i = X509_STORE_CTX_get_error(ctx);
2820
2821 switch (i) {
2822 default:
2823 fprintf(stderr, "Error string: %s\n",
2824 X509_verify_cert_error_string(i));
2825 break;
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:
2829 ok = 1;
2830 break;
2831 }
2832 }
2833
2834 return (ok);
2835 }
2836
2837 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2838 {
2839 int ok = 1;
2840 struct app_verify_arg *cb_arg = arg;
2841
2842 if (cb_arg->app_verify) {
2843 char *s = NULL, buf[256];
2844 X509 *c = X509_STORE_CTX_get0_cert(ctx);
2845
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);
2850 if (c)
2851 s = X509_NAME_oneline(X509_get_subject_name(c), buf, 256);
2852 if (s != NULL) {
2853 printf("cert depth=%d %s\n",
2854 X509_STORE_CTX_get_error_depth(ctx), buf);
2855 }
2856 return (1);
2857 }
2858
2859 ok = X509_verify_cert(ctx);
2860
2861 return (ok);
2862 }
2863
2864 #ifndef OPENSSL_NO_DH
2865 /*-
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.)
2871 */
2872 static DH *get_dh512()
2873 {
2874 static unsigned char dh512_p[] = {
2875 0xCB, 0xC8, 0xE1, 0x86, 0xD0, 0x1F, 0x94, 0x17, 0xA6, 0x99, 0xF0,
2876 0xC6,
2877 0x1F, 0x0D, 0xAC, 0xB6, 0x25, 0x3E, 0x06, 0x39, 0xCA, 0x72, 0x04,
2878 0xB0,
2879 0x6E, 0xDA, 0xC0, 0x61, 0xE6, 0x7A, 0x77, 0x25, 0xE8, 0x3B, 0xB9,
2880 0x5F,
2881 0x9A, 0xB6, 0xB5, 0xFE, 0x99, 0x0B, 0xA1, 0x93, 0x4E, 0x35, 0x33,
2882 0xB8,
2883 0xE1, 0xF1, 0x13, 0x4F, 0x59, 0x1A, 0xD2, 0x57, 0xC0, 0x26, 0x21,
2884 0x33,
2885 0x02, 0xC5, 0xAE, 0x23,
2886 };
2887 static unsigned char dh512_g[] = {
2888 0x02,
2889 };
2890 DH *dh;
2891 BIGNUM *p, *g;
2892
2893 if ((dh = DH_new()) == NULL)
2894 return (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)) {
2898 DH_free(dh);
2899 BN_free(p);
2900 BN_free(g);
2901 return (NULL);
2902 }
2903 return (dh);
2904 }
2905
2906 static DH *get_dh1024()
2907 {
2908 static unsigned char dh1024_p[] = {
2909 0xF8, 0x81, 0x89, 0x7D, 0x14, 0x24, 0xC5, 0xD1, 0xE6, 0xF7, 0xBF,
2910 0x3A,
2911 0xE4, 0x90, 0xF4, 0xFC, 0x73, 0xFB, 0x34, 0xB5, 0xFA, 0x4C, 0x56,
2912 0xA2,
2913 0xEA, 0xA7, 0xE9, 0xC0, 0xC0, 0xCE, 0x89, 0xE1, 0xFA, 0x63, 0x3F,
2914 0xB0,
2915 0x6B, 0x32, 0x66, 0xF1, 0xD1, 0x7B, 0xB0, 0x00, 0x8F, 0xCA, 0x87,
2916 0xC2,
2917 0xAE, 0x98, 0x89, 0x26, 0x17, 0xC2, 0x05, 0xD2, 0xEC, 0x08, 0xD0,
2918 0x8C,
2919 0xFF, 0x17, 0x52, 0x8C, 0xC5, 0x07, 0x93, 0x03, 0xB1, 0xF6, 0x2F,
2920 0xB8,
2921 0x1C, 0x52, 0x47, 0x27, 0x1B, 0xDB, 0xD1, 0x8D, 0x9D, 0x69, 0x1D,
2922 0x52,
2923 0x4B, 0x32, 0x81, 0xAA, 0x7F, 0x00, 0xC8, 0xDC, 0xE6, 0xD9, 0xCC,
2924 0xC1,
2925 0x11, 0x2D, 0x37, 0x34, 0x6C, 0xEA, 0x02, 0x97, 0x4B, 0x0E, 0xBB,
2926 0xB1,
2927 0x71, 0x33, 0x09, 0x15, 0xFD, 0xDD, 0x23, 0x87, 0x07, 0x5E, 0x89,
2928 0xAB,
2929 0x6B, 0x7C, 0x5F, 0xEC, 0xA6, 0x24, 0xDC, 0x53,
2930 };
2931 static unsigned char dh1024_g[] = {
2932 0x02,
2933 };
2934 DH *dh;
2935 BIGNUM *p, *g;
2936
2937 if ((dh = DH_new()) == NULL)
2938 return (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)) {
2942 DH_free(dh);
2943 BN_free(p);
2944 BN_free(g);
2945 return (NULL);
2946 }
2947 return (dh);
2948 }
2949
2950 static DH *get_dh1024dsa()
2951 {
2952 static unsigned char dh1024_p[] = {
2953 0xC8, 0x00, 0xF7, 0x08, 0x07, 0x89, 0x4D, 0x90, 0x53, 0xF3, 0xD5,
2954 0x00,
2955 0x21, 0x1B, 0xF7, 0x31, 0xA6, 0xA2, 0xDA, 0x23, 0x9A, 0xC7, 0x87,
2956 0x19,
2957 0x3B, 0x47, 0xB6, 0x8C, 0x04, 0x6F, 0xFF, 0xC6, 0x9B, 0xB8, 0x65,
2958 0xD2,
2959 0xC2, 0x5F, 0x31, 0x83, 0x4A, 0xA7, 0x5F, 0x2F, 0x88, 0x38, 0xB6,
2960 0x55,
2961 0xCF, 0xD9, 0x87, 0x6D, 0x6F, 0x9F, 0xDA, 0xAC, 0xA6, 0x48, 0xAF,
2962 0xFC,
2963 0x33, 0x84, 0x37, 0x5B, 0x82, 0x4A, 0x31, 0x5D, 0xE7, 0xBD, 0x52,
2964 0x97,
2965 0xA1, 0x77, 0xBF, 0x10, 0x9E, 0x37, 0xEA, 0x64, 0xFA, 0xCA, 0x28,
2966 0x8D,
2967 0x9D, 0x3B, 0xD2, 0x6E, 0x09, 0x5C, 0x68, 0xC7, 0x45, 0x90, 0xFD,
2968 0xBB,
2969 0x70, 0xC9, 0x3A, 0xBB, 0xDF, 0xD4, 0x21, 0x0F, 0xC4, 0x6A, 0x3C,
2970 0xF6,
2971 0x61, 0xCF, 0x3F, 0xD6, 0x13, 0xF1, 0x5F, 0xBC, 0xCF, 0xBC, 0x26,
2972 0x9E,
2973 0xBC, 0x0B, 0xBD, 0xAB, 0x5D, 0xC9, 0x54, 0x39,
2974 };
2975 static unsigned char dh1024_g[] = {
2976 0x3B, 0x40, 0x86, 0xE7, 0xF3, 0x6C, 0xDE, 0x67, 0x1C, 0xCC, 0x80,
2977 0x05,
2978 0x5A, 0xDF, 0xFE, 0xBD, 0x20, 0x27, 0x74, 0x6C, 0x24, 0xC9, 0x03,
2979 0xF3,
2980 0xE1, 0x8D, 0xC3, 0x7D, 0x98, 0x27, 0x40, 0x08, 0xB8, 0x8C, 0x6A,
2981 0xE9,
2982 0xBB, 0x1A, 0x3A, 0xD6, 0x86, 0x83, 0x5E, 0x72, 0x41, 0xCE, 0x85,
2983 0x3C,
2984 0xD2, 0xB3, 0xFC, 0x13, 0xCE, 0x37, 0x81, 0x9E, 0x4C, 0x1C, 0x7B,
2985 0x65,
2986 0xD3, 0xE6, 0xA6, 0x00, 0xF5, 0x5A, 0x95, 0x43, 0x5E, 0x81, 0xCF,
2987 0x60,
2988 0xA2, 0x23, 0xFC, 0x36, 0xA7, 0x5D, 0x7A, 0x4C, 0x06, 0x91, 0x6E,
2989 0xF6,
2990 0x57, 0xEE, 0x36, 0xCB, 0x06, 0xEA, 0xF5, 0x3D, 0x95, 0x49, 0xCB,
2991 0xA7,
2992 0xDD, 0x81, 0xDF, 0x80, 0x09, 0x4A, 0x97, 0x4D, 0xA8, 0x22, 0x72,
2993 0xA1,
2994 0x7F, 0xC4, 0x70, 0x56, 0x70, 0xE8, 0x20, 0x10, 0x18, 0x8F, 0x2E,
2995 0x60,
2996 0x07, 0xE7, 0x68, 0x1A, 0x82, 0x5D, 0x32, 0xA2,
2997 };
2998 DH *dh;
2999 BIGNUM *p, *g;
3000
3001 if ((dh = DH_new()) == NULL)
3002 return (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)) {
3006 DH_free(dh);
3007 BN_free(p);
3008 BN_free(g);
3009 return (NULL);
3010 }
3011 DH_set_length(dh, 160);
3012 return (dh);
3013 }
3014 #endif
3015
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)
3020 {
3021 int ret;
3022 BIGNUM *bn = NULL;
3023
3024 ret = BN_hex2bn(&bn, pskkey);
3025 if (!ret) {
3026 BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
3027 pskkey);
3028 BN_free(bn);
3029 return 0;
3030 }
3031 if (BN_num_bytes(bn) > (int)max_psk_len) {
3032 BIO_printf(bio_err,
3033 "psk buffer of callback is too small (%d) for key (%d)\n",
3034 max_psk_len, BN_num_bytes(bn));
3035 BN_free(bn);
3036 return 0;
3037 }
3038 ret = BN_bn2bin(bn, psk);
3039 BN_free(bn);
3040 return ret;
3041 }
3042
3043 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
3044 char *identity,
3045 unsigned int max_identity_len,
3046 unsigned char *psk,
3047 unsigned int max_psk_len)
3048 {
3049 int ret;
3050 unsigned int psk_len = 0;
3051
3052 ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3053 if (ret < 0)
3054 goto out_err;
3055 if (debug)
3056 fprintf(stderr, "client: created identity '%s' len=%d\n", identity,
3057 ret);
3058 ret = psk_key2bn(psk_key, psk, max_psk_len);
3059 if (ret < 0)
3060 goto out_err;
3061 psk_len = ret;
3062 out_err:
3063 return psk_len;
3064 }
3065
3066 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3067 unsigned char *psk,
3068 unsigned int max_psk_len)
3069 {
3070 unsigned int psk_len = 0;
3071
3072 if (strcmp(identity, "Client_identity") != 0) {
3073 BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3074 return 0;
3075 }
3076 psk_len = psk_key2bn(psk_key, psk, max_psk_len);
3077 return psk_len;
3078 }
3079 #endif
A mirror of the official openssl repository