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