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