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