]> 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
Implement EVP_MAC_do_all_ex()
[thirdparty/openssl.git] / test / ssltest_old.c
1 /*
2 * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
3 * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
4 * Copyright 2005 Nokia. All rights reserved.
5 *
6 * Licensed under the Apache License 2.0 (the "License"). You may not use
7 * this file except in compliance with the License. You can obtain a copy
8 * in the file LICENSE in the source distribution or at
9 * https://www.openssl.org/source/license.html
10 */
11
12 #include "e_os.h"
13
14 /* Or gethostname won't be declared properly on Linux and GNU platforms. */
15 #ifndef _BSD_SOURCE
16 # define _BSD_SOURCE 1
17 #endif
18 #ifndef _DEFAULT_SOURCE
19 # define _DEFAULT_SOURCE 1
20 #endif
21
22 #include <assert.h>
23 #include <errno.h>
24 #include <limits.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <time.h>
29
30 #include "internal/nelem.h"
31
32 #ifdef OPENSSL_SYS_VMS
33 /*
34 * Or isascii won't be declared properly on VMS (at least with DECompHP C).
35 */
36 # define _XOPEN_SOURCE 500
37 #endif
38
39 #include <ctype.h>
40
41 #include <openssl/bio.h>
42 #include <openssl/crypto.h>
43 #include <openssl/evp.h>
44 #include <openssl/x509.h>
45 #include <openssl/x509v3.h>
46 #include <openssl/ssl.h>
47 #include <openssl/err.h>
48 #include <openssl/rand.h>
49 #ifndef OPENSSL_NO_RSA
50 # include <openssl/rsa.h>
51 #endif
52 #ifndef OPENSSL_NO_DSA
53 # include <openssl/dsa.h>
54 #endif
55 #ifndef OPENSSL_NO_DH
56 # include <openssl/dh.h>
57 #endif
58 #include <openssl/bn.h>
59 #ifndef OPENSSL_NO_CT
60 # include <openssl/ct.h>
61 #endif
62
63 /*
64 * Or gethostname won't be declared properly
65 * on Compaq platforms (at least with DEC C).
66 * Do not try to put it earlier, or IPv6 includes
67 * get screwed...
68 */
69 #define _XOPEN_SOURCE_EXTENDED 1
70
71 #ifdef OPENSSL_SYS_WINDOWS
72 # include <winsock.h>
73 #else
74 # include <unistd.h>
75 #endif
76
77 static SSL_CTX *s_ctx = NULL;
78 static SSL_CTX *s_ctx2 = NULL;
79
80 /*
81 * There is really no standard for this, so let's assign something
82 * only for this test
83 */
84 #define COMP_ZLIB 1
85
86 static int verify_callback(int ok, X509_STORE_CTX *ctx);
87 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg);
88 #define APP_CALLBACK_STRING "Test Callback Argument"
89 struct app_verify_arg {
90 char *string;
91 int app_verify;
92 };
93
94 #ifndef OPENSSL_NO_DH
95 static DH *get_dh512(void);
96 static DH *get_dh1024(void);
97 static DH *get_dh1024dsa(void);
98 #endif
99
100 static char *psk_key = NULL; /* by default PSK is not used */
101 #ifndef OPENSSL_NO_PSK
102 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
103 char *identity,
104 unsigned int max_identity_len,
105 unsigned char *psk,
106 unsigned int max_psk_len);
107 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
108 unsigned char *psk,
109 unsigned int max_psk_len);
110 #endif
111
112 static BIO *bio_err = NULL;
113 static BIO *bio_stdout = NULL;
114
115 #ifndef OPENSSL_NO_NEXTPROTONEG
116 /* Note that this code assumes that this is only a one element list: */
117 static const char NEXT_PROTO_STRING[] = "\x09testproto";
118 static int npn_client = 0;
119 static int npn_server = 0;
120 static int npn_server_reject = 0;
121
122 static int cb_client_npn(SSL *s, unsigned char **out, unsigned char *outlen,
123 const unsigned char *in, unsigned int inlen,
124 void *arg)
125 {
126 /*
127 * This callback only returns the protocol string, rather than a length
128 * prefixed set. We assume that NEXT_PROTO_STRING is a one element list
129 * and remove the first byte to chop off the length prefix.
130 */
131 *out = (unsigned char *)NEXT_PROTO_STRING + 1;
132 *outlen = sizeof(NEXT_PROTO_STRING) - 2;
133 return SSL_TLSEXT_ERR_OK;
134 }
135
136 static int cb_server_npn(SSL *s, const unsigned char **data,
137 unsigned int *len, void *arg)
138 {
139 *data = (const unsigned char *)NEXT_PROTO_STRING;
140 *len = sizeof(NEXT_PROTO_STRING) - 1;
141 return SSL_TLSEXT_ERR_OK;
142 }
143
144 static int cb_server_rejects_npn(SSL *s, const unsigned char **data,
145 unsigned int *len, void *arg)
146 {
147 return SSL_TLSEXT_ERR_NOACK;
148 }
149
150 static int verify_npn(SSL *client, SSL *server)
151 {
152 const unsigned char *client_s;
153 unsigned client_len;
154 const unsigned char *server_s;
155 unsigned server_len;
156
157 SSL_get0_next_proto_negotiated(client, &client_s, &client_len);
158 SSL_get0_next_proto_negotiated(server, &server_s, &server_len);
159
160 if (client_len) {
161 BIO_printf(bio_stdout, "Client NPN: ");
162 BIO_write(bio_stdout, client_s, client_len);
163 BIO_printf(bio_stdout, "\n");
164 }
165
166 if (server_len) {
167 BIO_printf(bio_stdout, "Server NPN: ");
168 BIO_write(bio_stdout, server_s, server_len);
169 BIO_printf(bio_stdout, "\n");
170 }
171
172 /*
173 * If an NPN string was returned, it must be the protocol that we
174 * expected to negotiate.
175 */
176 if (client_len && (client_len != sizeof(NEXT_PROTO_STRING) - 2 ||
177 memcmp(client_s, NEXT_PROTO_STRING + 1, client_len)))
178 return -1;
179 if (server_len && (server_len != sizeof(NEXT_PROTO_STRING) - 2 ||
180 memcmp(server_s, NEXT_PROTO_STRING + 1, server_len)))
181 return -1;
182
183 if (!npn_client && client_len)
184 return -1;
185 if (!npn_server && server_len)
186 return -1;
187 if (npn_server_reject && server_len)
188 return -1;
189 if (npn_client && npn_server && (!client_len || !server_len))
190 return -1;
191
192 return 0;
193 }
194 #endif
195
196 static const char *alpn_client;
197 static char *alpn_server;
198 static char *alpn_server2;
199 static const char *alpn_expected;
200 static unsigned char *alpn_selected;
201 static const char *server_min_proto;
202 static const char *server_max_proto;
203 static const char *client_min_proto;
204 static const char *client_max_proto;
205 static const char *should_negotiate;
206 static const char *sn_client;
207 static const char *sn_server1;
208 static const char *sn_server2;
209 static int sn_expect = 0;
210 static const char *server_sess_out;
211 static const char *server_sess_in;
212 static const char *client_sess_out;
213 static const char *client_sess_in;
214 static SSL_SESSION *server_sess;
215 static SSL_SESSION *client_sess;
216
217 static int servername_cb(SSL *s, int *ad, void *arg)
218 {
219 const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
220 if (sn_server2 == NULL) {
221 BIO_printf(bio_stdout, "Servername 2 is NULL\n");
222 return SSL_TLSEXT_ERR_NOACK;
223 }
224
225 if (servername) {
226 if (s_ctx2 != NULL && sn_server2 != NULL &&
227 !strcasecmp(servername, sn_server2)) {
228 BIO_printf(bio_stdout, "Switching server context.\n");
229 SSL_set_SSL_CTX(s, s_ctx2);
230 }
231 }
232 return SSL_TLSEXT_ERR_OK;
233 }
234 static int verify_servername(SSL *client, SSL *server)
235 {
236 /* just need to see if sn_context is what we expect */
237 SSL_CTX* ctx = SSL_get_SSL_CTX(server);
238 if (sn_expect == 0)
239 return 0;
240 if (sn_expect == 1 && ctx == s_ctx)
241 return 0;
242 if (sn_expect == 2 && ctx == s_ctx2)
243 return 0;
244 BIO_printf(bio_stdout, "Servername: expected context %d\n", sn_expect);
245 if (ctx == s_ctx2)
246 BIO_printf(bio_stdout, "Servername: context is 2\n");
247 else if (ctx == s_ctx)
248 BIO_printf(bio_stdout, "Servername: context is 1\n");
249 else
250 BIO_printf(bio_stdout, "Servername: context is unknown\n");
251 return -1;
252 }
253
254
255 /*-
256 * next_protos_parse parses a comma separated list of strings into a string
257 * in a format suitable for passing to SSL_CTX_set_next_protos_advertised.
258 * outlen: (output) set to the length of the resulting buffer on success.
259 * in: a NUL terminated string like "abc,def,ghi"
260 *
261 * returns: a malloced buffer or NULL on failure.
262 */
263 static unsigned char *next_protos_parse(size_t *outlen,
264 const char *in)
265 {
266 size_t len;
267 unsigned char *out;
268 size_t i, start = 0;
269
270 len = strlen(in);
271 if (len >= 65535)
272 return NULL;
273
274 out = OPENSSL_malloc(strlen(in) + 1);
275 if (!out)
276 return NULL;
277
278 for (i = 0; i <= len; ++i) {
279 if (i == len || in[i] == ',') {
280 if (i - start > 255) {
281 OPENSSL_free(out);
282 return NULL;
283 }
284 out[start] = (unsigned char)(i - start);
285 start = i + 1;
286 } else
287 out[i + 1] = in[i];
288 }
289
290 *outlen = len + 1;
291 return out;
292 }
293
294 static int cb_server_alpn(SSL *s, const unsigned char **out,
295 unsigned char *outlen, const unsigned char *in,
296 unsigned int inlen, void *arg)
297 {
298 unsigned char *protos;
299 size_t protos_len;
300 char* alpn_str = arg;
301
302 protos = next_protos_parse(&protos_len, alpn_str);
303 if (protos == NULL) {
304 fprintf(stderr, "failed to parser ALPN server protocol string: %s\n",
305 alpn_str);
306 abort();
307 }
308
309 if (SSL_select_next_proto
310 ((unsigned char **)out, outlen, protos, protos_len, in,
311 inlen) != OPENSSL_NPN_NEGOTIATED) {
312 OPENSSL_free(protos);
313 return SSL_TLSEXT_ERR_NOACK;
314 }
315
316 /*
317 * Make a copy of the selected protocol which will be freed in
318 * verify_alpn.
319 */
320 alpn_selected = OPENSSL_malloc(*outlen);
321 memcpy(alpn_selected, *out, *outlen);
322 *out = alpn_selected;
323
324 OPENSSL_free(protos);
325 return SSL_TLSEXT_ERR_OK;
326 }
327
328 static int verify_alpn(SSL *client, SSL *server)
329 {
330 const unsigned char *client_proto, *server_proto;
331 unsigned int client_proto_len = 0, server_proto_len = 0;
332 SSL_get0_alpn_selected(client, &client_proto, &client_proto_len);
333 SSL_get0_alpn_selected(server, &server_proto, &server_proto_len);
334
335 OPENSSL_free(alpn_selected);
336 alpn_selected = NULL;
337
338 if (client_proto_len != server_proto_len) {
339 BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");
340 goto err;
341 }
342
343 if (client_proto != NULL &&
344 memcmp(client_proto, server_proto, client_proto_len) != 0) {
345 BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");
346 goto err;
347 }
348
349 if (client_proto_len > 0 && alpn_expected == NULL) {
350 BIO_printf(bio_stdout, "ALPN unexpectedly negotiated\n");
351 goto err;
352 }
353
354 if (alpn_expected != NULL &&
355 (client_proto_len != strlen(alpn_expected) ||
356 memcmp(client_proto, alpn_expected, client_proto_len) != 0)) {
357 BIO_printf(bio_stdout,
358 "ALPN selected protocols not equal to expected protocol: %s\n",
359 alpn_expected);
360 goto err;
361 }
362
363 return 0;
364
365 err:
366 BIO_printf(bio_stdout, "ALPN results: client: '");
367 BIO_write(bio_stdout, client_proto, client_proto_len);
368 BIO_printf(bio_stdout, "', server: '");
369 BIO_write(bio_stdout, server_proto, server_proto_len);
370 BIO_printf(bio_stdout, "'\n");
371 BIO_printf(bio_stdout, "ALPN configured: client: '%s', server: '",
372 alpn_client);
373 if (SSL_get_SSL_CTX(server) == s_ctx2) {
374 BIO_printf(bio_stdout, "%s'\n",
375 alpn_server2);
376 } else {
377 BIO_printf(bio_stdout, "%s'\n",
378 alpn_server);
379 }
380 return -1;
381 }
382
383 /*
384 * WARNING : below extension types are *NOT* IETF assigned, and could
385 * conflict if these types are reassigned and handled specially by OpenSSL
386 * in the future
387 */
388 #define TACK_EXT_TYPE 62208
389 #define CUSTOM_EXT_TYPE_0 1000
390 #define CUSTOM_EXT_TYPE_1 1001
391 #define CUSTOM_EXT_TYPE_2 1002
392 #define CUSTOM_EXT_TYPE_3 1003
393
394 static const char custom_ext_cli_string[] = "abc";
395 static const char custom_ext_srv_string[] = "defg";
396
397 /* These set from cmdline */
398 static char *serverinfo_file = NULL;
399 static int serverinfo_sct = 0;
400 static int serverinfo_tack = 0;
401
402 /* These set based on extension callbacks */
403 static int serverinfo_sct_seen = 0;
404 static int serverinfo_tack_seen = 0;
405 static int serverinfo_other_seen = 0;
406
407 /* This set from cmdline */
408 static int custom_ext = 0;
409
410 /* This set based on extension callbacks */
411 static int custom_ext_error = 0;
412
413 static int serverinfo_cli_parse_cb(SSL *s, unsigned int ext_type,
414 const unsigned char *in, size_t inlen,
415 int *al, void *arg)
416 {
417 if (ext_type == TLSEXT_TYPE_signed_certificate_timestamp)
418 serverinfo_sct_seen++;
419 else if (ext_type == TACK_EXT_TYPE)
420 serverinfo_tack_seen++;
421 else
422 serverinfo_other_seen++;
423 return 1;
424 }
425
426 static int verify_serverinfo(void)
427 {
428 if (serverinfo_sct != serverinfo_sct_seen)
429 return -1;
430 if (serverinfo_tack != serverinfo_tack_seen)
431 return -1;
432 if (serverinfo_other_seen)
433 return -1;
434 return 0;
435 }
436
437 /*-
438 * Four test cases for custom extensions:
439 * 0 - no ClientHello extension or ServerHello response
440 * 1 - ClientHello with "abc", no response
441 * 2 - ClientHello with "abc", empty response
442 * 3 - ClientHello with "abc", "defg" response
443 */
444
445 static int custom_ext_0_cli_add_cb(SSL *s, unsigned int ext_type,
446 const unsigned char **out,
447 size_t *outlen, int *al, void *arg)
448 {
449 if (ext_type != CUSTOM_EXT_TYPE_0)
450 custom_ext_error = 1;
451 return 0; /* Don't send an extension */
452 }
453
454 static int custom_ext_0_cli_parse_cb(SSL *s, unsigned int ext_type,
455 const unsigned char *in,
456 size_t inlen, int *al, void *arg)
457 {
458 return 1;
459 }
460
461 static int custom_ext_1_cli_add_cb(SSL *s, unsigned int ext_type,
462 const unsigned char **out,
463 size_t *outlen, int *al, void *arg)
464 {
465 if (ext_type != CUSTOM_EXT_TYPE_1)
466 custom_ext_error = 1;
467 *out = (const unsigned char *)custom_ext_cli_string;
468 *outlen = strlen(custom_ext_cli_string);
469 return 1; /* Send "abc" */
470 }
471
472 static int custom_ext_1_cli_parse_cb(SSL *s, unsigned int ext_type,
473 const unsigned char *in,
474 size_t inlen, int *al, void *arg)
475 {
476 return 1;
477 }
478
479 static int custom_ext_2_cli_add_cb(SSL *s, unsigned int ext_type,
480 const unsigned char **out,
481 size_t *outlen, int *al, void *arg)
482 {
483 if (ext_type != CUSTOM_EXT_TYPE_2)
484 custom_ext_error = 1;
485 *out = (const unsigned char *)custom_ext_cli_string;
486 *outlen = strlen(custom_ext_cli_string);
487 return 1; /* Send "abc" */
488 }
489
490 static int custom_ext_2_cli_parse_cb(SSL *s, unsigned int ext_type,
491 const unsigned char *in,
492 size_t inlen, int *al, void *arg)
493 {
494 if (ext_type != CUSTOM_EXT_TYPE_2)
495 custom_ext_error = 1;
496 if (inlen != 0)
497 custom_ext_error = 1; /* Should be empty response */
498 return 1;
499 }
500
501 static int custom_ext_3_cli_add_cb(SSL *s, unsigned int ext_type,
502 const unsigned char **out,
503 size_t *outlen, int *al, void *arg)
504 {
505 if (ext_type != CUSTOM_EXT_TYPE_3)
506 custom_ext_error = 1;
507 *out = (const unsigned char *)custom_ext_cli_string;
508 *outlen = strlen(custom_ext_cli_string);
509 return 1; /* Send "abc" */
510 }
511
512 static int custom_ext_3_cli_parse_cb(SSL *s, unsigned int ext_type,
513 const unsigned char *in,
514 size_t inlen, int *al, void *arg)
515 {
516 if (ext_type != CUSTOM_EXT_TYPE_3)
517 custom_ext_error = 1;
518 if (inlen != strlen(custom_ext_srv_string))
519 custom_ext_error = 1;
520 if (memcmp(custom_ext_srv_string, in, inlen) != 0)
521 custom_ext_error = 1; /* Check for "defg" */
522 return 1;
523 }
524
525 /*
526 * custom_ext_0_cli_add_cb returns 0 - the server won't receive a callback
527 * for this extension
528 */
529 static int custom_ext_0_srv_parse_cb(SSL *s, unsigned int ext_type,
530 const unsigned char *in,
531 size_t inlen, int *al, void *arg)
532 {
533 custom_ext_error = 1;
534 return 1;
535 }
536
537 /* 'add' callbacks are only called if the 'parse' callback is called */
538 static int custom_ext_0_srv_add_cb(SSL *s, unsigned int ext_type,
539 const unsigned char **out,
540 size_t *outlen, int *al, void *arg)
541 {
542 /* Error: should not have been called */
543 custom_ext_error = 1;
544 return 0; /* Don't send an extension */
545 }
546
547 static int custom_ext_1_srv_parse_cb(SSL *s, unsigned int ext_type,
548 const unsigned char *in,
549 size_t inlen, int *al, void *arg)
550 {
551 if (ext_type != CUSTOM_EXT_TYPE_1)
552 custom_ext_error = 1;
553 /* Check for "abc" */
554 if (inlen != strlen(custom_ext_cli_string))
555 custom_ext_error = 1;
556 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
557 custom_ext_error = 1;
558 return 1;
559 }
560
561 static int custom_ext_1_srv_add_cb(SSL *s, unsigned int ext_type,
562 const unsigned char **out,
563 size_t *outlen, int *al, void *arg)
564 {
565 return 0; /* Don't send an extension */
566 }
567
568 static int custom_ext_2_srv_parse_cb(SSL *s, unsigned int ext_type,
569 const unsigned char *in,
570 size_t inlen, int *al, void *arg)
571 {
572 if (ext_type != CUSTOM_EXT_TYPE_2)
573 custom_ext_error = 1;
574 /* Check for "abc" */
575 if (inlen != strlen(custom_ext_cli_string))
576 custom_ext_error = 1;
577 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
578 custom_ext_error = 1;
579 return 1;
580 }
581
582 static int custom_ext_2_srv_add_cb(SSL *s, unsigned int ext_type,
583 const unsigned char **out,
584 size_t *outlen, int *al, void *arg)
585 {
586 *out = NULL;
587 *outlen = 0;
588 return 1; /* Send empty extension */
589 }
590
591 static int custom_ext_3_srv_parse_cb(SSL *s, unsigned int ext_type,
592 const unsigned char *in,
593 size_t inlen, int *al, void *arg)
594 {
595 if (ext_type != CUSTOM_EXT_TYPE_3)
596 custom_ext_error = 1;
597 /* Check for "abc" */
598 if (inlen != strlen(custom_ext_cli_string))
599 custom_ext_error = 1;
600 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
601 custom_ext_error = 1;
602 return 1;
603 }
604
605 static int custom_ext_3_srv_add_cb(SSL *s, unsigned int ext_type,
606 const unsigned char **out,
607 size_t *outlen, int *al, void *arg)
608 {
609 *out = (const unsigned char *)custom_ext_srv_string;
610 *outlen = strlen(custom_ext_srv_string);
611 return 1; /* Send "defg" */
612 }
613
614 static char *cipher = NULL;
615 static char *ciphersuites = NULL;
616 static int verbose = 0;
617 static int debug = 0;
618
619 int doit_localhost(SSL *s_ssl, SSL *c_ssl, int family,
620 long bytes, clock_t *s_time, clock_t *c_time);
621 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long bytes, clock_t *s_time,
622 clock_t *c_time);
623 int doit(SSL *s_ssl, SSL *c_ssl, long bytes);
624
625 static void sv_usage(void)
626 {
627 fprintf(stderr, "usage: ssltest [args ...]\n");
628 fprintf(stderr, "\n");
629 fprintf(stderr, " -server_auth - check server certificate\n");
630 fprintf(stderr, " -client_auth - do client authentication\n");
631 fprintf(stderr, " -v - more output\n");
632 fprintf(stderr, " -d - debug output\n");
633 fprintf(stderr, " -reuse - use session-id reuse\n");
634 fprintf(stderr, " -num <val> - number of connections to perform\n");
635 fprintf(stderr,
636 " -bytes <val> - number of bytes to swap between client/server\n");
637 #ifndef OPENSSL_NO_DH
638 fprintf(stderr,
639 " -dhe512 - use 512 bit key for DHE (to test failure)\n");
640 fprintf(stderr,
641 " -dhe1024 - use 1024 bit key (safe prime) for DHE (default, no-op)\n");
642 fprintf(stderr,
643 " -dhe1024dsa - use 1024 bit key (with 160-bit subprime) for DHE\n");
644 fprintf(stderr, " -no_dhe - disable DHE\n");
645 #endif
646 #ifndef OPENSSL_NO_EC
647 fprintf(stderr, " -no_ecdhe - disable ECDHE\nTODO(openssl-team): no_ecdhe was broken by auto ecdh. Make this work again.\n");
648 #endif
649 #ifndef OPENSSL_NO_PSK
650 fprintf(stderr, " -psk arg - PSK in hex (without 0x)\n");
651 #endif
652 #ifndef OPENSSL_NO_SSL3
653 fprintf(stderr, " -ssl3 - use SSLv3\n");
654 #endif
655 #ifndef OPENSSL_NO_TLS1
656 fprintf(stderr, " -tls1 - use TLSv1\n");
657 #endif
658 #ifndef OPENSSL_NO_DTLS
659 fprintf(stderr, " -dtls - use DTLS\n");
660 #ifndef OPENSSL_NO_DTLS1
661 fprintf(stderr, " -dtls1 - use DTLSv1\n");
662 #endif
663 #ifndef OPENSSL_NO_DTLS1_2
664 fprintf(stderr, " -dtls12 - use DTLSv1.2\n");
665 #endif
666 #endif
667 fprintf(stderr, " -CApath arg - PEM format directory of CA's\n");
668 fprintf(stderr, " -CAfile arg - PEM format file of CA's\n");
669 fprintf(stderr, " -cert arg - Server certificate file\n");
670 fprintf(stderr,
671 " -key arg - Server key file (default: same as -cert)\n");
672 fprintf(stderr, " -c_cert arg - Client certificate file\n");
673 fprintf(stderr,
674 " -c_key arg - Client key file (default: same as -c_cert)\n");
675 fprintf(stderr, " -cipher arg - The TLSv1.2 and below cipher list\n");
676 fprintf(stderr, " -ciphersuites arg - The TLSv1.3 ciphersuites\n");
677 fprintf(stderr, " -bio_pair - Use BIO pairs\n");
678 fprintf(stderr, " -ipv4 - Use IPv4 connection on localhost\n");
679 fprintf(stderr, " -ipv6 - Use IPv6 connection on localhost\n");
680 fprintf(stderr, " -f - Test even cases that can't work\n");
681 fprintf(stderr,
682 " -time - measure processor time used by client and server\n");
683 fprintf(stderr, " -zlib - use zlib compression\n");
684 #ifndef OPENSSL_NO_NEXTPROTONEG
685 fprintf(stderr, " -npn_client - have client side offer NPN\n");
686 fprintf(stderr, " -npn_server - have server side offer NPN\n");
687 fprintf(stderr, " -npn_server_reject - have server reject NPN\n");
688 #endif
689 fprintf(stderr, " -serverinfo_file file - have server use this file\n");
690 fprintf(stderr, " -serverinfo_sct - have client offer and expect SCT\n");
691 fprintf(stderr,
692 " -serverinfo_tack - have client offer and expect TACK\n");
693 fprintf(stderr,
694 " -custom_ext - try various custom extension callbacks\n");
695 fprintf(stderr, " -alpn_client <string> - have client side offer ALPN\n");
696 fprintf(stderr, " -alpn_server <string> - have server side offer ALPN\n");
697 fprintf(stderr, " -alpn_server1 <string> - alias for -alpn_server\n");
698 fprintf(stderr, " -alpn_server2 <string> - have server side context 2 offer ALPN\n");
699 fprintf(stderr,
700 " -alpn_expected <string> - the ALPN protocol that should be negotiated\n");
701 fprintf(stderr, " -server_min_proto <string> - Minimum version the server should support\n");
702 fprintf(stderr, " -server_max_proto <string> - Maximum version the server should support\n");
703 fprintf(stderr, " -client_min_proto <string> - Minimum version the client should support\n");
704 fprintf(stderr, " -client_max_proto <string> - Maximum version the client should support\n");
705 fprintf(stderr, " -should_negotiate <string> - The version that should be negotiated, fail-client or fail-server\n");
706 #ifndef OPENSSL_NO_CT
707 fprintf(stderr, " -noct - no certificate transparency\n");
708 fprintf(stderr, " -requestct - request certificate transparency\n");
709 fprintf(stderr, " -requirect - require certificate transparency\n");
710 #endif
711 fprintf(stderr, " -sn_client <string> - have client request this servername\n");
712 fprintf(stderr, " -sn_server1 <string> - have server context 1 respond to this servername\n");
713 fprintf(stderr, " -sn_server2 <string> - have server context 2 respond to this servername\n");
714 fprintf(stderr, " -sn_expect1 - expected server 1\n");
715 fprintf(stderr, " -sn_expect2 - expected server 2\n");
716 fprintf(stderr, " -server_sess_out <file> - Save the server session to a file\n");
717 fprintf(stderr, " -server_sess_in <file> - Read the server session from a file\n");
718 fprintf(stderr, " -client_sess_out <file> - Save the client session to a file\n");
719 fprintf(stderr, " -client_sess_in <file> - Read the client session from a file\n");
720 fprintf(stderr, " -should_reuse <number> - The expected state of reusing the session\n");
721 fprintf(stderr, " -no_ticket - do not issue TLS session ticket\n");
722 }
723
724 static void print_key_details(BIO *out, EVP_PKEY *key)
725 {
726 int keyid = EVP_PKEY_id(key);
727 #ifndef OPENSSL_NO_EC
728 if (keyid == EVP_PKEY_EC) {
729 EC_KEY *ec = EVP_PKEY_get1_EC_KEY(key);
730 int nid;
731 const char *cname;
732 nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
733 EC_KEY_free(ec);
734 cname = EC_curve_nid2nist(nid);
735 if (!cname)
736 cname = OBJ_nid2sn(nid);
737 BIO_printf(out, "%d bits EC (%s)", EVP_PKEY_bits(key), cname);
738 } else
739 #endif
740 {
741 const char *algname;
742 switch (keyid) {
743 case EVP_PKEY_RSA:
744 algname = "RSA";
745 break;
746 case EVP_PKEY_DSA:
747 algname = "DSA";
748 break;
749 case EVP_PKEY_DH:
750 algname = "DH";
751 break;
752 default:
753 algname = OBJ_nid2sn(keyid);
754 break;
755 }
756 BIO_printf(out, "%d bits %s", EVP_PKEY_bits(key), algname);
757 }
758 }
759
760 static void print_details(SSL *c_ssl, const char *prefix)
761 {
762 const SSL_CIPHER *ciph;
763 int mdnid;
764 X509 *cert;
765 EVP_PKEY *pkey;
766
767 ciph = SSL_get_current_cipher(c_ssl);
768 BIO_printf(bio_stdout, "%s%s, cipher %s %s",
769 prefix,
770 SSL_get_version(c_ssl),
771 SSL_CIPHER_get_version(ciph), SSL_CIPHER_get_name(ciph));
772 cert = SSL_get_peer_certificate(c_ssl);
773 if (cert != NULL) {
774 EVP_PKEY* pubkey = X509_get0_pubkey(cert);
775
776 if (pubkey != NULL) {
777 BIO_puts(bio_stdout, ", ");
778 print_key_details(bio_stdout, pubkey);
779 }
780 X509_free(cert);
781 }
782 if (SSL_get_peer_tmp_key(c_ssl, &pkey)) {
783 BIO_puts(bio_stdout, ", temp key: ");
784 print_key_details(bio_stdout, pkey);
785 EVP_PKEY_free(pkey);
786 }
787 if (SSL_get_peer_signature_nid(c_ssl, &mdnid))
788 BIO_printf(bio_stdout, ", digest=%s", OBJ_nid2sn(mdnid));
789 BIO_printf(bio_stdout, "\n");
790 }
791
792 /*
793 * protocol_from_string - converts a protocol version string to a number
794 *
795 * Returns -1 on failure or the version on success
796 */
797 static int protocol_from_string(const char *value)
798 {
799 struct protocol_versions {
800 const char *name;
801 int version;
802 };
803 static const struct protocol_versions versions[] = {
804 {"ssl3", SSL3_VERSION},
805 {"tls1", TLS1_VERSION},
806 {"tls1.1", TLS1_1_VERSION},
807 {"tls1.2", TLS1_2_VERSION},
808 {"tls1.3", TLS1_3_VERSION},
809 {"dtls1", DTLS1_VERSION},
810 {"dtls1.2", DTLS1_2_VERSION}};
811 size_t i;
812 size_t n = OSSL_NELEM(versions);
813
814 for (i = 0; i < n; i++)
815 if (strcmp(versions[i].name, value) == 0)
816 return versions[i].version;
817 return -1;
818 }
819
820 static SSL_SESSION *read_session(const char *filename)
821 {
822 SSL_SESSION *sess;
823 BIO *f = BIO_new_file(filename, "r");
824
825 if (f == NULL) {
826 BIO_printf(bio_err, "Can't open session file %s\n", filename);
827 ERR_print_errors(bio_err);
828 return NULL;
829 }
830 sess = PEM_read_bio_SSL_SESSION(f, NULL, 0, NULL);
831 if (sess == NULL) {
832 BIO_printf(bio_err, "Can't parse session file %s\n", filename);
833 ERR_print_errors(bio_err);
834 }
835 BIO_free(f);
836 return sess;
837 }
838
839 static int write_session(const char *filename, SSL_SESSION *sess)
840 {
841 BIO *f = BIO_new_file(filename, "w");
842
843 if (sess == NULL) {
844 BIO_printf(bio_err, "No session information\n");
845 return 0;
846 }
847 if (f == NULL) {
848 BIO_printf(bio_err, "Can't open session file %s\n", filename);
849 ERR_print_errors(bio_err);
850 return 0;
851 }
852 PEM_write_bio_SSL_SESSION(f, sess);
853 BIO_free(f);
854 return 1;
855 }
856
857 /*
858 * set_protocol_version - Sets protocol version minimum or maximum
859 *
860 * Returns 0 on failure and 1 on success
861 */
862 static int set_protocol_version(const char *version, SSL *ssl, int setting)
863 {
864 if (version != NULL) {
865 int ver = protocol_from_string(version);
866 if (ver < 0) {
867 BIO_printf(bio_err, "Error parsing: %s\n", version);
868 return 0;
869 }
870 return SSL_ctrl(ssl, setting, ver, NULL);
871 }
872 return 1;
873 }
874
875 int main(int argc, char *argv[])
876 {
877 const char *CApath = NULL, *CAfile = NULL;
878 int badop = 0;
879 enum { BIO_MEM, BIO_PAIR, BIO_IPV4, BIO_IPV6 } bio_type = BIO_MEM;
880 int force = 0;
881 int dtls1 = 0, dtls12 = 0, dtls = 0, tls1 = 0, tls1_2 = 0, ssl3 = 0;
882 int ret = EXIT_FAILURE;
883 int client_auth = 0;
884 int server_auth = 0, i;
885 struct app_verify_arg app_verify_arg =
886 { APP_CALLBACK_STRING, 0 };
887 char *p;
888 SSL_CTX *c_ctx = NULL;
889 const SSL_METHOD *meth = NULL;
890 SSL *c_ssl, *s_ssl;
891 int number = 1, reuse = 0;
892 int should_reuse = -1;
893 int no_ticket = 0;
894 long bytes = 256L;
895 #ifndef OPENSSL_NO_DH
896 DH *dh;
897 int dhe512 = 0, dhe1024dsa = 0;
898 #endif
899 int no_dhe = 0;
900 int no_psk = 0;
901 int print_time = 0;
902 clock_t s_time = 0, c_time = 0;
903 #ifndef OPENSSL_NO_COMP
904 int n, comp = 0;
905 COMP_METHOD *cm = NULL;
906 STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
907 #endif
908 int no_protocol;
909 int min_version = 0, max_version = 0;
910 #ifndef OPENSSL_NO_CT
911 /*
912 * Disable CT validation by default, because it will interfere with
913 * anything using custom extension handlers to deal with SCT extensions.
914 */
915 int ct_validation = 0;
916 #endif
917 SSL_CONF_CTX *s_cctx = NULL, *c_cctx = NULL, *s_cctx2 = NULL;
918 STACK_OF(OPENSSL_STRING) *conf_args = NULL;
919 char *arg = NULL, *argn = NULL;
920
921 verbose = 0;
922 debug = 0;
923
924 bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
925
926 p = getenv("OPENSSL_DEBUG_MEMORY");
927 if (p != NULL && strcmp(p, "on") == 0)
928 CRYPTO_set_mem_debug(1);
929 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
930
931 bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);
932
933 s_cctx = SSL_CONF_CTX_new();
934 s_cctx2 = SSL_CONF_CTX_new();
935 c_cctx = SSL_CONF_CTX_new();
936
937 if (!s_cctx || !c_cctx || !s_cctx2) {
938 ERR_print_errors(bio_err);
939 goto end;
940 }
941
942 SSL_CONF_CTX_set_flags(s_cctx,
943 SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_SERVER |
944 SSL_CONF_FLAG_CERTIFICATE |
945 SSL_CONF_FLAG_REQUIRE_PRIVATE);
946 SSL_CONF_CTX_set_flags(s_cctx2,
947 SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_SERVER |
948 SSL_CONF_FLAG_CERTIFICATE |
949 SSL_CONF_FLAG_REQUIRE_PRIVATE);
950 if (!SSL_CONF_CTX_set1_prefix(s_cctx, "-s_")) {
951 ERR_print_errors(bio_err);
952 goto end;
953 }
954 if (!SSL_CONF_CTX_set1_prefix(s_cctx2, "-s_")) {
955 ERR_print_errors(bio_err);
956 goto end;
957 }
958
959 SSL_CONF_CTX_set_flags(c_cctx,
960 SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_CLIENT |
961 SSL_CONF_FLAG_CERTIFICATE |
962 SSL_CONF_FLAG_REQUIRE_PRIVATE);
963 if (!SSL_CONF_CTX_set1_prefix(c_cctx, "-c_")) {
964 ERR_print_errors(bio_err);
965 goto end;
966 }
967
968 argc--;
969 argv++;
970
971 while (argc >= 1) {
972 if (strcmp(*argv, "-F") == 0) {
973 fprintf(stderr,
974 "not compiled with FIPS support, so exiting without running.\n");
975 EXIT(0);
976 } else if (strcmp(*argv, "-server_auth") == 0)
977 server_auth = 1;
978 else if (strcmp(*argv, "-client_auth") == 0)
979 client_auth = 1;
980 else if (strcmp(*argv, "-v") == 0)
981 verbose = 1;
982 else if (strcmp(*argv, "-d") == 0)
983 debug = 1;
984 else if (strcmp(*argv, "-reuse") == 0)
985 reuse = 1;
986 else if (strcmp(*argv, "-dhe512") == 0) {
987 #ifndef OPENSSL_NO_DH
988 dhe512 = 1;
989 #else
990 fprintf(stderr,
991 "ignoring -dhe512, since I'm compiled without DH\n");
992 #endif
993 } else if (strcmp(*argv, "-dhe1024dsa") == 0) {
994 #ifndef OPENSSL_NO_DH
995 dhe1024dsa = 1;
996 #else
997 fprintf(stderr,
998 "ignoring -dhe1024dsa, since I'm compiled without DH\n");
999 #endif
1000 } else if (strcmp(*argv, "-no_dhe") == 0)
1001 no_dhe = 1;
1002 else if (strcmp(*argv, "-no_ecdhe") == 0)
1003 /* obsolete */;
1004 else if (strcmp(*argv, "-psk") == 0) {
1005 if (--argc < 1)
1006 goto bad;
1007 psk_key = *(++argv);
1008 #ifndef OPENSSL_NO_PSK
1009 if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key)) {
1010 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
1011 goto bad;
1012 }
1013 #else
1014 no_psk = 1;
1015 #endif
1016 }
1017 else if (strcmp(*argv, "-tls1_2") == 0) {
1018 tls1_2 = 1;
1019 } else if (strcmp(*argv, "-tls1") == 0) {
1020 tls1 = 1;
1021 } else if (strcmp(*argv, "-ssl3") == 0) {
1022 ssl3 = 1;
1023 } else if (strcmp(*argv, "-dtls1") == 0) {
1024 dtls1 = 1;
1025 } else if (strcmp(*argv, "-dtls12") == 0) {
1026 dtls12 = 1;
1027 } else if (strcmp(*argv, "-dtls") == 0) {
1028 dtls = 1;
1029 } else if (strncmp(*argv, "-num", 4) == 0) {
1030 if (--argc < 1)
1031 goto bad;
1032 number = atoi(*(++argv));
1033 if (number == 0)
1034 number = 1;
1035 } else if (strcmp(*argv, "-bytes") == 0) {
1036 if (--argc < 1)
1037 goto bad;
1038 bytes = atol(*(++argv));
1039 if (bytes == 0L)
1040 bytes = 1L;
1041 i = strlen(argv[0]);
1042 if (argv[0][i - 1] == 'k')
1043 bytes *= 1024L;
1044 if (argv[0][i - 1] == 'm')
1045 bytes *= 1024L * 1024L;
1046 } else if (strcmp(*argv, "-cipher") == 0) {
1047 if (--argc < 1)
1048 goto bad;
1049 cipher = *(++argv);
1050 } else if (strcmp(*argv, "-ciphersuites") == 0) {
1051 if (--argc < 1)
1052 goto bad;
1053 ciphersuites = *(++argv);
1054 } else if (strcmp(*argv, "-CApath") == 0) {
1055 if (--argc < 1)
1056 goto bad;
1057 CApath = *(++argv);
1058 } else if (strcmp(*argv, "-CAfile") == 0) {
1059 if (--argc < 1)
1060 goto bad;
1061 CAfile = *(++argv);
1062 } else if (strcmp(*argv, "-bio_pair") == 0) {
1063 bio_type = BIO_PAIR;
1064 }
1065 #ifndef OPENSSL_NO_SOCK
1066 else if (strcmp(*argv, "-ipv4") == 0) {
1067 bio_type = BIO_IPV4;
1068 } else if (strcmp(*argv, "-ipv6") == 0) {
1069 bio_type = BIO_IPV6;
1070 }
1071 #endif
1072 else if (strcmp(*argv, "-f") == 0) {
1073 force = 1;
1074 } else if (strcmp(*argv, "-time") == 0) {
1075 print_time = 1;
1076 }
1077 #ifndef OPENSSL_NO_CT
1078 else if (strcmp(*argv, "-noct") == 0) {
1079 ct_validation = 0;
1080 }
1081 else if (strcmp(*argv, "-ct") == 0) {
1082 ct_validation = 1;
1083 }
1084 #endif
1085 #ifndef OPENSSL_NO_COMP
1086 else if (strcmp(*argv, "-zlib") == 0) {
1087 comp = COMP_ZLIB;
1088 }
1089 #endif
1090 else if (strcmp(*argv, "-app_verify") == 0) {
1091 app_verify_arg.app_verify = 1;
1092 }
1093 #ifndef OPENSSL_NO_NEXTPROTONEG
1094 else if (strcmp(*argv, "-npn_client") == 0) {
1095 npn_client = 1;
1096 } else if (strcmp(*argv, "-npn_server") == 0) {
1097 npn_server = 1;
1098 } else if (strcmp(*argv, "-npn_server_reject") == 0) {
1099 npn_server_reject = 1;
1100 }
1101 #endif
1102 else if (strcmp(*argv, "-serverinfo_sct") == 0) {
1103 serverinfo_sct = 1;
1104 } else if (strcmp(*argv, "-serverinfo_tack") == 0) {
1105 serverinfo_tack = 1;
1106 } else if (strcmp(*argv, "-serverinfo_file") == 0) {
1107 if (--argc < 1)
1108 goto bad;
1109 serverinfo_file = *(++argv);
1110 } else if (strcmp(*argv, "-custom_ext") == 0) {
1111 custom_ext = 1;
1112 } else if (strcmp(*argv, "-alpn_client") == 0) {
1113 if (--argc < 1)
1114 goto bad;
1115 alpn_client = *(++argv);
1116 } else if (strcmp(*argv, "-alpn_server") == 0 ||
1117 strcmp(*argv, "-alpn_server1") == 0) {
1118 if (--argc < 1)
1119 goto bad;
1120 alpn_server = *(++argv);
1121 } else if (strcmp(*argv, "-alpn_server2") == 0) {
1122 if (--argc < 1)
1123 goto bad;
1124 alpn_server2 = *(++argv);
1125 } else if (strcmp(*argv, "-alpn_expected") == 0) {
1126 if (--argc < 1)
1127 goto bad;
1128 alpn_expected = *(++argv);
1129 } else if (strcmp(*argv, "-server_min_proto") == 0) {
1130 if (--argc < 1)
1131 goto bad;
1132 server_min_proto = *(++argv);
1133 } else if (strcmp(*argv, "-server_max_proto") == 0) {
1134 if (--argc < 1)
1135 goto bad;
1136 server_max_proto = *(++argv);
1137 } else if (strcmp(*argv, "-client_min_proto") == 0) {
1138 if (--argc < 1)
1139 goto bad;
1140 client_min_proto = *(++argv);
1141 } else if (strcmp(*argv, "-client_max_proto") == 0) {
1142 if (--argc < 1)
1143 goto bad;
1144 client_max_proto = *(++argv);
1145 } else if (strcmp(*argv, "-should_negotiate") == 0) {
1146 if (--argc < 1)
1147 goto bad;
1148 should_negotiate = *(++argv);
1149 } else if (strcmp(*argv, "-sn_client") == 0) {
1150 if (--argc < 1)
1151 goto bad;
1152 sn_client = *(++argv);
1153 } else if (strcmp(*argv, "-sn_server1") == 0) {
1154 if (--argc < 1)
1155 goto bad;
1156 sn_server1 = *(++argv);
1157 } else if (strcmp(*argv, "-sn_server2") == 0) {
1158 if (--argc < 1)
1159 goto bad;
1160 sn_server2 = *(++argv);
1161 } else if (strcmp(*argv, "-sn_expect1") == 0) {
1162 sn_expect = 1;
1163 } else if (strcmp(*argv, "-sn_expect2") == 0) {
1164 sn_expect = 2;
1165 } else if (strcmp(*argv, "-server_sess_out") == 0) {
1166 if (--argc < 1)
1167 goto bad;
1168 server_sess_out = *(++argv);
1169 } else if (strcmp(*argv, "-server_sess_in") == 0) {
1170 if (--argc < 1)
1171 goto bad;
1172 server_sess_in = *(++argv);
1173 } else if (strcmp(*argv, "-client_sess_out") == 0) {
1174 if (--argc < 1)
1175 goto bad;
1176 client_sess_out = *(++argv);
1177 } else if (strcmp(*argv, "-client_sess_in") == 0) {
1178 if (--argc < 1)
1179 goto bad;
1180 client_sess_in = *(++argv);
1181 } else if (strcmp(*argv, "-should_reuse") == 0) {
1182 if (--argc < 1)
1183 goto bad;
1184 should_reuse = !!atoi(*(++argv));
1185 } else if (strcmp(*argv, "-no_ticket") == 0) {
1186 no_ticket = 1;
1187 } else {
1188 int rv;
1189 arg = argv[0];
1190 argn = argv[1];
1191 /* Try to process command using SSL_CONF */
1192 rv = SSL_CONF_cmd_argv(c_cctx, &argc, &argv);
1193 /* If not processed try server */
1194 if (rv == 0)
1195 rv = SSL_CONF_cmd_argv(s_cctx, &argc, &argv);
1196 /* Recognised: store it for later use */
1197 if (rv > 0) {
1198 if (rv == 1)
1199 argn = NULL;
1200 if (!conf_args) {
1201 conf_args = sk_OPENSSL_STRING_new_null();
1202 if (!conf_args)
1203 goto end;
1204 }
1205 if (!sk_OPENSSL_STRING_push(conf_args, arg))
1206 goto end;
1207 if (!sk_OPENSSL_STRING_push(conf_args, argn))
1208 goto end;
1209 continue;
1210 }
1211 if (rv == -3)
1212 BIO_printf(bio_err, "Missing argument for %s\n", arg);
1213 else if (rv < 0)
1214 BIO_printf(bio_err, "Error with command %s\n", arg);
1215 else if (rv == 0)
1216 BIO_printf(bio_err, "unknown option %s\n", arg);
1217 badop = 1;
1218 break;
1219 }
1220 argc--;
1221 argv++;
1222 }
1223 if (badop) {
1224 bad:
1225 sv_usage();
1226 goto end;
1227 }
1228
1229 if (ssl3 + tls1 + tls1_2 + dtls + dtls1 + dtls12 > 1) {
1230 fprintf(stderr, "At most one of -ssl3, -tls1, -tls1_2, -dtls, -dtls1 or -dtls12 should "
1231 "be requested.\n");
1232 EXIT(1);
1233 }
1234
1235 #ifdef OPENSSL_NO_SSL3
1236 if (ssl3)
1237 no_protocol = 1;
1238 else
1239 #endif
1240 #ifdef OPENSSL_NO_TLS1
1241 if (tls1)
1242 no_protocol = 1;
1243 else
1244 #endif
1245 #ifdef OPENSSL_NO_TLS1_2
1246 if (tls1_2)
1247 no_protocol = 1;
1248 else
1249 #endif
1250 #if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1)
1251 if (dtls1)
1252 no_protocol = 1;
1253 else
1254 #endif
1255 #if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1_2)
1256 if (dtls12)
1257 no_protocol = 1;
1258 else
1259 #endif
1260 no_protocol = 0;
1261
1262 /*
1263 * Testing was requested for a compiled-out protocol (e.g. SSLv3).
1264 * Ideally, we would error out, but the generic test wrapper can't know
1265 * when to expect failure. So we do nothing and return success.
1266 */
1267 if (no_protocol) {
1268 fprintf(stderr, "Testing was requested for a disabled protocol. "
1269 "Skipping tests.\n");
1270 ret = EXIT_SUCCESS;
1271 goto end;
1272 }
1273
1274 if (!ssl3 && !tls1 && !tls1_2 && !dtls && !dtls1 && !dtls12 && number > 1
1275 && !reuse && !force) {
1276 fprintf(stderr, "This case cannot work. Use -f to perform "
1277 "the test anyway (and\n-d to see what happens), "
1278 "or add one of -ssl3, -tls1, -tls1_2, -dtls, -dtls1, -dtls12, -reuse\n"
1279 "to avoid protocol mismatch.\n");
1280 EXIT(1);
1281 }
1282
1283 if (print_time) {
1284 if (bio_type != BIO_PAIR) {
1285 fprintf(stderr, "Using BIO pair (-bio_pair)\n");
1286 bio_type = BIO_PAIR;
1287 }
1288 if (number < 50 && !force)
1289 fprintf(stderr,
1290 "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
1291 }
1292
1293 #ifndef OPENSSL_NO_COMP
1294 if (comp == COMP_ZLIB)
1295 cm = COMP_zlib();
1296 if (cm != NULL) {
1297 if (COMP_get_type(cm) != NID_undef) {
1298 if (SSL_COMP_add_compression_method(comp, cm) != 0) {
1299 fprintf(stderr, "Failed to add compression method\n");
1300 ERR_print_errors_fp(stderr);
1301 }
1302 } else {
1303 fprintf(stderr,
1304 "Warning: %s compression not supported\n",
1305 comp == COMP_ZLIB ? "zlib" : "unknown");
1306 ERR_print_errors_fp(stderr);
1307 }
1308 }
1309 ssl_comp_methods = SSL_COMP_get_compression_methods();
1310 n = sk_SSL_COMP_num(ssl_comp_methods);
1311 if (n) {
1312 int j;
1313 printf("Available compression methods:");
1314 for (j = 0; j < n; j++) {
1315 SSL_COMP *c = sk_SSL_COMP_value(ssl_comp_methods, j);
1316 printf(" %s:%d", SSL_COMP_get0_name(c), SSL_COMP_get_id(c));
1317 }
1318 printf("\n");
1319 }
1320 #endif
1321
1322 #ifndef OPENSSL_NO_TLS
1323 meth = TLS_method();
1324 if (ssl3) {
1325 min_version = SSL3_VERSION;
1326 max_version = SSL3_VERSION;
1327 } else if (tls1) {
1328 min_version = TLS1_VERSION;
1329 max_version = TLS1_VERSION;
1330 } else if (tls1_2) {
1331 min_version = TLS1_2_VERSION;
1332 max_version = TLS1_2_VERSION;
1333 } else {
1334 min_version = 0;
1335 max_version = 0;
1336 }
1337 #endif
1338 #ifndef OPENSSL_NO_DTLS
1339 if (dtls || dtls1 || dtls12) {
1340 meth = DTLS_method();
1341 if (dtls1) {
1342 min_version = DTLS1_VERSION;
1343 max_version = DTLS1_VERSION;
1344 } else if (dtls12) {
1345 min_version = DTLS1_2_VERSION;
1346 max_version = DTLS1_2_VERSION;
1347 } else {
1348 min_version = 0;
1349 max_version = 0;
1350 }
1351 }
1352 #endif
1353
1354 c_ctx = SSL_CTX_new(meth);
1355 s_ctx = SSL_CTX_new(meth);
1356 s_ctx2 = SSL_CTX_new(meth); /* no SSL_CTX_dup! */
1357 if ((c_ctx == NULL) || (s_ctx == NULL) || (s_ctx2 == NULL)) {
1358 ERR_print_errors(bio_err);
1359 goto end;
1360 }
1361 /*
1362 * Since we will use low security ciphersuites and keys for testing set
1363 * security level to zero by default. Tests can override this by adding
1364 * "@SECLEVEL=n" to the cipher string.
1365 */
1366 SSL_CTX_set_security_level(c_ctx, 0);
1367 SSL_CTX_set_security_level(s_ctx, 0);
1368 SSL_CTX_set_security_level(s_ctx2, 0);
1369
1370 if (no_ticket) {
1371 SSL_CTX_set_options(c_ctx, SSL_OP_NO_TICKET);
1372 SSL_CTX_set_options(s_ctx, SSL_OP_NO_TICKET);
1373 }
1374
1375 if (SSL_CTX_set_min_proto_version(c_ctx, min_version) == 0)
1376 goto end;
1377 if (SSL_CTX_set_max_proto_version(c_ctx, max_version) == 0)
1378 goto end;
1379 if (SSL_CTX_set_min_proto_version(s_ctx, min_version) == 0)
1380 goto end;
1381 if (SSL_CTX_set_max_proto_version(s_ctx, max_version) == 0)
1382 goto end;
1383
1384 if (cipher != NULL) {
1385 if (strcmp(cipher, "") == 0) {
1386 if (!SSL_CTX_set_cipher_list(c_ctx, cipher)) {
1387 if (ERR_GET_REASON(ERR_peek_error()) == SSL_R_NO_CIPHER_MATCH) {
1388 ERR_clear_error();
1389 } else {
1390 ERR_print_errors(bio_err);
1391 goto end;
1392 }
1393 } else {
1394 /* Should have failed when clearing all TLSv1.2 ciphers. */
1395 fprintf(stderr, "CLEARING ALL TLSv1.2 CIPHERS SHOULD FAIL\n");
1396 goto end;
1397 }
1398
1399 if (!SSL_CTX_set_cipher_list(s_ctx, cipher)) {
1400 if (ERR_GET_REASON(ERR_peek_error()) == SSL_R_NO_CIPHER_MATCH) {
1401 ERR_clear_error();
1402 } else {
1403 ERR_print_errors(bio_err);
1404 goto end;
1405 }
1406 } else {
1407 /* Should have failed when clearing all TLSv1.2 ciphers. */
1408 fprintf(stderr, "CLEARING ALL TLSv1.2 CIPHERS SHOULD FAIL\n");
1409 goto end;
1410 }
1411
1412 if (!SSL_CTX_set_cipher_list(s_ctx2, cipher)) {
1413 if (ERR_GET_REASON(ERR_peek_error()) == SSL_R_NO_CIPHER_MATCH) {
1414 ERR_clear_error();
1415 } else {
1416 ERR_print_errors(bio_err);
1417 goto end;
1418 }
1419 } else {
1420 /* Should have failed when clearing all TLSv1.2 ciphers. */
1421 fprintf(stderr, "CLEARING ALL TLSv1.2 CIPHERS SHOULD FAIL\n");
1422 goto end;
1423 }
1424 } else {
1425 if (!SSL_CTX_set_cipher_list(c_ctx, cipher)
1426 || !SSL_CTX_set_cipher_list(s_ctx, cipher)
1427 || !SSL_CTX_set_cipher_list(s_ctx2, cipher)) {
1428 ERR_print_errors(bio_err);
1429 goto end;
1430 }
1431 }
1432 }
1433 if (ciphersuites != NULL) {
1434 if (!SSL_CTX_set_ciphersuites(c_ctx, ciphersuites)
1435 || !SSL_CTX_set_ciphersuites(s_ctx, ciphersuites)
1436 || !SSL_CTX_set_ciphersuites(s_ctx2, ciphersuites)) {
1437 ERR_print_errors(bio_err);
1438 goto end;
1439 }
1440 }
1441
1442 #ifndef OPENSSL_NO_CT
1443 if (ct_validation &&
1444 !SSL_CTX_enable_ct(c_ctx, SSL_CT_VALIDATION_STRICT)) {
1445 ERR_print_errors(bio_err);
1446 goto end;
1447 }
1448 #endif
1449
1450 /* Process SSL_CONF arguments */
1451 SSL_CONF_CTX_set_ssl_ctx(c_cctx, c_ctx);
1452 SSL_CONF_CTX_set_ssl_ctx(s_cctx, s_ctx);
1453 SSL_CONF_CTX_set_ssl_ctx(s_cctx2, s_ctx2);
1454
1455 for (i = 0; i < sk_OPENSSL_STRING_num(conf_args); i += 2) {
1456 int rv;
1457 arg = sk_OPENSSL_STRING_value(conf_args, i);
1458 argn = sk_OPENSSL_STRING_value(conf_args, i + 1);
1459 rv = SSL_CONF_cmd(c_cctx, arg, argn);
1460 /* If not recognised use server context */
1461 if (rv == -2) {
1462 rv = SSL_CONF_cmd(s_cctx2, arg, argn);
1463 if (rv > 0)
1464 rv = SSL_CONF_cmd(s_cctx, arg, argn);
1465 }
1466 if (rv <= 0) {
1467 BIO_printf(bio_err, "Error processing %s %s\n",
1468 arg, argn ? argn : "");
1469 ERR_print_errors(bio_err);
1470 goto end;
1471 }
1472 }
1473
1474 if (!SSL_CONF_CTX_finish(s_cctx) || !SSL_CONF_CTX_finish(c_cctx) || !SSL_CONF_CTX_finish(s_cctx2)) {
1475 BIO_puts(bio_err, "Error finishing context\n");
1476 ERR_print_errors(bio_err);
1477 goto end;
1478 }
1479 #ifndef OPENSSL_NO_DH
1480 if (!no_dhe) {
1481 if (dhe1024dsa) {
1482 dh = get_dh1024dsa();
1483 } else if (dhe512)
1484 dh = get_dh512();
1485 else
1486 dh = get_dh1024();
1487 SSL_CTX_set_tmp_dh(s_ctx, dh);
1488 SSL_CTX_set_tmp_dh(s_ctx2, dh);
1489 DH_free(dh);
1490 }
1491 #else
1492 (void)no_dhe;
1493 #endif
1494
1495 if ((!SSL_CTX_load_verify_locations(s_ctx, CAfile, CApath)) ||
1496 (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1497 (!SSL_CTX_load_verify_locations(s_ctx2, CAfile, CApath)) ||
1498 (!SSL_CTX_set_default_verify_paths(s_ctx2)) ||
1499 (!SSL_CTX_load_verify_locations(c_ctx, CAfile, CApath)) ||
1500 (!SSL_CTX_set_default_verify_paths(c_ctx))) {
1501 ERR_print_errors(bio_err);
1502 }
1503
1504 #ifndef OPENSSL_NO_CT
1505 if (!SSL_CTX_set_default_ctlog_list_file(s_ctx) ||
1506 !SSL_CTX_set_default_ctlog_list_file(s_ctx2) ||
1507 !SSL_CTX_set_default_ctlog_list_file(c_ctx)) {
1508 ERR_print_errors(bio_err);
1509 }
1510 #endif
1511
1512 if (client_auth) {
1513 printf("client authentication\n");
1514 SSL_CTX_set_verify(s_ctx,
1515 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1516 verify_callback);
1517 SSL_CTX_set_verify(s_ctx2,
1518 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1519 verify_callback);
1520 SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback,
1521 &app_verify_arg);
1522 SSL_CTX_set_cert_verify_callback(s_ctx2, app_verify_callback,
1523 &app_verify_arg);
1524 }
1525 if (server_auth) {
1526 printf("server authentication\n");
1527 SSL_CTX_set_verify(c_ctx, SSL_VERIFY_PEER, verify_callback);
1528 SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback,
1529 &app_verify_arg);
1530 }
1531
1532 {
1533 int session_id_context = 0;
1534 if (!SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context,
1535 sizeof(session_id_context)) ||
1536 !SSL_CTX_set_session_id_context(s_ctx2, (void *)&session_id_context,
1537 sizeof(session_id_context))) {
1538 ERR_print_errors(bio_err);
1539 goto end;
1540 }
1541 }
1542
1543 /* Use PSK only if PSK key is given */
1544 if (psk_key != NULL) {
1545 /*
1546 * no_psk is used to avoid putting psk command to openssl tool
1547 */
1548 if (no_psk) {
1549 /*
1550 * if PSK is not compiled in and psk key is given, do nothing and
1551 * exit successfully
1552 */
1553 ret = EXIT_SUCCESS;
1554 goto end;
1555 }
1556 #ifndef OPENSSL_NO_PSK
1557 SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1558 SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1559 SSL_CTX_set_psk_server_callback(s_ctx2, psk_server_callback);
1560 if (debug)
1561 BIO_printf(bio_err, "setting PSK identity hint to s_ctx\n");
1562 if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint") ||
1563 !SSL_CTX_use_psk_identity_hint(s_ctx2, "ctx server identity_hint")) {
1564 BIO_printf(bio_err, "error setting PSK identity hint to s_ctx\n");
1565 ERR_print_errors(bio_err);
1566 goto end;
1567 }
1568 #endif
1569 }
1570
1571 #ifndef OPENSSL_NO_NEXTPROTONEG
1572 if (npn_client) {
1573 SSL_CTX_set_next_proto_select_cb(c_ctx, cb_client_npn, NULL);
1574 }
1575 if (npn_server) {
1576 if (npn_server_reject) {
1577 BIO_printf(bio_err,
1578 "Can't have both -npn_server and -npn_server_reject\n");
1579 goto end;
1580 }
1581 SSL_CTX_set_npn_advertised_cb(s_ctx, cb_server_npn, NULL);
1582 SSL_CTX_set_npn_advertised_cb(s_ctx2, cb_server_npn, NULL);
1583 }
1584 if (npn_server_reject) {
1585 SSL_CTX_set_npn_advertised_cb(s_ctx, cb_server_rejects_npn, NULL);
1586 SSL_CTX_set_npn_advertised_cb(s_ctx2, cb_server_rejects_npn, NULL);
1587 }
1588 #endif
1589
1590 if (serverinfo_sct) {
1591 if (!SSL_CTX_add_client_custom_ext(c_ctx,
1592 TLSEXT_TYPE_signed_certificate_timestamp,
1593 NULL, NULL, NULL,
1594 serverinfo_cli_parse_cb, NULL)) {
1595 BIO_printf(bio_err, "Error adding SCT extension\n");
1596 goto end;
1597 }
1598 }
1599 if (serverinfo_tack) {
1600 if (!SSL_CTX_add_client_custom_ext(c_ctx, TACK_EXT_TYPE,
1601 NULL, NULL, NULL,
1602 serverinfo_cli_parse_cb, NULL)) {
1603 BIO_printf(bio_err, "Error adding TACK extension\n");
1604 goto end;
1605 }
1606 }
1607 if (serverinfo_file)
1608 if (!SSL_CTX_use_serverinfo_file(s_ctx, serverinfo_file) ||
1609 !SSL_CTX_use_serverinfo_file(s_ctx2, serverinfo_file)) {
1610 BIO_printf(bio_err, "missing serverinfo file\n");
1611 goto end;
1612 }
1613
1614 if (custom_ext) {
1615 if (!SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_0,
1616 custom_ext_0_cli_add_cb,
1617 NULL, NULL,
1618 custom_ext_0_cli_parse_cb, NULL)
1619 || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_1,
1620 custom_ext_1_cli_add_cb,
1621 NULL, NULL,
1622 custom_ext_1_cli_parse_cb, NULL)
1623 || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_2,
1624 custom_ext_2_cli_add_cb,
1625 NULL, NULL,
1626 custom_ext_2_cli_parse_cb, NULL)
1627 || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_3,
1628 custom_ext_3_cli_add_cb,
1629 NULL, NULL,
1630 custom_ext_3_cli_parse_cb, NULL)
1631 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_0,
1632 custom_ext_0_srv_add_cb,
1633 NULL, NULL,
1634 custom_ext_0_srv_parse_cb, NULL)
1635 || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_0,
1636 custom_ext_0_srv_add_cb,
1637 NULL, NULL,
1638 custom_ext_0_srv_parse_cb, NULL)
1639 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_1,
1640 custom_ext_1_srv_add_cb,
1641 NULL, NULL,
1642 custom_ext_1_srv_parse_cb, NULL)
1643 || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_1,
1644 custom_ext_1_srv_add_cb,
1645 NULL, NULL,
1646 custom_ext_1_srv_parse_cb, NULL)
1647 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_2,
1648 custom_ext_2_srv_add_cb,
1649 NULL, NULL,
1650 custom_ext_2_srv_parse_cb, NULL)
1651 || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_2,
1652 custom_ext_2_srv_add_cb,
1653 NULL, NULL,
1654 custom_ext_2_srv_parse_cb, NULL)
1655 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_3,
1656 custom_ext_3_srv_add_cb,
1657 NULL, NULL,
1658 custom_ext_3_srv_parse_cb, NULL)
1659 || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_3,
1660 custom_ext_3_srv_add_cb,
1661 NULL, NULL,
1662 custom_ext_3_srv_parse_cb, NULL)) {
1663 BIO_printf(bio_err, "Error setting custom extensions\n");
1664 goto end;
1665 }
1666 }
1667
1668 if (alpn_server)
1669 SSL_CTX_set_alpn_select_cb(s_ctx, cb_server_alpn, alpn_server);
1670 if (alpn_server2)
1671 SSL_CTX_set_alpn_select_cb(s_ctx2, cb_server_alpn, alpn_server2);
1672
1673 if (alpn_client) {
1674 size_t alpn_len;
1675 unsigned char *alpn = next_protos_parse(&alpn_len, alpn_client);
1676
1677 if (alpn == NULL) {
1678 BIO_printf(bio_err, "Error parsing -alpn_client argument\n");
1679 goto end;
1680 }
1681 /* Returns 0 on success!! */
1682 if (SSL_CTX_set_alpn_protos(c_ctx, alpn, alpn_len)) {
1683 BIO_printf(bio_err, "Error setting ALPN\n");
1684 OPENSSL_free(alpn);
1685 goto end;
1686 }
1687 OPENSSL_free(alpn);
1688 }
1689
1690 if (server_sess_in != NULL) {
1691 server_sess = read_session(server_sess_in);
1692 if (server_sess == NULL)
1693 goto end;
1694 }
1695 if (client_sess_in != NULL) {
1696 client_sess = read_session(client_sess_in);
1697 if (client_sess == NULL)
1698 goto end;
1699 }
1700
1701 if (server_sess_out != NULL || server_sess_in != NULL) {
1702 char *keys;
1703 long size;
1704
1705 /* Use a fixed key so that we can decrypt the ticket. */
1706 size = SSL_CTX_set_tlsext_ticket_keys(s_ctx, NULL, 0);
1707 keys = OPENSSL_zalloc(size);
1708 SSL_CTX_set_tlsext_ticket_keys(s_ctx, keys, size);
1709 OPENSSL_free(keys);
1710 }
1711
1712 if (sn_server1 != NULL || sn_server2 != NULL)
1713 SSL_CTX_set_tlsext_servername_callback(s_ctx, servername_cb);
1714
1715 c_ssl = SSL_new(c_ctx);
1716 s_ssl = SSL_new(s_ctx);
1717
1718 if (sn_client)
1719 SSL_set_tlsext_host_name(c_ssl, sn_client);
1720
1721 if (!set_protocol_version(server_min_proto, s_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1722 goto end;
1723 if (!set_protocol_version(server_max_proto, s_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1724 goto end;
1725 if (!set_protocol_version(client_min_proto, c_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1726 goto end;
1727 if (!set_protocol_version(client_max_proto, c_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1728 goto end;
1729
1730 if (server_sess) {
1731 if (SSL_CTX_add_session(s_ctx, server_sess) == 0) {
1732 BIO_printf(bio_err, "Can't add server session\n");
1733 ERR_print_errors(bio_err);
1734 goto end;
1735 }
1736 }
1737
1738 BIO_printf(bio_stdout, "Doing handshakes=%d bytes=%ld\n", number, bytes);
1739 for (i = 0; i < number; i++) {
1740 if (!reuse) {
1741 if (!SSL_set_session(c_ssl, NULL)) {
1742 BIO_printf(bio_err, "Failed to set session\n");
1743 goto end;
1744 }
1745 }
1746 if (client_sess_in != NULL) {
1747 if (SSL_set_session(c_ssl, client_sess) == 0) {
1748 BIO_printf(bio_err, "Can't set client session\n");
1749 ERR_print_errors(bio_err);
1750 goto end;
1751 }
1752 }
1753 switch (bio_type) {
1754 case BIO_MEM:
1755 ret = doit(s_ssl, c_ssl, bytes);
1756 break;
1757 case BIO_PAIR:
1758 ret = doit_biopair(s_ssl, c_ssl, bytes, &s_time, &c_time);
1759 break;
1760 #ifndef OPENSSL_NO_SOCK
1761 case BIO_IPV4:
1762 ret = doit_localhost(s_ssl, c_ssl, BIO_FAMILY_IPV4,
1763 bytes, &s_time, &c_time);
1764 break;
1765 case BIO_IPV6:
1766 ret = doit_localhost(s_ssl, c_ssl, BIO_FAMILY_IPV6,
1767 bytes, &s_time, &c_time);
1768 break;
1769 #else
1770 case BIO_IPV4:
1771 case BIO_IPV6:
1772 ret = EXIT_FAILURE;
1773 goto err;
1774 #endif
1775 }
1776 if (ret != EXIT_SUCCESS) break;
1777 }
1778
1779 if (should_negotiate && ret == EXIT_SUCCESS &&
1780 strcmp(should_negotiate, "fail-server") != 0 &&
1781 strcmp(should_negotiate, "fail-client") != 0) {
1782 int version = protocol_from_string(should_negotiate);
1783 if (version < 0) {
1784 BIO_printf(bio_err, "Error parsing: %s\n", should_negotiate);
1785 ret = EXIT_FAILURE;
1786 goto err;
1787 }
1788 if (SSL_version(c_ssl) != version) {
1789 BIO_printf(bio_err, "Unexpected version negotiated. "
1790 "Expected: %s, got %s\n", should_negotiate, SSL_get_version(c_ssl));
1791 ret = EXIT_FAILURE;
1792 goto err;
1793 }
1794 }
1795
1796 if (should_reuse != -1) {
1797 if (SSL_session_reused(s_ssl) != should_reuse ||
1798 SSL_session_reused(c_ssl) != should_reuse) {
1799 BIO_printf(bio_err, "Unexpected session reuse state. "
1800 "Expected: %d, server: %d, client: %d\n", should_reuse,
1801 SSL_session_reused(s_ssl), SSL_session_reused(c_ssl));
1802 ret = EXIT_FAILURE;
1803 goto err;
1804 }
1805 }
1806
1807 if (server_sess_out != NULL) {
1808 if (write_session(server_sess_out, SSL_get_session(s_ssl)) == 0) {
1809 ret = EXIT_FAILURE;
1810 goto err;
1811 }
1812 }
1813 if (client_sess_out != NULL) {
1814 if (write_session(client_sess_out, SSL_get_session(c_ssl)) == 0) {
1815 ret = EXIT_FAILURE;
1816 goto err;
1817 }
1818 }
1819
1820 if (!verbose) {
1821 print_details(c_ssl, "");
1822 }
1823 if (print_time) {
1824 #ifdef CLOCKS_PER_SEC
1825 /*
1826 * "To determine the time in seconds, the value returned by the clock
1827 * function should be divided by the value of the macro
1828 * CLOCKS_PER_SEC." -- ISO/IEC 9899
1829 */
1830 BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1831 "Approximate total client time: %6.2f s\n",
1832 (double)s_time / CLOCKS_PER_SEC,
1833 (double)c_time / CLOCKS_PER_SEC);
1834 #else
1835 BIO_printf(bio_stdout,
1836 "Approximate total server time: %6.2f units\n"
1837 "Approximate total client time: %6.2f units\n",
1838 (double)s_time, (double)c_time);
1839 #endif
1840 }
1841
1842 err:
1843 SSL_free(s_ssl);
1844 SSL_free(c_ssl);
1845
1846 end:
1847 SSL_CTX_free(s_ctx);
1848 SSL_CTX_free(s_ctx2);
1849 SSL_CTX_free(c_ctx);
1850 SSL_CONF_CTX_free(s_cctx);
1851 SSL_CONF_CTX_free(s_cctx2);
1852 SSL_CONF_CTX_free(c_cctx);
1853 sk_OPENSSL_STRING_free(conf_args);
1854
1855 BIO_free(bio_stdout);
1856
1857 SSL_SESSION_free(server_sess);
1858 SSL_SESSION_free(client_sess);
1859
1860 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
1861 if (CRYPTO_mem_leaks(bio_err) <= 0)
1862 ret = EXIT_FAILURE;
1863 #endif
1864 BIO_free(bio_err);
1865 EXIT(ret);
1866 }
1867
1868 #ifndef OPENSSL_NO_SOCK
1869 int doit_localhost(SSL *s_ssl, SSL *c_ssl, int family, long count,
1870 clock_t *s_time, clock_t *c_time)
1871 {
1872 long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1873 BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1874 BIO *acpt = NULL, *server = NULL, *client = NULL;
1875 char addr_str[40];
1876 int ret = EXIT_FAILURE;
1877 int err_in_client = 0;
1878 int err_in_server = 0;
1879
1880 acpt = BIO_new_accept(family == BIO_FAMILY_IPV4 ? "127.0.0.1:0"
1881 : "[::1]:0");
1882 if (acpt == NULL)
1883 goto err;
1884 BIO_set_accept_ip_family(acpt, family);
1885 BIO_set_bind_mode(acpt, BIO_SOCK_NONBLOCK | BIO_SOCK_REUSEADDR);
1886 if (BIO_do_accept(acpt) <= 0)
1887 goto err;
1888
1889 BIO_snprintf(addr_str, sizeof(addr_str), ":%s", BIO_get_accept_port(acpt));
1890
1891 client = BIO_new_connect(addr_str);
1892 BIO_set_conn_ip_family(client, family);
1893 if (!client)
1894 goto err;
1895
1896 if (BIO_set_nbio(client, 1) <= 0)
1897 goto err;
1898 if (BIO_set_nbio(acpt, 1) <= 0)
1899 goto err;
1900
1901 {
1902 int st_connect = 0, st_accept = 0;
1903
1904 while(!st_connect || !st_accept) {
1905 if (!st_connect) {
1906 if (BIO_do_connect(client) <= 0) {
1907 if (!BIO_should_retry(client))
1908 goto err;
1909 } else {
1910 st_connect = 1;
1911 }
1912 }
1913 if (!st_accept) {
1914 if (BIO_do_accept(acpt) <= 0) {
1915 if (!BIO_should_retry(acpt))
1916 goto err;
1917 } else {
1918 st_accept = 1;
1919 }
1920 }
1921 }
1922 }
1923 /* We're not interested in accepting further connects */
1924 server = BIO_pop(acpt);
1925 BIO_free_all(acpt);
1926 acpt = NULL;
1927
1928 s_ssl_bio = BIO_new(BIO_f_ssl());
1929 if (!s_ssl_bio)
1930 goto err;
1931
1932 c_ssl_bio = BIO_new(BIO_f_ssl());
1933 if (!c_ssl_bio)
1934 goto err;
1935
1936 SSL_set_connect_state(c_ssl);
1937 SSL_set_bio(c_ssl, client, client);
1938 (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1939
1940 SSL_set_accept_state(s_ssl);
1941 SSL_set_bio(s_ssl, server, server);
1942 (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1943
1944 do {
1945 /*-
1946 * c_ssl_bio: SSL filter BIO
1947 *
1948 * client: I/O for SSL library
1949 *
1950 *
1951 * server: I/O for SSL library
1952 *
1953 * s_ssl_bio: SSL filter BIO
1954 */
1955
1956 /*
1957 * We have non-blocking behaviour throughout this test program, but
1958 * can be sure that there is *some* progress in each iteration; so we
1959 * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
1960 * we just try everything in each iteration
1961 */
1962
1963 {
1964 /* CLIENT */
1965
1966 char cbuf[1024 * 8];
1967 int i, r;
1968 clock_t c_clock = clock();
1969
1970 memset(cbuf, 0, sizeof(cbuf));
1971
1972 if (debug)
1973 if (SSL_in_init(c_ssl))
1974 printf("client waiting in SSL_connect - %s\n",
1975 SSL_state_string_long(c_ssl));
1976
1977 if (cw_num > 0) {
1978 /* Write to server. */
1979
1980 if (cw_num > (long)sizeof(cbuf))
1981 i = sizeof(cbuf);
1982 else
1983 i = (int)cw_num;
1984 r = BIO_write(c_ssl_bio, cbuf, i);
1985 if (r < 0) {
1986 if (!BIO_should_retry(c_ssl_bio)) {
1987 fprintf(stderr, "ERROR in CLIENT\n");
1988 err_in_client = 1;
1989 goto err;
1990 }
1991 /*
1992 * BIO_should_retry(...) can just be ignored here. The
1993 * library expects us to call BIO_write with the same
1994 * arguments again, and that's what we will do in the
1995 * next iteration.
1996 */
1997 } else if (r == 0) {
1998 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1999 goto err;
2000 } else {
2001 if (debug)
2002 printf("client wrote %d\n", r);
2003 cw_num -= r;
2004 }
2005 }
2006
2007 if (cr_num > 0) {
2008 /* Read from server. */
2009
2010 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
2011 if (r < 0) {
2012 if (!BIO_should_retry(c_ssl_bio)) {
2013 fprintf(stderr, "ERROR in CLIENT\n");
2014 err_in_client = 1;
2015 goto err;
2016 }
2017 /*
2018 * Again, "BIO_should_retry" can be ignored.
2019 */
2020 } else if (r == 0) {
2021 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2022 goto err;
2023 } else {
2024 if (debug)
2025 printf("client read %d\n", r);
2026 cr_num -= r;
2027 }
2028 }
2029
2030 /*
2031 * c_time and s_time increments will typically be very small
2032 * (depending on machine speed and clock tick intervals), but
2033 * sampling over a large number of connections should result in
2034 * fairly accurate figures. We cannot guarantee a lot, however
2035 * -- if each connection lasts for exactly one clock tick, it
2036 * will be counted only for the client or only for the server or
2037 * even not at all.
2038 */
2039 *c_time += (clock() - c_clock);
2040 }
2041
2042 {
2043 /* SERVER */
2044
2045 char sbuf[1024 * 8];
2046 int i, r;
2047 clock_t s_clock = clock();
2048
2049 memset(sbuf, 0, sizeof(sbuf));
2050
2051 if (debug)
2052 if (SSL_in_init(s_ssl))
2053 printf("server waiting in SSL_accept - %s\n",
2054 SSL_state_string_long(s_ssl));
2055
2056 if (sw_num > 0) {
2057 /* Write to client. */
2058
2059 if (sw_num > (long)sizeof(sbuf))
2060 i = sizeof(sbuf);
2061 else
2062 i = (int)sw_num;
2063 r = BIO_write(s_ssl_bio, sbuf, i);
2064 if (r < 0) {
2065 if (!BIO_should_retry(s_ssl_bio)) {
2066 fprintf(stderr, "ERROR in SERVER\n");
2067 err_in_server = 1;
2068 goto err;
2069 }
2070 /* Ignore "BIO_should_retry". */
2071 } else if (r == 0) {
2072 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2073 goto err;
2074 } else {
2075 if (debug)
2076 printf("server wrote %d\n", r);
2077 sw_num -= r;
2078 }
2079 }
2080
2081 if (sr_num > 0) {
2082 /* Read from client. */
2083
2084 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2085 if (r < 0) {
2086 if (!BIO_should_retry(s_ssl_bio)) {
2087 fprintf(stderr, "ERROR in SERVER\n");
2088 err_in_server = 1;
2089 goto err;
2090 }
2091 /* blah, blah */
2092 } else if (r == 0) {
2093 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2094 goto err;
2095 } else {
2096 if (debug)
2097 printf("server read %d\n", r);
2098 sr_num -= r;
2099 }
2100 }
2101
2102 *s_time += (clock() - s_clock);
2103 }
2104 }
2105 while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2106
2107 if (verbose)
2108 print_details(c_ssl, "DONE via TCP connect: ");
2109 # ifndef OPENSSL_NO_NEXTPROTONEG
2110 if (verify_npn(c_ssl, s_ssl) < 0)
2111 goto end;
2112 # endif
2113 if (verify_serverinfo() < 0) {
2114 fprintf(stderr, "Server info verify error\n");
2115 goto err;
2116 }
2117 if (verify_alpn(c_ssl, s_ssl) < 0
2118 || verify_servername(c_ssl, s_ssl) < 0)
2119 goto err;
2120
2121 if (custom_ext_error) {
2122 fprintf(stderr, "Custom extension error\n");
2123 goto err;
2124 }
2125
2126 # ifndef OPENSSL_NO_NEXTPROTONEG
2127 end:
2128 # endif
2129 ret = EXIT_SUCCESS;
2130
2131 err:
2132 ERR_print_errors(bio_err);
2133
2134 BIO_free_all(acpt);
2135 BIO_free(server);
2136 BIO_free(client);
2137 BIO_free(s_ssl_bio);
2138 BIO_free(c_ssl_bio);
2139
2140 if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2141 ret = (err_in_client != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2142 else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2143 ret = (err_in_server != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2144
2145 return ret;
2146 }
2147 #endif
2148
2149 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
2150 clock_t *s_time, clock_t *c_time)
2151 {
2152 long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
2153 BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
2154 BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
2155 int ret = EXIT_FAILURE;
2156 int err_in_client = 0;
2157 int err_in_server = 0;
2158
2159 size_t bufsiz = 256; /* small buffer for testing */
2160
2161 if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
2162 goto err;
2163 if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
2164 goto err;
2165
2166 s_ssl_bio = BIO_new(BIO_f_ssl());
2167 if (!s_ssl_bio)
2168 goto err;
2169
2170 c_ssl_bio = BIO_new(BIO_f_ssl());
2171 if (!c_ssl_bio)
2172 goto err;
2173
2174 SSL_set_connect_state(c_ssl);
2175 SSL_set_bio(c_ssl, client, client);
2176 (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
2177
2178 SSL_set_accept_state(s_ssl);
2179 SSL_set_bio(s_ssl, server, server);
2180 (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
2181
2182 do {
2183 /*-
2184 * c_ssl_bio: SSL filter BIO
2185 *
2186 * client: pseudo-I/O for SSL library
2187 *
2188 * client_io: client's SSL communication; usually to be
2189 * relayed over some I/O facility, but in this
2190 * test program, we're the server, too:
2191 *
2192 * server_io: server's SSL communication
2193 *
2194 * server: pseudo-I/O for SSL library
2195 *
2196 * s_ssl_bio: SSL filter BIO
2197 *
2198 * The client and the server each employ a "BIO pair":
2199 * client + client_io, server + server_io.
2200 * BIO pairs are symmetric. A BIO pair behaves similar
2201 * to a non-blocking socketpair (but both endpoints must
2202 * be handled by the same thread).
2203 * [Here we could connect client and server to the ends
2204 * of a single BIO pair, but then this code would be less
2205 * suitable as an example for BIO pairs in general.]
2206 *
2207 * Useful functions for querying the state of BIO pair endpoints:
2208 *
2209 * BIO_ctrl_pending(bio) number of bytes we can read now
2210 * BIO_ctrl_get_read_request(bio) number of bytes needed to fulfill
2211 * other side's read attempt
2212 * BIO_ctrl_get_write_guarantee(bio) number of bytes we can write now
2213 *
2214 * ..._read_request is never more than ..._write_guarantee;
2215 * it depends on the application which one you should use.
2216 */
2217
2218 /*
2219 * We have non-blocking behaviour throughout this test program, but
2220 * can be sure that there is *some* progress in each iteration; so we
2221 * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
2222 * we just try everything in each iteration
2223 */
2224
2225 {
2226 /* CLIENT */
2227
2228 char cbuf[1024 * 8];
2229 int i, r;
2230 clock_t c_clock = clock();
2231
2232 memset(cbuf, 0, sizeof(cbuf));
2233
2234 if (debug)
2235 if (SSL_in_init(c_ssl))
2236 printf("client waiting in SSL_connect - %s\n",
2237 SSL_state_string_long(c_ssl));
2238
2239 if (cw_num > 0) {
2240 /* Write to server. */
2241
2242 if (cw_num > (long)sizeof(cbuf))
2243 i = sizeof(cbuf);
2244 else
2245 i = (int)cw_num;
2246 r = BIO_write(c_ssl_bio, cbuf, i);
2247 if (r < 0) {
2248 if (!BIO_should_retry(c_ssl_bio)) {
2249 fprintf(stderr, "ERROR in CLIENT\n");
2250 err_in_client = 1;
2251 goto err;
2252 }
2253 /*
2254 * BIO_should_retry(...) can just be ignored here. The
2255 * library expects us to call BIO_write with the same
2256 * arguments again, and that's what we will do in the
2257 * next iteration.
2258 */
2259 } else if (r == 0) {
2260 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2261 goto err;
2262 } else {
2263 if (debug)
2264 printf("client wrote %d\n", r);
2265 cw_num -= r;
2266 }
2267 }
2268
2269 if (cr_num > 0) {
2270 /* Read from server. */
2271
2272 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
2273 if (r < 0) {
2274 if (!BIO_should_retry(c_ssl_bio)) {
2275 fprintf(stderr, "ERROR in CLIENT\n");
2276 err_in_client = 1;
2277 goto err;
2278 }
2279 /*
2280 * Again, "BIO_should_retry" can be ignored.
2281 */
2282 } else if (r == 0) {
2283 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2284 goto err;
2285 } else {
2286 if (debug)
2287 printf("client read %d\n", r);
2288 cr_num -= r;
2289 }
2290 }
2291
2292 /*
2293 * c_time and s_time increments will typically be very small
2294 * (depending on machine speed and clock tick intervals), but
2295 * sampling over a large number of connections should result in
2296 * fairly accurate figures. We cannot guarantee a lot, however
2297 * -- if each connection lasts for exactly one clock tick, it
2298 * will be counted only for the client or only for the server or
2299 * even not at all.
2300 */
2301 *c_time += (clock() - c_clock);
2302 }
2303
2304 {
2305 /* SERVER */
2306
2307 char sbuf[1024 * 8];
2308 int i, r;
2309 clock_t s_clock = clock();
2310
2311 memset(sbuf, 0, sizeof(sbuf));
2312
2313 if (debug)
2314 if (SSL_in_init(s_ssl))
2315 printf("server waiting in SSL_accept - %s\n",
2316 SSL_state_string_long(s_ssl));
2317
2318 if (sw_num > 0) {
2319 /* Write to client. */
2320
2321 if (sw_num > (long)sizeof(sbuf))
2322 i = sizeof(sbuf);
2323 else
2324 i = (int)sw_num;
2325 r = BIO_write(s_ssl_bio, sbuf, i);
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 /* Ignore "BIO_should_retry". */
2333 } else if (r == 0) {
2334 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2335 goto err;
2336 } else {
2337 if (debug)
2338 printf("server wrote %d\n", r);
2339 sw_num -= r;
2340 }
2341 }
2342
2343 if (sr_num > 0) {
2344 /* Read from client. */
2345
2346 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2347 if (r < 0) {
2348 if (!BIO_should_retry(s_ssl_bio)) {
2349 fprintf(stderr, "ERROR in SERVER\n");
2350 err_in_server = 1;
2351 goto err;
2352 }
2353 /* blah, blah */
2354 } else if (r == 0) {
2355 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2356 goto err;
2357 } else {
2358 if (debug)
2359 printf("server read %d\n", r);
2360 sr_num -= r;
2361 }
2362 }
2363
2364 *s_time += (clock() - s_clock);
2365 }
2366
2367 {
2368 /* "I/O" BETWEEN CLIENT AND SERVER. */
2369
2370 size_t r1, r2;
2371 BIO *io1 = server_io, *io2 = client_io;
2372 /*
2373 * we use the non-copying interface for io1 and the standard
2374 * BIO_write/BIO_read interface for io2
2375 */
2376
2377 static int prev_progress = 1;
2378 int progress = 0;
2379
2380 /* io1 to io2 */
2381 do {
2382 size_t num;
2383 int r;
2384
2385 r1 = BIO_ctrl_pending(io1);
2386 r2 = BIO_ctrl_get_write_guarantee(io2);
2387
2388 num = r1;
2389 if (r2 < num)
2390 num = r2;
2391 if (num) {
2392 char *dataptr;
2393
2394 if (INT_MAX < num) /* yeah, right */
2395 num = INT_MAX;
2396
2397 r = BIO_nread(io1, &dataptr, (int)num);
2398 assert(r > 0);
2399 assert(r <= (int)num);
2400 /*
2401 * possibly r < num (non-contiguous data)
2402 */
2403 num = r;
2404 r = BIO_write(io2, dataptr, (int)num);
2405 if (r != (int)num) { /* can't happen */
2406 fprintf(stderr, "ERROR: BIO_write could not write "
2407 "BIO_ctrl_get_write_guarantee() bytes");
2408 goto err;
2409 }
2410 progress = 1;
2411
2412 if (debug)
2413 printf((io1 == client_io) ?
2414 "C->S relaying: %d bytes\n" :
2415 "S->C relaying: %d bytes\n", (int)num);
2416 }
2417 }
2418 while (r1 && r2);
2419
2420 /* io2 to io1 */
2421 {
2422 size_t num;
2423 int r;
2424
2425 r1 = BIO_ctrl_pending(io2);
2426 r2 = BIO_ctrl_get_read_request(io1);
2427 /*
2428 * here we could use ..._get_write_guarantee instead of
2429 * ..._get_read_request, but by using the latter we test
2430 * restartability of the SSL implementation more thoroughly
2431 */
2432 num = r1;
2433 if (r2 < num)
2434 num = r2;
2435 if (num) {
2436 char *dataptr;
2437
2438 if (INT_MAX < num)
2439 num = INT_MAX;
2440
2441 if (num > 1)
2442 --num; /* test restartability even more thoroughly */
2443
2444 r = BIO_nwrite0(io1, &dataptr);
2445 assert(r > 0);
2446 if (r < (int)num)
2447 num = r;
2448 r = BIO_read(io2, dataptr, (int)num);
2449 if (r != (int)num) { /* can't happen */
2450 fprintf(stderr, "ERROR: BIO_read could not read "
2451 "BIO_ctrl_pending() bytes");
2452 goto err;
2453 }
2454 progress = 1;
2455 r = BIO_nwrite(io1, &dataptr, (int)num);
2456 if (r != (int)num) { /* can't happen */
2457 fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
2458 "BIO_nwrite0() bytes");
2459 goto err;
2460 }
2461
2462 if (debug)
2463 printf((io2 == client_io) ?
2464 "C->S relaying: %d bytes\n" :
2465 "S->C relaying: %d bytes\n", (int)num);
2466 }
2467 } /* no loop, BIO_ctrl_get_read_request now
2468 * returns 0 anyway */
2469
2470 if (!progress && !prev_progress)
2471 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0) {
2472 fprintf(stderr, "ERROR: got stuck\n");
2473 fprintf(stderr, " ERROR.\n");
2474 goto err;
2475 }
2476 prev_progress = progress;
2477 }
2478 }
2479 while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2480
2481 if (verbose)
2482 print_details(c_ssl, "DONE via BIO pair: ");
2483 #ifndef OPENSSL_NO_NEXTPROTONEG
2484 if (verify_npn(c_ssl, s_ssl) < 0)
2485 goto end;
2486 #endif
2487 if (verify_serverinfo() < 0) {
2488 fprintf(stderr, "Server info verify error\n");
2489 goto err;
2490 }
2491 if (verify_alpn(c_ssl, s_ssl) < 0
2492 || verify_servername(c_ssl, s_ssl) < 0)
2493 goto err;
2494
2495 if (custom_ext_error) {
2496 fprintf(stderr, "Custom extension error\n");
2497 goto err;
2498 }
2499
2500 #ifndef OPENSSL_NO_NEXTPROTONEG
2501 end:
2502 #endif
2503 ret = EXIT_SUCCESS;
2504
2505 err:
2506 ERR_print_errors(bio_err);
2507
2508 BIO_free(server);
2509 BIO_free(server_io);
2510 BIO_free(client);
2511 BIO_free(client_io);
2512 BIO_free(s_ssl_bio);
2513 BIO_free(c_ssl_bio);
2514
2515 if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2516 ret = (err_in_client != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2517 else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2518 ret = (err_in_server != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2519
2520 return ret;
2521 }
2522
2523 #define W_READ 1
2524 #define W_WRITE 2
2525 #define C_DONE 1
2526 #define S_DONE 2
2527
2528 int doit(SSL *s_ssl, SSL *c_ssl, long count)
2529 {
2530 char *cbuf = NULL, *sbuf = NULL;
2531 long bufsiz;
2532 long cw_num = count, cr_num = count;
2533 long sw_num = count, sr_num = count;
2534 int ret = EXIT_FAILURE;
2535 BIO *c_to_s = NULL;
2536 BIO *s_to_c = NULL;
2537 BIO *c_bio = NULL;
2538 BIO *s_bio = NULL;
2539 int c_r, c_w, s_r, s_w;
2540 int i, j;
2541 int done = 0;
2542 int c_write, s_write;
2543 int do_server = 0, do_client = 0;
2544 int max_frag = 5 * 1024;
2545 int err_in_client = 0;
2546 int err_in_server = 0;
2547
2548 bufsiz = count > 40 * 1024 ? 40 * 1024 : count;
2549
2550 if ((cbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2551 goto err;
2552 if ((sbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2553 goto err;
2554
2555 c_to_s = BIO_new(BIO_s_mem());
2556 s_to_c = BIO_new(BIO_s_mem());
2557 if ((s_to_c == NULL) || (c_to_s == NULL)) {
2558 ERR_print_errors(bio_err);
2559 goto err;
2560 }
2561
2562 c_bio = BIO_new(BIO_f_ssl());
2563 s_bio = BIO_new(BIO_f_ssl());
2564 if ((c_bio == NULL) || (s_bio == NULL)) {
2565 ERR_print_errors(bio_err);
2566 goto err;
2567 }
2568
2569 SSL_set_connect_state(c_ssl);
2570 SSL_set_bio(c_ssl, s_to_c, c_to_s);
2571 SSL_set_max_send_fragment(c_ssl, max_frag);
2572 BIO_set_ssl(c_bio, c_ssl, BIO_NOCLOSE);
2573
2574 /*
2575 * We've just given our ref to these BIOs to c_ssl. We need another one to
2576 * give to s_ssl
2577 */
2578 if (!BIO_up_ref(c_to_s)) {
2579 /* c_to_s and s_to_c will get freed when we free c_ssl */
2580 c_to_s = NULL;
2581 s_to_c = NULL;
2582 goto err;
2583 }
2584 if (!BIO_up_ref(s_to_c)) {
2585 /* s_to_c will get freed when we free c_ssl */
2586 s_to_c = NULL;
2587 goto err;
2588 }
2589
2590 SSL_set_accept_state(s_ssl);
2591 SSL_set_bio(s_ssl, c_to_s, s_to_c);
2592
2593 /* We've used up all our refs to these now */
2594 c_to_s = NULL;
2595 s_to_c = NULL;
2596
2597 SSL_set_max_send_fragment(s_ssl, max_frag);
2598 BIO_set_ssl(s_bio, s_ssl, BIO_NOCLOSE);
2599
2600 c_r = 0;
2601 s_r = 1;
2602 c_w = 1;
2603 s_w = 0;
2604 c_write = 1, s_write = 0;
2605
2606 /* We can always do writes */
2607 for (;;) {
2608 do_server = 0;
2609 do_client = 0;
2610
2611 i = (int)BIO_pending(s_bio);
2612 if ((i && s_r) || s_w)
2613 do_server = 1;
2614
2615 i = (int)BIO_pending(c_bio);
2616 if ((i && c_r) || c_w)
2617 do_client = 1;
2618
2619 if (do_server && debug) {
2620 if (SSL_in_init(s_ssl))
2621 printf("server waiting in SSL_accept - %s\n",
2622 SSL_state_string_long(s_ssl));
2623 }
2624
2625 if (do_client && debug) {
2626 if (SSL_in_init(c_ssl))
2627 printf("client waiting in SSL_connect - %s\n",
2628 SSL_state_string_long(c_ssl));
2629 }
2630
2631 if (!do_client && !do_server) {
2632 fprintf(stdout, "ERROR IN STARTUP\n");
2633 ERR_print_errors(bio_err);
2634 goto err;
2635 }
2636 if (do_client && !(done & C_DONE)) {
2637 if (c_write) {
2638 j = (cw_num > bufsiz) ? (int)bufsiz : (int)cw_num;
2639 i = BIO_write(c_bio, cbuf, j);
2640 if (i < 0) {
2641 c_r = 0;
2642 c_w = 0;
2643 if (BIO_should_retry(c_bio)) {
2644 if (BIO_should_read(c_bio))
2645 c_r = 1;
2646 if (BIO_should_write(c_bio))
2647 c_w = 1;
2648 } else {
2649 fprintf(stderr, "ERROR in CLIENT\n");
2650 err_in_client = 1;
2651 ERR_print_errors(bio_err);
2652 goto err;
2653 }
2654 } else if (i == 0) {
2655 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2656 goto err;
2657 } else {
2658 if (debug)
2659 printf("client wrote %d\n", i);
2660 /* ok */
2661 s_r = 1;
2662 c_write = 0;
2663 cw_num -= i;
2664 if (max_frag > 1029)
2665 SSL_set_max_send_fragment(c_ssl, max_frag -= 5);
2666 }
2667 } else {
2668 i = BIO_read(c_bio, cbuf, bufsiz);
2669 if (i < 0) {
2670 c_r = 0;
2671 c_w = 0;
2672 if (BIO_should_retry(c_bio)) {
2673 if (BIO_should_read(c_bio))
2674 c_r = 1;
2675 if (BIO_should_write(c_bio))
2676 c_w = 1;
2677 } else {
2678 fprintf(stderr, "ERROR in CLIENT\n");
2679 err_in_client = 1;
2680 ERR_print_errors(bio_err);
2681 goto err;
2682 }
2683 } else if (i == 0) {
2684 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2685 goto err;
2686 } else {
2687 if (debug)
2688 printf("client read %d\n", i);
2689 cr_num -= i;
2690 if (sw_num > 0) {
2691 s_write = 1;
2692 s_w = 1;
2693 }
2694 if (cr_num <= 0) {
2695 s_write = 1;
2696 s_w = 1;
2697 done = S_DONE | C_DONE;
2698 }
2699 }
2700 }
2701 }
2702
2703 if (do_server && !(done & S_DONE)) {
2704 if (!s_write) {
2705 i = BIO_read(s_bio, sbuf, bufsiz);
2706 if (i < 0) {
2707 s_r = 0;
2708 s_w = 0;
2709 if (BIO_should_retry(s_bio)) {
2710 if (BIO_should_read(s_bio))
2711 s_r = 1;
2712 if (BIO_should_write(s_bio))
2713 s_w = 1;
2714 } else {
2715 fprintf(stderr, "ERROR in SERVER\n");
2716 err_in_server = 1;
2717 ERR_print_errors(bio_err);
2718 goto err;
2719 }
2720 } else if (i == 0) {
2721 ERR_print_errors(bio_err);
2722 fprintf(stderr,
2723 "SSL SERVER STARTUP FAILED in SSL_read\n");
2724 goto err;
2725 } else {
2726 if (debug)
2727 printf("server read %d\n", i);
2728 sr_num -= i;
2729 if (cw_num > 0) {
2730 c_write = 1;
2731 c_w = 1;
2732 }
2733 if (sr_num <= 0) {
2734 s_write = 1;
2735 s_w = 1;
2736 c_write = 0;
2737 }
2738 }
2739 } else {
2740 j = (sw_num > bufsiz) ? (int)bufsiz : (int)sw_num;
2741 i = BIO_write(s_bio, sbuf, j);
2742 if (i < 0) {
2743 s_r = 0;
2744 s_w = 0;
2745 if (BIO_should_retry(s_bio)) {
2746 if (BIO_should_read(s_bio))
2747 s_r = 1;
2748 if (BIO_should_write(s_bio))
2749 s_w = 1;
2750 } else {
2751 fprintf(stderr, "ERROR in SERVER\n");
2752 err_in_server = 1;
2753 ERR_print_errors(bio_err);
2754 goto err;
2755 }
2756 } else if (i == 0) {
2757 ERR_print_errors(bio_err);
2758 fprintf(stderr,
2759 "SSL SERVER STARTUP FAILED in SSL_write\n");
2760 goto err;
2761 } else {
2762 if (debug)
2763 printf("server wrote %d\n", i);
2764 sw_num -= i;
2765 s_write = 0;
2766 c_r = 1;
2767 if (sw_num <= 0)
2768 done |= S_DONE;
2769 if (max_frag > 1029)
2770 SSL_set_max_send_fragment(s_ssl, max_frag -= 5);
2771 }
2772 }
2773 }
2774
2775 if ((done & S_DONE) && (done & C_DONE))
2776 break;
2777 }
2778
2779 if (verbose)
2780 print_details(c_ssl, "DONE: ");
2781 #ifndef OPENSSL_NO_NEXTPROTONEG
2782 if (verify_npn(c_ssl, s_ssl) < 0)
2783 goto err;
2784 #endif
2785 if (verify_serverinfo() < 0) {
2786 fprintf(stderr, "Server info verify error\n");
2787 goto err;
2788 }
2789 if (custom_ext_error) {
2790 fprintf(stderr, "Custom extension error\n");
2791 goto err;
2792 }
2793 ret = EXIT_SUCCESS;
2794 err:
2795 BIO_free(c_to_s);
2796 BIO_free(s_to_c);
2797 BIO_free_all(c_bio);
2798 BIO_free_all(s_bio);
2799 OPENSSL_free(cbuf);
2800 OPENSSL_free(sbuf);
2801
2802 if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2803 ret = (err_in_client != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2804 else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2805 ret = (err_in_server != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2806
2807 return ret;
2808 }
2809
2810 static int verify_callback(int ok, X509_STORE_CTX *ctx)
2811 {
2812 char *s, buf[256];
2813
2814 s = X509_NAME_oneline(X509_get_subject_name(X509_STORE_CTX_get_current_cert(ctx)),
2815 buf, sizeof(buf));
2816 if (s != NULL) {
2817 if (ok)
2818 printf("depth=%d %s\n", X509_STORE_CTX_get_error_depth(ctx), buf);
2819 else {
2820 fprintf(stderr, "depth=%d error=%d %s\n",
2821 X509_STORE_CTX_get_error_depth(ctx),
2822 X509_STORE_CTX_get_error(ctx), buf);
2823 }
2824 }
2825
2826 if (ok == 0) {
2827 int i = X509_STORE_CTX_get_error(ctx);
2828
2829 switch (i) {
2830 default:
2831 fprintf(stderr, "Error string: %s\n",
2832 X509_verify_cert_error_string(i));
2833 break;
2834 case X509_V_ERR_CERT_NOT_YET_VALID:
2835 case X509_V_ERR_CERT_HAS_EXPIRED:
2836 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2837 ok = 1;
2838 break;
2839 }
2840 }
2841
2842 return ok;
2843 }
2844
2845 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2846 {
2847 int ok = 1;
2848 struct app_verify_arg *cb_arg = arg;
2849
2850 if (cb_arg->app_verify) {
2851 char *s = NULL, buf[256];
2852 X509 *c = X509_STORE_CTX_get0_cert(ctx);
2853
2854 printf("In app_verify_callback, allowing cert. ");
2855 printf("Arg is: %s\n", cb_arg->string);
2856 printf("Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2857 (void *)ctx, (void *)c);
2858 if (c)
2859 s = X509_NAME_oneline(X509_get_subject_name(c), buf, 256);
2860 if (s != NULL) {
2861 printf("cert depth=%d %s\n",
2862 X509_STORE_CTX_get_error_depth(ctx), buf);
2863 }
2864 return 1;
2865 }
2866
2867 ok = X509_verify_cert(ctx);
2868
2869 return ok;
2870 }
2871
2872 #ifndef OPENSSL_NO_DH
2873 /*-
2874 * These DH parameters have been generated as follows:
2875 * $ openssl dhparam -C -noout 512
2876 * $ openssl dhparam -C -noout 1024
2877 * $ openssl dhparam -C -noout -dsaparam 1024
2878 * (The third function has been renamed to avoid name conflicts.)
2879 */
2880 static DH *get_dh512(void)
2881 {
2882 static unsigned char dh512_p[] = {
2883 0xCB, 0xC8, 0xE1, 0x86, 0xD0, 0x1F, 0x94, 0x17, 0xA6, 0x99, 0xF0,
2884 0xC6,
2885 0x1F, 0x0D, 0xAC, 0xB6, 0x25, 0x3E, 0x06, 0x39, 0xCA, 0x72, 0x04,
2886 0xB0,
2887 0x6E, 0xDA, 0xC0, 0x61, 0xE6, 0x7A, 0x77, 0x25, 0xE8, 0x3B, 0xB9,
2888 0x5F,
2889 0x9A, 0xB6, 0xB5, 0xFE, 0x99, 0x0B, 0xA1, 0x93, 0x4E, 0x35, 0x33,
2890 0xB8,
2891 0xE1, 0xF1, 0x13, 0x4F, 0x59, 0x1A, 0xD2, 0x57, 0xC0, 0x26, 0x21,
2892 0x33,
2893 0x02, 0xC5, 0xAE, 0x23,
2894 };
2895 static unsigned char dh512_g[] = {
2896 0x02,
2897 };
2898 DH *dh;
2899 BIGNUM *p, *g;
2900
2901 if ((dh = DH_new()) == NULL)
2902 return NULL;
2903 p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
2904 g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
2905 if ((p == NULL) || (g == NULL) || !DH_set0_pqg(dh, p, NULL, g)) {
2906 DH_free(dh);
2907 BN_free(p);
2908 BN_free(g);
2909 return NULL;
2910 }
2911 return dh;
2912 }
2913
2914 static DH *get_dh1024(void)
2915 {
2916 static unsigned char dh1024_p[] = {
2917 0xF8, 0x81, 0x89, 0x7D, 0x14, 0x24, 0xC5, 0xD1, 0xE6, 0xF7, 0xBF,
2918 0x3A,
2919 0xE4, 0x90, 0xF4, 0xFC, 0x73, 0xFB, 0x34, 0xB5, 0xFA, 0x4C, 0x56,
2920 0xA2,
2921 0xEA, 0xA7, 0xE9, 0xC0, 0xC0, 0xCE, 0x89, 0xE1, 0xFA, 0x63, 0x3F,
2922 0xB0,
2923 0x6B, 0x32, 0x66, 0xF1, 0xD1, 0x7B, 0xB0, 0x00, 0x8F, 0xCA, 0x87,
2924 0xC2,
2925 0xAE, 0x98, 0x89, 0x26, 0x17, 0xC2, 0x05, 0xD2, 0xEC, 0x08, 0xD0,
2926 0x8C,
2927 0xFF, 0x17, 0x52, 0x8C, 0xC5, 0x07, 0x93, 0x03, 0xB1, 0xF6, 0x2F,
2928 0xB8,
2929 0x1C, 0x52, 0x47, 0x27, 0x1B, 0xDB, 0xD1, 0x8D, 0x9D, 0x69, 0x1D,
2930 0x52,
2931 0x4B, 0x32, 0x81, 0xAA, 0x7F, 0x00, 0xC8, 0xDC, 0xE6, 0xD9, 0xCC,
2932 0xC1,
2933 0x11, 0x2D, 0x37, 0x34, 0x6C, 0xEA, 0x02, 0x97, 0x4B, 0x0E, 0xBB,
2934 0xB1,
2935 0x71, 0x33, 0x09, 0x15, 0xFD, 0xDD, 0x23, 0x87, 0x07, 0x5E, 0x89,
2936 0xAB,
2937 0x6B, 0x7C, 0x5F, 0xEC, 0xA6, 0x24, 0xDC, 0x53,
2938 };
2939 static unsigned char dh1024_g[] = {
2940 0x02,
2941 };
2942 DH *dh;
2943 BIGNUM *p, *g;
2944
2945 if ((dh = DH_new()) == NULL)
2946 return NULL;
2947 p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
2948 g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
2949 if ((p == NULL) || (g == NULL) || !DH_set0_pqg(dh, p, NULL, g)) {
2950 DH_free(dh);
2951 BN_free(p);
2952 BN_free(g);
2953 return NULL;
2954 }
2955 return dh;
2956 }
2957
2958 static DH *get_dh1024dsa(void)
2959 {
2960 static unsigned char dh1024_p[] = {
2961 0xC8, 0x00, 0xF7, 0x08, 0x07, 0x89, 0x4D, 0x90, 0x53, 0xF3, 0xD5,
2962 0x00,
2963 0x21, 0x1B, 0xF7, 0x31, 0xA6, 0xA2, 0xDA, 0x23, 0x9A, 0xC7, 0x87,
2964 0x19,
2965 0x3B, 0x47, 0xB6, 0x8C, 0x04, 0x6F, 0xFF, 0xC6, 0x9B, 0xB8, 0x65,
2966 0xD2,
2967 0xC2, 0x5F, 0x31, 0x83, 0x4A, 0xA7, 0x5F, 0x2F, 0x88, 0x38, 0xB6,
2968 0x55,
2969 0xCF, 0xD9, 0x87, 0x6D, 0x6F, 0x9F, 0xDA, 0xAC, 0xA6, 0x48, 0xAF,
2970 0xFC,
2971 0x33, 0x84, 0x37, 0x5B, 0x82, 0x4A, 0x31, 0x5D, 0xE7, 0xBD, 0x52,
2972 0x97,
2973 0xA1, 0x77, 0xBF, 0x10, 0x9E, 0x37, 0xEA, 0x64, 0xFA, 0xCA, 0x28,
2974 0x8D,
2975 0x9D, 0x3B, 0xD2, 0x6E, 0x09, 0x5C, 0x68, 0xC7, 0x45, 0x90, 0xFD,
2976 0xBB,
2977 0x70, 0xC9, 0x3A, 0xBB, 0xDF, 0xD4, 0x21, 0x0F, 0xC4, 0x6A, 0x3C,
2978 0xF6,
2979 0x61, 0xCF, 0x3F, 0xD6, 0x13, 0xF1, 0x5F, 0xBC, 0xCF, 0xBC, 0x26,
2980 0x9E,
2981 0xBC, 0x0B, 0xBD, 0xAB, 0x5D, 0xC9, 0x54, 0x39,
2982 };
2983 static unsigned char dh1024_g[] = {
2984 0x3B, 0x40, 0x86, 0xE7, 0xF3, 0x6C, 0xDE, 0x67, 0x1C, 0xCC, 0x80,
2985 0x05,
2986 0x5A, 0xDF, 0xFE, 0xBD, 0x20, 0x27, 0x74, 0x6C, 0x24, 0xC9, 0x03,
2987 0xF3,
2988 0xE1, 0x8D, 0xC3, 0x7D, 0x98, 0x27, 0x40, 0x08, 0xB8, 0x8C, 0x6A,
2989 0xE9,
2990 0xBB, 0x1A, 0x3A, 0xD6, 0x86, 0x83, 0x5E, 0x72, 0x41, 0xCE, 0x85,
2991 0x3C,
2992 0xD2, 0xB3, 0xFC, 0x13, 0xCE, 0x37, 0x81, 0x9E, 0x4C, 0x1C, 0x7B,
2993 0x65,
2994 0xD3, 0xE6, 0xA6, 0x00, 0xF5, 0x5A, 0x95, 0x43, 0x5E, 0x81, 0xCF,
2995 0x60,
2996 0xA2, 0x23, 0xFC, 0x36, 0xA7, 0x5D, 0x7A, 0x4C, 0x06, 0x91, 0x6E,
2997 0xF6,
2998 0x57, 0xEE, 0x36, 0xCB, 0x06, 0xEA, 0xF5, 0x3D, 0x95, 0x49, 0xCB,
2999 0xA7,
3000 0xDD, 0x81, 0xDF, 0x80, 0x09, 0x4A, 0x97, 0x4D, 0xA8, 0x22, 0x72,
3001 0xA1,
3002 0x7F, 0xC4, 0x70, 0x56, 0x70, 0xE8, 0x20, 0x10, 0x18, 0x8F, 0x2E,
3003 0x60,
3004 0x07, 0xE7, 0x68, 0x1A, 0x82, 0x5D, 0x32, 0xA2,
3005 };
3006 DH *dh;
3007 BIGNUM *p, *g;
3008
3009 if ((dh = DH_new()) == NULL)
3010 return NULL;
3011 p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
3012 g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
3013 if ((p == NULL) || (g == NULL) || !DH_set0_pqg(dh, p, NULL, g)) {
3014 DH_free(dh);
3015 BN_free(p);
3016 BN_free(g);
3017 return NULL;
3018 }
3019 DH_set_length(dh, 160);
3020 return dh;
3021 }
3022 #endif
3023
3024 #ifndef OPENSSL_NO_PSK
3025 /* convert the PSK key (psk_key) in ascii to binary (psk) */
3026 static int psk_key2bn(const char *pskkey, unsigned char *psk,
3027 unsigned int max_psk_len)
3028 {
3029 int ret;
3030 BIGNUM *bn = NULL;
3031
3032 ret = BN_hex2bn(&bn, pskkey);
3033 if (!ret) {
3034 BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
3035 pskkey);
3036 BN_free(bn);
3037 return 0;
3038 }
3039 if (BN_num_bytes(bn) > (int)max_psk_len) {
3040 BIO_printf(bio_err,
3041 "psk buffer of callback is too small (%d) for key (%d)\n",
3042 max_psk_len, BN_num_bytes(bn));
3043 BN_free(bn);
3044 return 0;
3045 }
3046 ret = BN_bn2bin(bn, psk);
3047 BN_free(bn);
3048 return ret;
3049 }
3050
3051 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
3052 char *identity,
3053 unsigned int max_identity_len,
3054 unsigned char *psk,
3055 unsigned int max_psk_len)
3056 {
3057 int ret;
3058 unsigned int psk_len = 0;
3059
3060 ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3061 if (ret < 0)
3062 goto out_err;
3063 if (debug)
3064 fprintf(stderr, "client: created identity '%s' len=%d\n", identity,
3065 ret);
3066 ret = psk_key2bn(psk_key, psk, max_psk_len);
3067 if (ret < 0)
3068 goto out_err;
3069 psk_len = ret;
3070 out_err:
3071 return psk_len;
3072 }
3073
3074 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3075 unsigned char *psk,
3076 unsigned int max_psk_len)
3077 {
3078 unsigned int psk_len = 0;
3079
3080 if (strcmp(identity, "Client_identity") != 0) {
3081 BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3082 return 0;
3083 }
3084 psk_len = psk_key2bn(psk_key, psk, max_psk_len);
3085 return psk_len;
3086 }
3087 #endif
A mirror of the official openssl repository