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