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