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