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