]> git.ipfire.org Git - thirdparty/openssl.git/blob - test/ssltest_old.c
projects / thirdparty / openssl.git / blob
? search:


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