ssl_old_test.c@ 94403

最後變更在這個檔案從94403是 94320,由 vboxsync 提交於 3 年前
libs/openssl-3.0.1: Export to OSE and fix copyright headers in Makefiles, bugref:10128
檔案大小: 96.3 KB

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

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/libs/openssl-3.0.2/test/ssl_old_test.c@ 94403

以其他格式下載: