blob: da9391a0c800d654ac3bd50f483a3274d742fd4e [file] [log] [blame]
Ralf S. Engelschall58964a41998-12-21 10:56:39 +00001/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002 * 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.
Matt Caswell0f113f32015-01-22 03:40:55 +00007 *
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00008 * 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).
Matt Caswell0f113f32015-01-22 03:40:55 +000014 *
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +000015 * 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.
Matt Caswell0f113f32015-01-22 03:40:55 +000021 *
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +000022 * 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 :-).
Matt Caswell0f113f32015-01-22 03:40:55 +000036 * 4. If you include any Windows specific code (or a derivative thereof) from
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +000037 * the apps directory (application code) you must include an acknowledgement:
38 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
Matt Caswell0f113f32015-01-22 03:40:55 +000039 *
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +000040 * 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.
Matt Caswell0f113f32015-01-22 03:40:55 +000051 *
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +000052 * 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 */
Bodo Möller3ac82fa2000-12-15 16:40:35 +000057/* ====================================================================
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
Matt Caswell0f113f32015-01-22 03:40:55 +000065 * notice, this list of conditions and the following disclaimer.
Bodo Möller3ac82fa2000-12-15 16:40:35 +000066 *
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 */
Bodo Möllerea262262002-08-09 08:56:08 +0000110/* ====================================================================
111 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
Matt Caswell0f113f32015-01-22 03:40:55 +0000112 * ECC cipher suite support in OpenSSL originally developed by
Bodo Möllerea262262002-08-09 08:56:08 +0000113 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
114 */
Nils Larschddac1972006-03-10 23:06:27 +0000115/* ====================================================================
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 */
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +0000141
Matt Caswelldbd87ff2015-01-21 11:09:58 +0000142/* Or gethostname won't be declared properly on Linux and GNU platforms. */
143#define _BSD_SOURCE 1
Richard Levittef9fd3522015-12-02 18:18:03 +0100144#define _DEFAULT_SOURCE 1
Richard Levitte37289742001-07-31 08:50:20 +0000145
Bodo Möller6f7af151999-09-10 14:03:21 +0000146#include <assert.h>
147#include <errno.h>
148#include <limits.h>
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +0000149#include <stdio.h>
150#include <stdlib.h>
151#include <string.h>
Bodo Möller563f1502000-03-13 15:06:54 +0000152#include <time.h>
Bodo Möller17e3dd11999-05-20 21:59:20 +0000153
Richard Levittee7a28562002-12-02 22:49:02 +0000154#define USE_SOCKETS
Richard Levitte41d2a332001-02-22 14:45:02 +0000155#include "e_os.h"
Bodo Möller17e3dd11999-05-20 21:59:20 +0000156
Dr. Stephen Hensonbc120a52010-01-24 16:57:20 +0000157#ifdef OPENSSL_SYS_VMS
Matt Caswell0f113f32015-01-22 03:40:55 +0000158/*
159 * Or isascii won't be declared properly on VMS (at least with DECompHP C).
160 */
161# define _XOPEN_SOURCE 500
Dr. Stephen Hensonbc120a52010-01-24 16:57:20 +0000162#endif
163
Richard Levittea9633952005-01-19 17:03:07 +0000164#include <ctype.h>
165
Bodo Möllerec577821999-04-23 22:13:45 +0000166#include <openssl/bio.h>
167#include <openssl/crypto.h>
Bodo Möller563f1502000-03-13 15:06:54 +0000168#include <openssl/evp.h>
Bodo Möllerec577821999-04-23 22:13:45 +0000169#include <openssl/x509.h>
Richard Levittea7201e92005-01-17 17:06:58 +0000170#include <openssl/x509v3.h>
Bodo Möllerec577821999-04-23 22:13:45 +0000171#include <openssl/ssl.h>
Richard Levitte0b13e9f2003-01-30 17:39:26 +0000172#ifndef OPENSSL_NO_ENGINE
Matt Caswell0f113f32015-01-22 03:40:55 +0000173# include <openssl/engine.h>
Richard Levitte0b13e9f2003-01-30 17:39:26 +0000174#endif
Bodo Möllerec577821999-04-23 22:13:45 +0000175#include <openssl/err.h>
Ulf Möllerb9d82f42000-01-16 12:21:22 +0000176#include <openssl/rand.h>
Nils Larsch3eeaab42005-07-16 12:37:36 +0000177#ifndef OPENSSL_NO_RSA
Matt Caswell0f113f32015-01-22 03:40:55 +0000178# include <openssl/rsa.h>
Nils Larsch3eeaab42005-07-16 12:37:36 +0000179#endif
180#ifndef OPENSSL_NO_DSA
Matt Caswell0f113f32015-01-22 03:40:55 +0000181# include <openssl/dsa.h>
Nils Larsch3eeaab42005-07-16 12:37:36 +0000182#endif
183#ifndef OPENSSL_NO_DH
Matt Caswell0f113f32015-01-22 03:40:55 +0000184# include <openssl/dh.h>
Nils Larsch3eeaab42005-07-16 12:37:36 +0000185#endif
Ben Laurieedc032b2011-03-12 17:01:19 +0000186#ifndef OPENSSL_NO_SRP
Matt Caswell0f113f32015-01-22 03:40:55 +0000187# include <openssl/srp.h>
Ben Laurieedc032b2011-03-12 17:01:19 +0000188#endif
Geoff Thorped095b682004-05-17 18:53:47 +0000189#include <openssl/bn.h>
Rob Percivaldd696a52016-03-02 13:34:05 +0000190#ifndef OPENSSL_NO_CT
191# include <openssl/ct.h>
192#endif
Richard Levitte09867a42002-12-19 19:39:30 +0000193
Matt Caswellb6ba4012015-01-27 20:11:24 +0000194#include "../ssl/ssl_locl.h"
195
Matt Caswelldbd87ff2015-01-21 11:09:58 +0000196/*
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...
Matt Caswell0f113f32015-01-22 03:40:55 +0000201 */
202#define _XOPEN_SOURCE_EXTENDED 1
Richard Levitte09867a42002-12-19 19:39:30 +0000203
Richard Levittebc36ee62001-02-20 08:13:47 +0000204#ifdef OPENSSL_SYS_WINDOWS
Matt Caswell0f113f32015-01-22 03:40:55 +0000205# include <winsock.h>
Richard Levitte37289742001-07-31 08:50:20 +0000206#else
Matt Caswell0f113f32015-01-22 03:40:55 +0000207# include OPENSSL_UNISTD
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +0000208#endif
209
Matt Caswell0f113f32015-01-22 03:40:55 +0000210/*
Rich Salz45ddce22015-05-02 11:19:06 -0400211 * There is really no standard for this, so let's assign something
212 * only for this test
Matt Caswell0f113f32015-01-22 03:40:55 +0000213 */
Matt Caswell0f113f32015-01-22 03:40:55 +0000214#define COMP_ZLIB 1
Richard Levitte23f80f42000-11-30 11:57:31 +0000215
Rich Salz6d23cf92015-01-12 17:29:26 -0500216static int verify_callback(int ok, X509_STORE_CTX *ctx);
Rich Salz6d23cf92015-01-12 17:29:26 -0500217static int app_verify_callback(X509_STORE_CTX *ctx, void *arg);
Richard Levittea7201e92005-01-17 17:06:58 +0000218#define APP_CALLBACK_STRING "Test Callback Argument"
Matt Caswell0f113f32015-01-22 03:40:55 +0000219struct app_verify_arg {
220 char *string;
221 int app_verify;
222 int allow_proxy_certs;
223 char *proxy_auth;
224 char *proxy_cond;
225};
Bodo Möller023ec152002-02-28 10:52:56 +0000226
Richard Levittebc36ee62001-02-20 08:13:47 +0000227#ifndef OPENSSL_NO_DH
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +0000228static DH *get_dh512(void);
Bodo Möllere4589582000-03-10 13:23:20 +0000229static DH *get_dh1024(void);
230static DH *get_dh1024dsa(void);
Bodo Möller53002dc2000-02-04 11:21:18 +0000231#endif
232
Matt Caswell0f113f32015-01-22 03:40:55 +0000233static char *psk_key = NULL; /* by default PSK is not used */
Nils Larschddac1972006-03-10 23:06:27 +0000234#ifndef OPENSSL_NO_PSK
Matt Caswell0f113f32015-01-22 03:40:55 +0000235static 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);
Nils Larschddac1972006-03-10 23:06:27 +0000243#endif
244
Ben Laurieedc032b2011-03-12 17:01:19 +0000245#ifndef OPENSSL_NO_SRP
246/* SRP client */
247/* This is a context that we pass to all callbacks */
Matt Caswell0f113f32015-01-22 03:40:55 +0000248typedef struct srp_client_arg_st {
249 char *srppassin;
250 char *srplogin;
251} SRP_CLIENT_ARG;
Ben Laurieedc032b2011-03-12 17:01:19 +0000252
Matt Caswell0f113f32015-01-22 03:40:55 +0000253# define PWD_STRLEN 1024
Ben Laurieedc032b2011-03-12 17:01:19 +0000254
Matt Caswell0f113f32015-01-22 03:40:55 +0000255static char *ssl_give_srp_client_pwd_cb(SSL *s, void *arg)
256{
257 SRP_CLIENT_ARG *srp_client_arg = (SRP_CLIENT_ARG *)arg;
Rich Salz7644a9a2015-12-16 16:12:24 -0500258 return OPENSSL_strdup((char *)srp_client_arg->srppassin);
Matt Caswell0f113f32015-01-22 03:40:55 +0000259}
Ben Laurieedc032b2011-03-12 17:01:19 +0000260
Ben Laurieedc032b2011-03-12 17:01:19 +0000261/* SRP server */
262/* This is a context that we pass to SRP server callbacks */
Matt Caswell0f113f32015-01-22 03:40:55 +0000263typedef struct srp_server_arg_st {
264 char *expected_user;
265 char *pass;
266} SRP_SERVER_ARG;
Ben Laurieedc032b2011-03-12 17:01:19 +0000267
Rich Salz6d23cf92015-01-12 17:29:26 -0500268static int ssl_srp_server_param_cb(SSL *s, int *ad, void *arg)
Matt Caswell0f113f32015-01-22 03:40:55 +0000269{
270 SRP_SERVER_ARG *p = (SRP_SERVER_ARG *)arg;
Ben Laurieedc032b2011-03-12 17:01:19 +0000271
Matt Caswell0f113f32015-01-22 03:40:55 +0000272 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}
Ben Laurieedc032b2011-03-12 17:01:19 +0000282#endif
283
Matt Caswell0f113f32015-01-22 03:40:55 +0000284static BIO *bio_err = NULL;
285static BIO *bio_stdout = NULL;
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +0000286
Piotr Sikora29115752013-11-13 15:20:22 -0800287#ifndef OPENSSL_NO_NEXTPROTONEG
Ben Lauried9a268b2010-09-05 16:35:10 +0000288/* Note that this code assumes that this is only a one element list: */
289static const char NEXT_PROTO_STRING[] = "\x09testproto";
Ben Lauriedf2ee0e2015-09-05 13:32:58 +0100290static int npn_client = 0;
291static int npn_server = 0;
292static int npn_server_reject = 0;
Ben Lauried9a268b2010-09-05 16:35:10 +0000293
Matt Caswell0f113f32015-01-22 03:40:55 +0000294static 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}
Ben Lauried9a268b2010-09-05 16:35:10 +0000307
Matt Caswell0f113f32015-01-22 03:40:55 +0000308static 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}
Ben Lauried9a268b2010-09-05 16:35:10 +0000315
Matt Caswell0f113f32015-01-22 03:40:55 +0000316static 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}
Ben Lauried9a268b2010-09-05 16:35:10 +0000321
322static int verify_npn(SSL *client, SSL *server)
Matt Caswell0f113f32015-01-22 03:40:55 +0000323{
324 const unsigned char *client_s;
325 unsigned client_len;
326 const unsigned char *server_s;
327 unsigned server_len;
Ben Lauried9a268b2010-09-05 16:35:10 +0000328
Matt Caswell0f113f32015-01-22 03:40:55 +0000329 SSL_get0_next_proto_negotiated(client, &client_s, &client_len);
330 SSL_get0_next_proto_negotiated(server, &server_s, &server_len);
Ben Lauried9a268b2010-09-05 16:35:10 +0000331
Matt Caswell0f113f32015-01-22 03:40:55 +0000332 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 }
Ben Lauried9a268b2010-09-05 16:35:10 +0000337
Matt Caswell0f113f32015-01-22 03:40:55 +0000338 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 }
Ben Lauried9a268b2010-09-05 16:35:10 +0000343
Matt Caswell0f113f32015-01-22 03:40:55 +0000344 /*
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;
Ben Lauried9a268b2010-09-05 16:35:10 +0000354
Matt Caswell0f113f32015-01-22 03:40:55 +0000355 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;
Ben Lauried9a268b2010-09-05 16:35:10 +0000363
Matt Caswell0f113f32015-01-22 03:40:55 +0000364 return 0;
365}
Ben Lauried9a268b2010-09-05 16:35:10 +0000366#endif
367
Adam Langleya8989362013-07-15 15:57:16 -0400368static const char *alpn_client;
369static const char *alpn_server;
370static const char *alpn_expected;
371static unsigned char *alpn_selected;
Kurt Roeckx7946ab32015-12-06 17:56:41 +0100372static const char *server_min_proto;
373static const char *server_max_proto;
374static const char *client_min_proto;
375static const char *client_max_proto;
376static const char *should_negotiate;
Adam Langleya8989362013-07-15 15:57:16 -0400377
Matt Caswell3a834622015-01-05 00:34:00 +0000378/*-
379 * next_protos_parse parses a comma separated list of strings into a string
Adam Langleya8989362013-07-15 15:57:16 -0400380 * in a format suitable for passing to SSL_CTX_set_next_protos_advertised.
381 * outlen: (output) set to the length of the resulting buffer on success.
382 * err: (maybe NULL) on failure, an error message line is written to this BIO.
Kurt Cancemi4eadd112014-09-09 13:48:00 -0400383 * in: a NUL terminated string like "abc,def,ghi"
Adam Langleya8989362013-07-15 15:57:16 -0400384 *
385 * returns: a malloced buffer or NULL on failure.
386 */
Matt Caswell0f113f32015-01-22 03:40:55 +0000387static unsigned char *next_protos_parse(unsigned short *outlen,
388 const char *in)
389{
390 size_t len;
391 unsigned char *out;
392 size_t i, start = 0;
Adam Langleya8989362013-07-15 15:57:16 -0400393
Matt Caswell0f113f32015-01-22 03:40:55 +0000394 len = strlen(in);
395 if (len >= 65535)
396 return NULL;
Adam Langleya8989362013-07-15 15:57:16 -0400397
Matt Caswell0f113f32015-01-22 03:40:55 +0000398 out = OPENSSL_malloc(strlen(in) + 1);
399 if (!out)
400 return NULL;
Adam Langleya8989362013-07-15 15:57:16 -0400401
Matt Caswell0f113f32015-01-22 03:40:55 +0000402 for (i = 0; i <= len; ++i) {
403 if (i == len || in[i] == ',') {
404 if (i - start > 255) {
405 OPENSSL_free(out);
406 return NULL;
407 }
408 out[start] = i - start;
409 start = i + 1;
410 } else
411 out[i + 1] = in[i];
412 }
Adam Langleya8989362013-07-15 15:57:16 -0400413
Matt Caswell0f113f32015-01-22 03:40:55 +0000414 *outlen = len + 1;
415 return out;
416}
Adam Langleya8989362013-07-15 15:57:16 -0400417
Matt Caswell0f113f32015-01-22 03:40:55 +0000418static int cb_server_alpn(SSL *s, const unsigned char **out,
419 unsigned char *outlen, const unsigned char *in,
420 unsigned int inlen, void *arg)
421{
422 unsigned char *protos;
423 unsigned short protos_len;
Adam Langleya8989362013-07-15 15:57:16 -0400424
Matt Caswell0f113f32015-01-22 03:40:55 +0000425 protos = next_protos_parse(&protos_len, alpn_server);
426 if (protos == NULL) {
427 fprintf(stderr, "failed to parser ALPN server protocol string: %s\n",
428 alpn_server);
429 abort();
430 }
Adam Langleya8989362013-07-15 15:57:16 -0400431
Matt Caswell0f113f32015-01-22 03:40:55 +0000432 if (SSL_select_next_proto
433 ((unsigned char **)out, outlen, protos, protos_len, in,
434 inlen) != OPENSSL_NPN_NEGOTIATED) {
435 OPENSSL_free(protos);
436 return SSL_TLSEXT_ERR_NOACK;
437 }
Adam Langleya8989362013-07-15 15:57:16 -0400438
Matt Caswell0f113f32015-01-22 03:40:55 +0000439 /*
440 * Make a copy of the selected protocol which will be freed in
441 * verify_alpn.
442 */
443 alpn_selected = OPENSSL_malloc(*outlen);
444 memcpy(alpn_selected, *out, *outlen);
445 *out = alpn_selected;
Adam Langleya8989362013-07-15 15:57:16 -0400446
Matt Caswell0f113f32015-01-22 03:40:55 +0000447 OPENSSL_free(protos);
448 return SSL_TLSEXT_ERR_OK;
449}
Adam Langleya8989362013-07-15 15:57:16 -0400450
451static int verify_alpn(SSL *client, SSL *server)
Matt Caswell0f113f32015-01-22 03:40:55 +0000452{
453 const unsigned char *client_proto, *server_proto;
454 unsigned int client_proto_len = 0, server_proto_len = 0;
455 SSL_get0_alpn_selected(client, &client_proto, &client_proto_len);
456 SSL_get0_alpn_selected(server, &server_proto, &server_proto_len);
Adam Langleya8989362013-07-15 15:57:16 -0400457
Rich Salzb548a1f2015-05-01 10:02:07 -0400458 OPENSSL_free(alpn_selected);
459 alpn_selected = NULL;
Adam Langleya8989362013-07-15 15:57:16 -0400460
Alessandro Ghedini3003e0a2015-10-17 21:28:25 +0200461 if (client_proto_len != server_proto_len) {
462 BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");
463 goto err;
464 }
465
466 if (client_proto != NULL &&
Matt Caswell0f113f32015-01-22 03:40:55 +0000467 memcmp(client_proto, server_proto, client_proto_len) != 0) {
468 BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");
469 goto err;
470 }
Adam Langleya8989362013-07-15 15:57:16 -0400471
Matt Caswell0f113f32015-01-22 03:40:55 +0000472 if (client_proto_len > 0 && alpn_expected == NULL) {
473 BIO_printf(bio_stdout, "ALPN unexpectedly negotiated\n");
474 goto err;
475 }
Adam Langleya8989362013-07-15 15:57:16 -0400476
Matt Caswell0f113f32015-01-22 03:40:55 +0000477 if (alpn_expected != NULL &&
478 (client_proto_len != strlen(alpn_expected) ||
479 memcmp(client_proto, alpn_expected, client_proto_len) != 0)) {
480 BIO_printf(bio_stdout,
481 "ALPN selected protocols not equal to expected protocol: %s\n",
482 alpn_expected);
483 goto err;
484 }
Adam Langleya8989362013-07-15 15:57:16 -0400485
Matt Caswell0f113f32015-01-22 03:40:55 +0000486 return 0;
Adam Langleya8989362013-07-15 15:57:16 -0400487
Matt Caswell0f113f32015-01-22 03:40:55 +0000488 err:
489 BIO_printf(bio_stdout, "ALPN results: client: '");
490 BIO_write(bio_stdout, client_proto, client_proto_len);
491 BIO_printf(bio_stdout, "', server: '");
492 BIO_write(bio_stdout, server_proto, server_proto_len);
493 BIO_printf(bio_stdout, "'\n");
494 BIO_printf(bio_stdout, "ALPN configured: client: '%s', server: '%s'\n",
495 alpn_client, alpn_server);
496 return -1;
497}
Adam Langleya8989362013-07-15 15:57:16 -0400498
Matt Caswell0f113f32015-01-22 03:40:55 +0000499/*
500 * WARNING : below extension types are *NOT* IETF assigned, and could
501 * conflict if these types are reassigned and handled specially by OpenSSL
502 * in the future
503 */
Trevora398f822013-05-12 18:55:27 -0700504#define TACK_EXT_TYPE 62208
Trevor9cd50f72013-06-13 22:36:45 -0700505#define CUSTOM_EXT_TYPE_0 1000
506#define CUSTOM_EXT_TYPE_1 1001
507#define CUSTOM_EXT_TYPE_2 1002
508#define CUSTOM_EXT_TYPE_3 1003
509
Ben Lauriedf2ee0e2015-09-05 13:32:58 +0100510static const char custom_ext_cli_string[] = "abc";
511static const char custom_ext_srv_string[] = "defg";
Trevora398f822013-05-12 18:55:27 -0700512
513/* These set from cmdline */
Ben Lauriedf2ee0e2015-09-05 13:32:58 +0100514static char *serverinfo_file = NULL;
515static int serverinfo_sct = 0;
516static int serverinfo_tack = 0;
Trevor9cd50f72013-06-13 22:36:45 -0700517
518/* These set based on extension callbacks */
Ben Lauriedf2ee0e2015-09-05 13:32:58 +0100519static int serverinfo_sct_seen = 0;
520static int serverinfo_tack_seen = 0;
521static int serverinfo_other_seen = 0;
Trevora398f822013-05-12 18:55:27 -0700522
Trevor9cd50f72013-06-13 22:36:45 -0700523/* This set from cmdline */
Ben Lauriedf2ee0e2015-09-05 13:32:58 +0100524static int custom_ext = 0;
Trevor9cd50f72013-06-13 22:36:45 -0700525
526/* This set based on extension callbacks */
Ben Lauriedf2ee0e2015-09-05 13:32:58 +0100527static int custom_ext_error = 0;
Trevor9cd50f72013-06-13 22:36:45 -0700528
Dr. Stephen Henson0cfefe42014-08-19 14:02:50 +0100529static int serverinfo_cli_parse_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000530 const unsigned char *in, size_t inlen,
531 int *al, void *arg)
532{
Rob Percivaldd696a52016-03-02 13:34:05 +0000533 if (ext_type == TLSEXT_TYPE_signed_certificate_timestamp)
Matt Caswell0f113f32015-01-22 03:40:55 +0000534 serverinfo_sct_seen++;
535 else if (ext_type == TACK_EXT_TYPE)
536 serverinfo_tack_seen++;
537 else
538 serverinfo_other_seen++;
539 return 1;
540}
Trevora398f822013-05-12 18:55:27 -0700541
542static int verify_serverinfo()
Matt Caswell0f113f32015-01-22 03:40:55 +0000543{
544 if (serverinfo_sct != serverinfo_sct_seen)
545 return -1;
546 if (serverinfo_tack != serverinfo_tack_seen)
547 return -1;
548 if (serverinfo_other_seen)
549 return -1;
550 return 0;
551}
Trevora398f822013-05-12 18:55:27 -0700552
Tim Hudson1d97c842014-12-28 12:48:40 +1000553/*-
554 * Four test cases for custom extensions:
Trevor9cd50f72013-06-13 22:36:45 -0700555 * 0 - no ClientHello extension or ServerHello response
556 * 1 - ClientHello with "abc", no response
557 * 2 - ClientHello with "abc", empty response
558 * 3 - ClientHello with "abc", "defg" response
559 */
560
Dr. Stephen Hensonde2a9e32014-08-14 13:25:50 +0100561static int custom_ext_0_cli_add_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000562 const unsigned char **out,
563 size_t *outlen, int *al, void *arg)
564{
565 if (ext_type != CUSTOM_EXT_TYPE_0)
566 custom_ext_error = 1;
567 return 0; /* Don't send an extension */
568}
Trevor9cd50f72013-06-13 22:36:45 -0700569
Dr. Stephen Hensonde2a9e32014-08-14 13:25:50 +0100570static int custom_ext_0_cli_parse_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000571 const unsigned char *in,
572 size_t inlen, int *al, void *arg)
573{
574 return 1;
575}
Trevor9cd50f72013-06-13 22:36:45 -0700576
Dr. Stephen Hensonde2a9e32014-08-14 13:25:50 +0100577static int custom_ext_1_cli_add_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000578 const unsigned char **out,
579 size_t *outlen, int *al, void *arg)
580{
581 if (ext_type != CUSTOM_EXT_TYPE_1)
582 custom_ext_error = 1;
583 *out = (const unsigned char *)custom_ext_cli_string;
584 *outlen = strlen(custom_ext_cli_string);
585 return 1; /* Send "abc" */
586}
Trevor9cd50f72013-06-13 22:36:45 -0700587
Dr. Stephen Hensonde2a9e32014-08-14 13:25:50 +0100588static int custom_ext_1_cli_parse_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000589 const unsigned char *in,
590 size_t inlen, int *al, void *arg)
591{
592 return 1;
593}
Trevor9cd50f72013-06-13 22:36:45 -0700594
Dr. Stephen Hensonde2a9e32014-08-14 13:25:50 +0100595static int custom_ext_2_cli_add_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000596 const unsigned char **out,
597 size_t *outlen, int *al, void *arg)
598{
599 if (ext_type != CUSTOM_EXT_TYPE_2)
600 custom_ext_error = 1;
601 *out = (const unsigned char *)custom_ext_cli_string;
602 *outlen = strlen(custom_ext_cli_string);
603 return 1; /* Send "abc" */
604}
Trevor9cd50f72013-06-13 22:36:45 -0700605
Dr. Stephen Hensonde2a9e32014-08-14 13:25:50 +0100606static int custom_ext_2_cli_parse_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000607 const unsigned char *in,
608 size_t inlen, int *al, void *arg)
609{
610 if (ext_type != CUSTOM_EXT_TYPE_2)
611 custom_ext_error = 1;
612 if (inlen != 0)
613 custom_ext_error = 1; /* Should be empty response */
614 return 1;
615}
Trevor9cd50f72013-06-13 22:36:45 -0700616
Dr. Stephen Hensonde2a9e32014-08-14 13:25:50 +0100617static int custom_ext_3_cli_add_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000618 const unsigned char **out,
619 size_t *outlen, int *al, void *arg)
620{
621 if (ext_type != CUSTOM_EXT_TYPE_3)
622 custom_ext_error = 1;
623 *out = (const unsigned char *)custom_ext_cli_string;
624 *outlen = strlen(custom_ext_cli_string);
625 return 1; /* Send "abc" */
626}
Trevor9cd50f72013-06-13 22:36:45 -0700627
Dr. Stephen Hensonde2a9e32014-08-14 13:25:50 +0100628static int custom_ext_3_cli_parse_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000629 const unsigned char *in,
630 size_t inlen, int *al, void *arg)
631{
632 if (ext_type != CUSTOM_EXT_TYPE_3)
633 custom_ext_error = 1;
634 if (inlen != strlen(custom_ext_srv_string))
635 custom_ext_error = 1;
636 if (memcmp(custom_ext_srv_string, in, inlen) != 0)
637 custom_ext_error = 1; /* Check for "defg" */
638 return 1;
639}
Trevor9cd50f72013-06-13 22:36:45 -0700640
Matt Caswell0f113f32015-01-22 03:40:55 +0000641/*
642 * custom_ext_0_cli_add_cb returns 0 - the server won't receive a callback
643 * for this extension
644 */
Dr. Stephen Hensonde2a9e32014-08-14 13:25:50 +0100645static int custom_ext_0_srv_parse_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000646 const unsigned char *in,
647 size_t inlen, int *al, void *arg)
648{
649 custom_ext_error = 1;
650 return 1;
651}
Trevor9cd50f72013-06-13 22:36:45 -0700652
Dr. Stephen Hensonf47e2032014-08-26 01:20:26 +0100653/* 'add' callbacks are only called if the 'parse' callback is called */
Dr. Stephen Hensonde2a9e32014-08-14 13:25:50 +0100654static int custom_ext_0_srv_add_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000655 const unsigned char **out,
656 size_t *outlen, int *al, void *arg)
657{
658 /* Error: should not have been called */
659 custom_ext_error = 1;
660 return 0; /* Don't send an extension */
661}
Trevor9cd50f72013-06-13 22:36:45 -0700662
Dr. Stephen Hensonde2a9e32014-08-14 13:25:50 +0100663static int custom_ext_1_srv_parse_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000664 const unsigned char *in,
665 size_t inlen, int *al, void *arg)
666{
667 if (ext_type != CUSTOM_EXT_TYPE_1)
668 custom_ext_error = 1;
669 /* Check for "abc" */
670 if (inlen != strlen(custom_ext_cli_string))
671 custom_ext_error = 1;
672 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
673 custom_ext_error = 1;
674 return 1;
675}
Trevor9cd50f72013-06-13 22:36:45 -0700676
Dr. Stephen Hensonde2a9e32014-08-14 13:25:50 +0100677static int custom_ext_1_srv_add_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000678 const unsigned char **out,
679 size_t *outlen, int *al, void *arg)
680{
681 return 0; /* Don't send an extension */
682}
Trevor9cd50f72013-06-13 22:36:45 -0700683
Dr. Stephen Hensonde2a9e32014-08-14 13:25:50 +0100684static int custom_ext_2_srv_parse_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000685 const unsigned char *in,
686 size_t inlen, int *al, void *arg)
687{
688 if (ext_type != CUSTOM_EXT_TYPE_2)
689 custom_ext_error = 1;
690 /* Check for "abc" */
691 if (inlen != strlen(custom_ext_cli_string))
692 custom_ext_error = 1;
693 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
694 custom_ext_error = 1;
695 return 1;
696}
Trevor9cd50f72013-06-13 22:36:45 -0700697
Dr. Stephen Hensonde2a9e32014-08-14 13:25:50 +0100698static int custom_ext_2_srv_add_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000699 const unsigned char **out,
700 size_t *outlen, int *al, void *arg)
701{
702 *out = NULL;
703 *outlen = 0;
704 return 1; /* Send empty extension */
705}
Trevor9cd50f72013-06-13 22:36:45 -0700706
Dr. Stephen Hensonde2a9e32014-08-14 13:25:50 +0100707static int custom_ext_3_srv_parse_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000708 const unsigned char *in,
709 size_t inlen, int *al, void *arg)
710{
711 if (ext_type != CUSTOM_EXT_TYPE_3)
712 custom_ext_error = 1;
713 /* Check for "abc" */
714 if (inlen != strlen(custom_ext_cli_string))
715 custom_ext_error = 1;
716 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
717 custom_ext_error = 1;
718 return 1;
719}
Trevor9cd50f72013-06-13 22:36:45 -0700720
Dr. Stephen Hensonde2a9e32014-08-14 13:25:50 +0100721static int custom_ext_3_srv_add_cb(SSL *s, unsigned int ext_type,
Matt Caswell0f113f32015-01-22 03:40:55 +0000722 const unsigned char **out,
723 size_t *outlen, int *al, void *arg)
724{
725 *out = (const unsigned char *)custom_ext_srv_string;
726 *outlen = strlen(custom_ext_srv_string);
727 return 1; /* Send "defg" */
728}
Trevor9cd50f72013-06-13 22:36:45 -0700729
Matt Caswell0f113f32015-01-22 03:40:55 +0000730static char *cipher = NULL;
731static int verbose = 0;
732static int debug = 0;
Matt Caswell0f113f32015-01-22 03:40:55 +0000733static const char rnd_seed[] =
734 "string to make the random number generator think it has entropy";
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +0000735
Richard Levitte75d5bd42016-02-02 23:50:52 +0100736int doit_localhost(SSL *s_ssl, SSL *c_ssl, int family,
737 long bytes, clock_t *s_time, clock_t *c_time);
Matt Caswell0f113f32015-01-22 03:40:55 +0000738int doit_biopair(SSL *s_ssl, SSL *c_ssl, long bytes, clock_t *s_time,
739 clock_t *c_time);
740int doit(SSL *s_ssl, SSL *c_ssl, long bytes);
Nils Larsch6e119bb2005-08-25 07:29:54 +0000741static int do_test_cipherlist(void);
Rich Salz9ccc00e2015-02-02 11:11:34 -0500742
Ulf Möller6b691a51999-04-19 21:31:43 +0000743static void sv_usage(void)
Matt Caswell0f113f32015-01-22 03:40:55 +0000744{
745 fprintf(stderr, "usage: ssltest [args ...]\n");
746 fprintf(stderr, "\n");
Dr. Stephen Henson086e32a2011-05-19 18:09:02 +0000747#ifdef OPENSSL_FIPS
Matt Caswell0f113f32015-01-22 03:40:55 +0000748 fprintf(stderr, "-F - run test in FIPS mode\n");
Dr. Stephen Henson086e32a2011-05-19 18:09:02 +0000749#endif
Matt Caswell0f113f32015-01-22 03:40:55 +0000750 fprintf(stderr, " -server_auth - check server certificate\n");
751 fprintf(stderr, " -client_auth - do client authentication\n");
752 fprintf(stderr, " -proxy - allow proxy certificates\n");
753 fprintf(stderr, " -proxy_auth <val> - set proxy policy rights\n");
754 fprintf(stderr,
755 " -proxy_cond <val> - expression to test proxy policy rights\n");
756 fprintf(stderr, " -v - more output\n");
757 fprintf(stderr, " -d - debug output\n");
758 fprintf(stderr, " -reuse - use session-id reuse\n");
759 fprintf(stderr, " -num <val> - number of connections to perform\n");
760 fprintf(stderr,
761 " -bytes <val> - number of bytes to swap between client/server\n");
Richard Levittebc36ee62001-02-20 08:13:47 +0000762#ifndef OPENSSL_NO_DH
Matt Caswell0f113f32015-01-22 03:40:55 +0000763 fprintf(stderr,
Emilia Kaspere8356e32015-05-22 18:35:50 +0200764 " -dhe512 - use 512 bit key for DHE (to test failure)\n");
765 fprintf(stderr,
766 " -dhe1024 - use 1024 bit key (safe prime) for DHE (default, no-op)\n");
Matt Caswell0f113f32015-01-22 03:40:55 +0000767 fprintf(stderr,
768 " -dhe1024dsa - use 1024 bit key (with 160-bit subprime) for DHE\n");
769 fprintf(stderr, " -no_dhe - disable DHE\n");
Bodo Möller77fa04a1999-09-03 16:31:36 +0000770#endif
Rich Salz10bf4fc2015-03-10 19:09:27 -0400771#ifndef OPENSSL_NO_EC
Matt Caswell0f113f32015-01-22 03:40:55 +0000772 fprintf(stderr, " -no_ecdhe - disable ECDHE\n");
Bodo Möllerea262262002-08-09 08:56:08 +0000773#endif
Nils Larschddac1972006-03-10 23:06:27 +0000774#ifndef OPENSSL_NO_PSK
Matt Caswell0f113f32015-01-22 03:40:55 +0000775 fprintf(stderr, " -psk arg - PSK in hex (without 0x)\n");
Nils Larschddac1972006-03-10 23:06:27 +0000776#endif
Ben Laurieedc032b2011-03-12 17:01:19 +0000777#ifndef OPENSSL_NO_SRP
Matt Caswell0f113f32015-01-22 03:40:55 +0000778 fprintf(stderr, " -srpuser user - SRP username to use\n");
779 fprintf(stderr, " -srppass arg - password for 'user'\n");
Ben Laurieedc032b2011-03-12 17:01:19 +0000780#endif
Viktor Dukhovni6b01bed2016-01-18 13:10:21 -0500781#ifndef OPENSSL_NO_SSL3
Matt Caswell0f113f32015-01-22 03:40:55 +0000782 fprintf(stderr, " -ssl3 - use SSLv3\n");
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +0000783#endif
Viktor Dukhovni6b01bed2016-01-18 13:10:21 -0500784#ifndef OPENSSL_NO_TLS1
Matt Caswell0f113f32015-01-22 03:40:55 +0000785 fprintf(stderr, " -tls1 - use TLSv1\n");
Viktor Dukhovni6b01bed2016-01-18 13:10:21 -0500786#endif
David Woodhouse98b8cdd2015-03-03 15:47:08 +0000787#ifndef OPENSSL_NO_DTLS
Kurt Roeckx7946ab32015-12-06 17:56:41 +0100788 fprintf(stderr, " -dtls - use DTLS\n");
Viktor Dukhovni6b01bed2016-01-18 13:10:21 -0500789#ifndef OPENSSL_NO_DTLS1
David Woodhouse98b8cdd2015-03-03 15:47:08 +0000790 fprintf(stderr, " -dtls1 - use DTLSv1\n");
Viktor Dukhovni6b01bed2016-01-18 13:10:21 -0500791#endif
792#ifndef OPENSSL_NO_DTLS1_2
David Woodhouse98b8cdd2015-03-03 15:47:08 +0000793 fprintf(stderr, " -dtls12 - use DTLSv1.2\n");
794#endif
Viktor Dukhovni6b01bed2016-01-18 13:10:21 -0500795#endif
Matt Caswell0f113f32015-01-22 03:40:55 +0000796 fprintf(stderr, " -CApath arg - PEM format directory of CA's\n");
797 fprintf(stderr, " -CAfile arg - PEM format file of CA's\n");
798 fprintf(stderr, " -cert arg - Server certificate file\n");
799 fprintf(stderr,
800 " -key arg - Server key file (default: same as -cert)\n");
801 fprintf(stderr, " -c_cert arg - Client certificate file\n");
802 fprintf(stderr,
803 " -c_key arg - Client key file (default: same as -c_cert)\n");
804 fprintf(stderr, " -cipher arg - The cipher list\n");
805 fprintf(stderr, " -bio_pair - Use BIO pairs\n");
Richard Levitte75d5bd42016-02-02 23:50:52 +0100806 fprintf(stderr, " -ipv4 - Use IPv4 connection on localhost\n");
807 fprintf(stderr, " -ipv6 - Use IPv6 connection on localhost\n");
Matt Caswell0f113f32015-01-22 03:40:55 +0000808 fprintf(stderr, " -f - Test even cases that can't work\n");
809 fprintf(stderr,
810 " -time - measure processor time used by client and server\n");
811 fprintf(stderr, " -zlib - use zlib compression\n");
Rich Salz10bf4fc2015-03-10 19:09:27 -0400812#ifndef OPENSSL_NO_EC
Matt Caswell0f113f32015-01-22 03:40:55 +0000813 fprintf(stderr,
814 " -named_curve arg - Elliptic curve name to use for ephemeral ECDH keys.\n"
815 " Use \"openssl ecparam -list_curves\" for all names\n"
816 " (default is sect163r2).\n");
Bodo Möllerea262262002-08-09 08:56:08 +0000817#endif
Matt Caswell0f113f32015-01-22 03:40:55 +0000818 fprintf(stderr,
819 " -test_cipherlist - Verifies the order of the ssl cipher lists.\n"
820 " When this option is requested, the cipherlist\n"
821 " tests are run instead of handshake tests.\n");
Piotr Sikora29115752013-11-13 15:20:22 -0800822#ifndef OPENSSL_NO_NEXTPROTONEG
Matt Caswell0f113f32015-01-22 03:40:55 +0000823 fprintf(stderr, " -npn_client - have client side offer NPN\n");
824 fprintf(stderr, " -npn_server - have server side offer NPN\n");
825 fprintf(stderr, " -npn_server_reject - have server reject NPN\n");
Ben Lauried9a268b2010-09-05 16:35:10 +0000826#endif
Matt Caswell0f113f32015-01-22 03:40:55 +0000827 fprintf(stderr, " -serverinfo_file file - have server use this file\n");
828 fprintf(stderr, " -serverinfo_sct - have client offer and expect SCT\n");
829 fprintf(stderr,
830 " -serverinfo_tack - have client offer and expect TACK\n");
831 fprintf(stderr,
832 " -custom_ext - try various custom extension callbacks\n");
833 fprintf(stderr, " -alpn_client <string> - have client side offer ALPN\n");
834 fprintf(stderr, " -alpn_server <string> - have server side offer ALPN\n");
835 fprintf(stderr,
836 " -alpn_expected <string> - the ALPN protocol that should be negotiated\n");
Kurt Roeckx7946ab32015-12-06 17:56:41 +0100837 fprintf(stderr, " -server_min_proto <string> - Minimum version the server should support\n");
838 fprintf(stderr, " -server_max_proto <string> - Maximum version the server should support\n");
839 fprintf(stderr, " -client_min_proto <string> - Minimum version the client should support\n");
840 fprintf(stderr, " -client_max_proto <string> - Maximum version the client should support\n");
841 fprintf(stderr, " -should_negotiate <string> - The version that should be negotiated, fail-client or fail-server\n");
Rob Percivaldd696a52016-03-02 13:34:05 +0000842#ifndef OPENSSL_NO_CT
843 fprintf(stderr, " -noct - no certificate transparency\n");
844 fprintf(stderr, " -requestct - request certificate transparency\n");
845 fprintf(stderr, " -requirect - require certificate transparency\n");
846#endif
Matt Caswell0f113f32015-01-22 03:40:55 +0000847}
Bodo Möller563f1502000-03-13 15:06:54 +0000848
Dr. Stephen Hensonf756f1f2014-10-27 14:39:37 +0000849static void print_key_details(BIO *out, EVP_PKEY *key)
Matt Caswell0f113f32015-01-22 03:40:55 +0000850{
851 int keyid = EVP_PKEY_id(key);
Dr. Stephen Hensonf756f1f2014-10-27 14:39:37 +0000852#ifndef OPENSSL_NO_EC
Matt Caswell0f113f32015-01-22 03:40:55 +0000853 if (keyid == EVP_PKEY_EC) {
854 EC_KEY *ec = EVP_PKEY_get1_EC_KEY(key);
855 int nid;
856 const char *cname;
857 nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
858 EC_KEY_free(ec);
859 cname = EC_curve_nid2nist(nid);
860 if (!cname)
861 cname = OBJ_nid2sn(nid);
862 BIO_printf(out, "%d bits EC (%s)", EVP_PKEY_bits(key), cname);
863 } else
Dr. Stephen Hensonf756f1f2014-10-27 14:39:37 +0000864#endif
Matt Caswell0f113f32015-01-22 03:40:55 +0000865 {
866 const char *algname;
867 switch (keyid) {
868 case EVP_PKEY_RSA:
869 algname = "RSA";
870 break;
871 case EVP_PKEY_DSA:
872 algname = "DSA";
873 break;
874 case EVP_PKEY_DH:
875 algname = "DH";
876 break;
877 default:
878 algname = OBJ_nid2sn(keyid);
879 break;
880 }
881 BIO_printf(out, "%d bits %s", EVP_PKEY_bits(key), algname);
882 }
883}
Dr. Stephen Hensonf756f1f2014-10-27 14:39:37 +0000884
Bodo Möller563f1502000-03-13 15:06:54 +0000885static void print_details(SSL *c_ssl, const char *prefix)
Matt Caswell0f113f32015-01-22 03:40:55 +0000886{
887 const SSL_CIPHER *ciph;
888 int mdnid;
889 X509 *cert;
890 EVP_PKEY *pkey;
891
892 ciph = SSL_get_current_cipher(c_ssl);
893 BIO_printf(bio_stdout, "%s%s, cipher %s %s",
894 prefix,
895 SSL_get_version(c_ssl),
896 SSL_CIPHER_get_version(ciph), SSL_CIPHER_get_name(ciph));
897 cert = SSL_get_peer_certificate(c_ssl);
898 if (cert != NULL) {
899 pkey = X509_get_pubkey(cert);
900 if (pkey != NULL) {
901 BIO_puts(bio_stdout, ", ");
902 print_key_details(bio_stdout, pkey);
903 EVP_PKEY_free(pkey);
904 }
905 X509_free(cert);
906 }
907 if (SSL_get_server_tmp_key(c_ssl, &pkey)) {
908 BIO_puts(bio_stdout, ", temp key: ");
909 print_key_details(bio_stdout, pkey);
910 EVP_PKEY_free(pkey);
911 }
912 if (SSL_get_peer_signature_nid(c_ssl, &mdnid))
913 BIO_printf(bio_stdout, ", digest=%s", OBJ_nid2sn(mdnid));
914 BIO_printf(bio_stdout, "\n");
915}
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +0000916
Bodo Möller3ac82fa2000-12-15 16:40:35 +0000917static void lock_dbg_cb(int mode, int type, const char *file, int line)
Matt Caswell0f113f32015-01-22 03:40:55 +0000918{
919 static int modes[CRYPTO_NUM_LOCKS]; /* = {0, 0, ... } */
920 const char *errstr = NULL;
921 int rw;
Bodo Möller3ac82fa2000-12-15 16:40:35 +0000922
Matt Caswell0f113f32015-01-22 03:40:55 +0000923 rw = mode & (CRYPTO_READ | CRYPTO_WRITE);
924 if (!((rw == CRYPTO_READ) || (rw == CRYPTO_WRITE))) {
925 errstr = "invalid mode";
926 goto err;
927 }
Bodo Möller3ac82fa2000-12-15 16:40:35 +0000928
Matt Caswell0f113f32015-01-22 03:40:55 +0000929 if (type < 0 || type >= CRYPTO_NUM_LOCKS) {
930 errstr = "type out of bounds";
931 goto err;
932 }
Bodo Möller3ac82fa2000-12-15 16:40:35 +0000933
Matt Caswell0f113f32015-01-22 03:40:55 +0000934 if (mode & CRYPTO_LOCK) {
935 if (modes[type]) {
936 errstr = "already locked";
937 /*
938 * must not happen in a single-threaded program (would deadlock)
939 */
940 goto err;
941 }
Bodo Möller3ac82fa2000-12-15 16:40:35 +0000942
Matt Caswell0f113f32015-01-22 03:40:55 +0000943 modes[type] = rw;
944 } else if (mode & CRYPTO_UNLOCK) {
945 if (!modes[type]) {
946 errstr = "not locked";
947 goto err;
948 }
949
950 if (modes[type] != rw) {
951 errstr = (rw == CRYPTO_READ) ?
952 "CRYPTO_r_unlock on write lock" :
953 "CRYPTO_w_unlock on read lock";
954 }
955
956 modes[type] = 0;
957 } else {
958 errstr = "invalid mode";
959 goto err;
960 }
Bodo Möller3ac82fa2000-12-15 16:40:35 +0000961
962 err:
Matt Caswell0f113f32015-01-22 03:40:55 +0000963 if (errstr) {
964 /* we cannot use bio_err here */
965 fprintf(stderr,
966 "openssl (lock_dbg_cb): %s (mode=%d, type=%d) at %s:%d\n",
967 errstr, mode, type, file, line);
968 }
969}
Bodo Möller3ac82fa2000-12-15 16:40:35 +0000970
Kurt Roeckx7946ab32015-12-06 17:56:41 +0100971/*
972 * protocol_from_string - converts a protocol version string to a number
973 *
974 * Returns -1 on failure or the version on success
975 */
976static int protocol_from_string(const char *value)
977{
978 struct protocol_versions {
979 const char *name;
980 int version;
981 };
982 static const struct protocol_versions versions[] = {
983 {"ssl3", SSL3_VERSION},
984 {"tls1", TLS1_VERSION},
985 {"tls1.1", TLS1_1_VERSION},
986 {"tls1.2", TLS1_2_VERSION},
987 {"dtls1", DTLS1_VERSION},
988 {"dtls1.2", DTLS1_2_VERSION}};
989 size_t i;
990 size_t n = OSSL_NELEM(versions);
991
992 for (i = 0; i < n; i++)
993 if (strcmp(versions[i].name, value) == 0)
994 return versions[i].version;
995 return -1;
996}
997
998/*
999 * set_protocol_version - Sets protocol version minimum or maximum
1000 *
1001 * Returns 0 on failure and 1 on success
1002 */
1003static int set_protocol_version(const char *version, SSL *ssl, int setting)
1004{
1005 if (version != NULL) {
1006 int ver = protocol_from_string(version);
1007 if (ver < 0) {
1008 BIO_printf(bio_err, "Error parsing: %s\n", version);
1009 return 0;
1010 }
1011 return SSL_ctrl(ssl, setting, ver, NULL);
1012 }
1013 return 1;
1014}
1015
Ulf Möller6b691a51999-04-19 21:31:43 +00001016int main(int argc, char *argv[])
Matt Caswell0f113f32015-01-22 03:40:55 +00001017{
1018 char *CApath = NULL, *CAfile = NULL;
1019 int badop = 0;
Richard Levitte75d5bd42016-02-02 23:50:52 +01001020 enum { BIO_MEM, BIO_PAIR, BIO_IPV4, BIO_IPV6 } bio_type = BIO_MEM;
Matt Caswell0f113f32015-01-22 03:40:55 +00001021 int force = 0;
Kurt Roeckx7946ab32015-12-06 17:56:41 +01001022 int dtls1 = 0, dtls12 = 0, dtls = 0, tls1 = 0, ssl3 = 0, ret = 1;
Matt Caswell0f113f32015-01-22 03:40:55 +00001023 int client_auth = 0;
1024 int server_auth = 0, i;
1025 struct app_verify_arg app_verify_arg =
1026 { APP_CALLBACK_STRING, 0, 0, NULL, NULL };
Rich Salzbbd86bf2016-01-07 15:06:38 -05001027 char *p;
Rich Salz10bf4fc2015-03-10 19:09:27 -04001028#ifndef OPENSSL_NO_EC
Matt Caswell0f113f32015-01-22 03:40:55 +00001029 char *named_curve = NULL;
Nils Larsch3eeaab42005-07-16 12:37:36 +00001030#endif
Matt Caswell0f113f32015-01-22 03:40:55 +00001031 SSL_CTX *s_ctx = NULL;
1032 SSL_CTX *c_ctx = NULL;
1033 const SSL_METHOD *meth = NULL;
1034 SSL *c_ssl, *s_ssl;
1035 int number = 1, reuse = 0;
1036 long bytes = 256L;
Richard Levittebc36ee62001-02-20 08:13:47 +00001037#ifndef OPENSSL_NO_DH
Matt Caswell0f113f32015-01-22 03:40:55 +00001038 DH *dh;
Emilia Kaspere8356e32015-05-22 18:35:50 +02001039 int dhe512 = 0, dhe1024dsa = 0;
Ralf S. Engelschall58964a41998-12-21 10:56:39 +00001040#endif
Rich Salz10bf4fc2015-03-10 19:09:27 -04001041#ifndef OPENSSL_NO_EC
Matt Caswell0f113f32015-01-22 03:40:55 +00001042 EC_KEY *ecdh = NULL;
Bodo Möllerea262262002-08-09 08:56:08 +00001043#endif
Ben Laurieedc032b2011-03-12 17:01:19 +00001044#ifndef OPENSSL_NO_SRP
Matt Caswell0f113f32015-01-22 03:40:55 +00001045 /* client */
1046 SRP_CLIENT_ARG srp_client_arg = { NULL, NULL };
1047 /* server */
1048 SRP_SERVER_ARG srp_server_arg = { NULL, NULL };
Ben Laurieedc032b2011-03-12 17:01:19 +00001049#endif
Matt Caswell0f113f32015-01-22 03:40:55 +00001050 int no_dhe = 0;
1051 int no_ecdhe = 0;
1052 int no_psk = 0;
1053 int print_time = 0;
1054 clock_t s_time = 0, c_time = 0;
Dr. Stephen Henson09b6c2e2005-09-30 23:35:33 +00001055#ifndef OPENSSL_NO_COMP
Rich Salz9a555702015-05-08 12:05:36 -04001056 int n, comp = 0;
Matt Caswell0f113f32015-01-22 03:40:55 +00001057 COMP_METHOD *cm = NULL;
1058 STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
Dr. Stephen Henson00a37b52010-04-06 11:18:59 +00001059#endif
Matt Caswell0f113f32015-01-22 03:40:55 +00001060 int test_cipherlist = 0;
Dr. Stephen Henson086e32a2011-05-19 18:09:02 +00001061#ifdef OPENSSL_FIPS
Matt Caswell0f113f32015-01-22 03:40:55 +00001062 int fips_mode = 0;
Dr. Stephen Henson086e32a2011-05-19 18:09:02 +00001063#endif
Viktor Dukhovni6b01bed2016-01-18 13:10:21 -05001064 int no_protocol;
Bodo Möller563f1502000-03-13 15:06:54 +00001065
Rob Percivaldd696a52016-03-02 13:34:05 +00001066#ifndef OPENSSL_NO_CT
1067 /*
1068 * Disable CT validation by default, because it will interfere with
1069 * anything using custom extension handlers to deal with SCT extensions.
1070 */
1071 ct_validation_cb ct_validation = NULL;
1072#endif
1073
Matt Caswell0f113f32015-01-22 03:40:55 +00001074 SSL_CONF_CTX *s_cctx = NULL, *c_cctx = NULL;
1075 STACK_OF(OPENSSL_STRING) *conf_args = NULL;
Dr. Stephen Henson4a640fb2015-12-23 00:47:28 +00001076 char *arg = NULL, *argn = NULL;
Dr. Stephen Hensonde942222014-10-27 14:07:12 +00001077
Matt Caswell0f113f32015-01-22 03:40:55 +00001078 verbose = 0;
1079 debug = 0;
1080 cipher = 0;
Bodo Möller1e3a9b62002-11-19 11:56:05 +00001081
Matt Caswell0f113f32015-01-22 03:40:55 +00001082 bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
Bodo Möller1e3a9b62002-11-19 11:56:05 +00001083
Matt Caswell0f113f32015-01-22 03:40:55 +00001084 CRYPTO_set_locking_callback(lock_dbg_cb);
Bodo Möller3ac82fa2000-12-15 16:40:35 +00001085
Rich Salzbbd86bf2016-01-07 15:06:38 -05001086 p = getenv("OPENSSL_DEBUG_MEMORY");
1087 if (p != NULL && strcmp(p, "on") == 0)
1088 CRYPTO_set_mem_debug(1);
Matt Caswell0f113f32015-01-22 03:40:55 +00001089 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00001090
Matt Caswell0f113f32015-01-22 03:40:55 +00001091 RAND_seed(rnd_seed, sizeof rnd_seed);
Ulf Möllerb9d82f42000-01-16 12:21:22 +00001092
Matt Caswell0f113f32015-01-22 03:40:55 +00001093 bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00001094
Matt Caswell0f113f32015-01-22 03:40:55 +00001095 s_cctx = SSL_CONF_CTX_new();
1096 c_cctx = SSL_CONF_CTX_new();
Dr. Stephen Hensonde942222014-10-27 14:07:12 +00001097
Matt Caswell0f113f32015-01-22 03:40:55 +00001098 if (!s_cctx || !c_cctx) {
1099 ERR_print_errors(bio_err);
1100 goto end;
1101 }
Dr. Stephen Hensonde942222014-10-27 14:07:12 +00001102
Matt Caswell0f113f32015-01-22 03:40:55 +00001103 SSL_CONF_CTX_set_flags(s_cctx,
Dr. Stephen Henson6a096882015-08-26 12:22:39 +01001104 SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_SERVER |
1105 SSL_CONF_FLAG_CERTIFICATE |
1106 SSL_CONF_FLAG_REQUIRE_PRIVATE);
Matt Caswell0f113f32015-01-22 03:40:55 +00001107 if (!SSL_CONF_CTX_set1_prefix(s_cctx, "-s_")) {
1108 ERR_print_errors(bio_err);
1109 goto end;
1110 }
Dr. Stephen Hensonde942222014-10-27 14:07:12 +00001111
Matt Caswell0f113f32015-01-22 03:40:55 +00001112 SSL_CONF_CTX_set_flags(c_cctx,
Dr. Stephen Henson6a096882015-08-26 12:22:39 +01001113 SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_CLIENT |
1114 SSL_CONF_FLAG_CERTIFICATE |
1115 SSL_CONF_FLAG_REQUIRE_PRIVATE);
Matt Caswell0f113f32015-01-22 03:40:55 +00001116 if (!SSL_CONF_CTX_set1_prefix(c_cctx, "-c_")) {
1117 ERR_print_errors(bio_err);
1118 goto end;
1119 }
Dr. Stephen Hensonde942222014-10-27 14:07:12 +00001120
Matt Caswell0f113f32015-01-22 03:40:55 +00001121 argc--;
1122 argv++;
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00001123
Matt Caswell0f113f32015-01-22 03:40:55 +00001124 while (argc >= 1) {
Rich Salz86885c22015-05-06 14:56:14 -04001125 if (strcmp(*argv, "-F") == 0) {
Dr. Stephen Henson086e32a2011-05-19 18:09:02 +00001126#ifdef OPENSSL_FIPS
Matt Caswell0f113f32015-01-22 03:40:55 +00001127 fips_mode = 1;
Dr. Stephen Henson086e32a2011-05-19 18:09:02 +00001128#else
Matt Caswell0f113f32015-01-22 03:40:55 +00001129 fprintf(stderr,
1130 "not compiled with FIPS support, so exiting without running.\n");
1131 EXIT(0);
Dr. Stephen Henson086e32a2011-05-19 18:09:02 +00001132#endif
Matt Caswell0f113f32015-01-22 03:40:55 +00001133 } else if (strcmp(*argv, "-server_auth") == 0)
1134 server_auth = 1;
1135 else if (strcmp(*argv, "-client_auth") == 0)
1136 client_auth = 1;
1137 else if (strcmp(*argv, "-proxy_auth") == 0) {
1138 if (--argc < 1)
1139 goto bad;
1140 app_verify_arg.proxy_auth = *(++argv);
1141 } else if (strcmp(*argv, "-proxy_cond") == 0) {
1142 if (--argc < 1)
1143 goto bad;
1144 app_verify_arg.proxy_cond = *(++argv);
1145 } else if (strcmp(*argv, "-v") == 0)
1146 verbose = 1;
1147 else if (strcmp(*argv, "-d") == 0)
1148 debug = 1;
1149 else if (strcmp(*argv, "-reuse") == 0)
1150 reuse = 1;
Emilia Kaspere8356e32015-05-22 18:35:50 +02001151 else if (strcmp(*argv, "-dhe512") == 0) {
Richard Levitte90f5a2b2002-08-14 12:16:27 +00001152#ifndef OPENSSL_NO_DH
Emilia Kaspere8356e32015-05-22 18:35:50 +02001153 dhe512 = 1;
Richard Levitte90f5a2b2002-08-14 12:16:27 +00001154#else
Matt Caswell0f113f32015-01-22 03:40:55 +00001155 fprintf(stderr,
Emilia Kaspere8356e32015-05-22 18:35:50 +02001156 "ignoring -dhe512, since I'm compiled without DH\n");
Bodo Möllere4589582000-03-10 13:23:20 +00001157#endif
Matt Caswell0f113f32015-01-22 03:40:55 +00001158 } else if (strcmp(*argv, "-dhe1024dsa") == 0) {
Richard Levitte90f5a2b2002-08-14 12:16:27 +00001159#ifndef OPENSSL_NO_DH
Matt Caswell0f113f32015-01-22 03:40:55 +00001160 dhe1024dsa = 1;
Richard Levitte90f5a2b2002-08-14 12:16:27 +00001161#else
Matt Caswell0f113f32015-01-22 03:40:55 +00001162 fprintf(stderr,
Emilia Kaspere8356e32015-05-22 18:35:50 +02001163 "ignoring -dhe1024dsa, since I'm compiled without DH\n");
Richard Levitte90f5a2b2002-08-14 12:16:27 +00001164#endif
Matt Caswell0f113f32015-01-22 03:40:55 +00001165 } else if (strcmp(*argv, "-no_dhe") == 0)
1166 no_dhe = 1;
1167 else if (strcmp(*argv, "-no_ecdhe") == 0)
1168 no_ecdhe = 1;
1169 else if (strcmp(*argv, "-psk") == 0) {
1170 if (--argc < 1)
1171 goto bad;
1172 psk_key = *(++argv);
Nils Larschddac1972006-03-10 23:06:27 +00001173#ifndef OPENSSL_NO_PSK
Matt Caswell0f113f32015-01-22 03:40:55 +00001174 if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key)) {
1175 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
1176 goto bad;
1177 }
Nils Larschddac1972006-03-10 23:06:27 +00001178#else
Matt Caswell0f113f32015-01-22 03:40:55 +00001179 no_psk = 1;
Nils Larschddac1972006-03-10 23:06:27 +00001180#endif
Matt Caswell0f113f32015-01-22 03:40:55 +00001181 }
Ben Laurieedc032b2011-03-12 17:01:19 +00001182#ifndef OPENSSL_NO_SRP
Matt Caswell0f113f32015-01-22 03:40:55 +00001183 else if (strcmp(*argv, "-srpuser") == 0) {
1184 if (--argc < 1)
1185 goto bad;
1186 srp_server_arg.expected_user = srp_client_arg.srplogin =
1187 *(++argv);
1188 tls1 = 1;
1189 } else if (strcmp(*argv, "-srppass") == 0) {
1190 if (--argc < 1)
1191 goto bad;
1192 srp_server_arg.pass = srp_client_arg.srppassin = *(++argv);
1193 tls1 = 1;
1194 }
Ben Laurieedc032b2011-03-12 17:01:19 +00001195#endif
Matt Caswell0f113f32015-01-22 03:40:55 +00001196 else if (strcmp(*argv, "-tls1") == 0) {
Matt Caswell0f113f32015-01-22 03:40:55 +00001197 tls1 = 1;
1198 } else if (strcmp(*argv, "-ssl3") == 0) {
Matt Caswell0f113f32015-01-22 03:40:55 +00001199 ssl3 = 1;
David Woodhouse98b8cdd2015-03-03 15:47:08 +00001200 } else if (strcmp(*argv, "-dtls1") == 0) {
David Woodhouse98b8cdd2015-03-03 15:47:08 +00001201 dtls1 = 1;
1202 } else if (strcmp(*argv, "-dtls12") == 0) {
David Woodhouse98b8cdd2015-03-03 15:47:08 +00001203 dtls12 = 1;
Kurt Roeckx7946ab32015-12-06 17:56:41 +01001204 } else if (strcmp(*argv, "-dtls") == 0) {
Kurt Roeckx7946ab32015-12-06 17:56:41 +01001205 dtls = 1;
Matt Caswell0f113f32015-01-22 03:40:55 +00001206 } else if (strncmp(*argv, "-num", 4) == 0) {
1207 if (--argc < 1)
1208 goto bad;
1209 number = atoi(*(++argv));
1210 if (number == 0)
1211 number = 1;
1212 } else if (strcmp(*argv, "-bytes") == 0) {
1213 if (--argc < 1)
1214 goto bad;
1215 bytes = atol(*(++argv));
1216 if (bytes == 0L)
1217 bytes = 1L;
1218 i = strlen(argv[0]);
1219 if (argv[0][i - 1] == 'k')
1220 bytes *= 1024L;
1221 if (argv[0][i - 1] == 'm')
1222 bytes *= 1024L * 1024L;
Matt Caswell0f113f32015-01-22 03:40:55 +00001223 } else if (strcmp(*argv, "-cipher") == 0) {
1224 if (--argc < 1)
1225 goto bad;
1226 cipher = *(++argv);
1227 } else if (strcmp(*argv, "-CApath") == 0) {
1228 if (--argc < 1)
1229 goto bad;
1230 CApath = *(++argv);
1231 } else if (strcmp(*argv, "-CAfile") == 0) {
1232 if (--argc < 1)
1233 goto bad;
1234 CAfile = *(++argv);
1235 } else if (strcmp(*argv, "-bio_pair") == 0) {
Richard Levitte75d5bd42016-02-02 23:50:52 +01001236 bio_type = BIO_PAIR;
1237 } else if (strcmp(*argv, "-ipv4") == 0) {
1238 bio_type = BIO_IPV4;
1239 } else if (strcmp(*argv, "-ipv6") == 0) {
1240 bio_type = BIO_IPV6;
Matt Caswell0f113f32015-01-22 03:40:55 +00001241 } else if (strcmp(*argv, "-f") == 0) {
1242 force = 1;
1243 } else if (strcmp(*argv, "-time") == 0) {
1244 print_time = 1;
1245 }
Rob Percivaldd696a52016-03-02 13:34:05 +00001246#ifndef OPENSSL_NO_CT
1247 else if (strcmp(*argv, "-noct") == 0) {
1248 ct_validation = NULL;
1249 }
1250 else if (strcmp(*argv, "-requestct") == 0) {
1251 ct_validation = CT_verify_no_bad_scts;
1252 }
1253 else if (strcmp(*argv, "-requirect") == 0) {
1254 ct_validation = CT_verify_at_least_one_good_sct;
1255 }
1256#endif
Dr. Stephen Hensona4c4a7d2012-12-29 23:37:56 +00001257#ifndef OPENSSL_NO_COMP
Matt Caswell0f113f32015-01-22 03:40:55 +00001258 else if (strcmp(*argv, "-zlib") == 0) {
1259 comp = COMP_ZLIB;
Matt Caswell0f113f32015-01-22 03:40:55 +00001260 }
Dr. Stephen Hensona4c4a7d2012-12-29 23:37:56 +00001261#endif
Matt Caswell0f113f32015-01-22 03:40:55 +00001262 else if (strcmp(*argv, "-named_curve") == 0) {
1263 if (--argc < 1)
1264 goto bad;
Rich Salz10bf4fc2015-03-10 19:09:27 -04001265#ifndef OPENSSL_NO_EC
Matt Caswell0f113f32015-01-22 03:40:55 +00001266 named_curve = *(++argv);
Richard Levitte90f5a2b2002-08-14 12:16:27 +00001267#else
Matt Caswell0f113f32015-01-22 03:40:55 +00001268 fprintf(stderr,
1269 "ignoring -named_curve, since I'm compiled without ECDH\n");
1270 ++argv;
Bodo Möllerea262262002-08-09 08:56:08 +00001271#endif
Matt Caswell0f113f32015-01-22 03:40:55 +00001272 } else if (strcmp(*argv, "-app_verify") == 0) {
1273 app_verify_arg.app_verify = 1;
1274 } else if (strcmp(*argv, "-proxy") == 0) {
1275 app_verify_arg.allow_proxy_certs = 1;
1276 } else if (strcmp(*argv, "-test_cipherlist") == 0) {
1277 test_cipherlist = 1;
1278 }
Piotr Sikora29115752013-11-13 15:20:22 -08001279#ifndef OPENSSL_NO_NEXTPROTONEG
Matt Caswell0f113f32015-01-22 03:40:55 +00001280 else if (strcmp(*argv, "-npn_client") == 0) {
1281 npn_client = 1;
1282 } else if (strcmp(*argv, "-npn_server") == 0) {
1283 npn_server = 1;
1284 } else if (strcmp(*argv, "-npn_server_reject") == 0) {
1285 npn_server_reject = 1;
1286 }
Ben Lauried9a268b2010-09-05 16:35:10 +00001287#endif
Matt Caswell0f113f32015-01-22 03:40:55 +00001288 else if (strcmp(*argv, "-serverinfo_sct") == 0) {
1289 serverinfo_sct = 1;
1290 } else if (strcmp(*argv, "-serverinfo_tack") == 0) {
1291 serverinfo_tack = 1;
1292 } else if (strcmp(*argv, "-serverinfo_file") == 0) {
1293 if (--argc < 1)
1294 goto bad;
1295 serverinfo_file = *(++argv);
1296 } else if (strcmp(*argv, "-custom_ext") == 0) {
1297 custom_ext = 1;
1298 } else if (strcmp(*argv, "-alpn_client") == 0) {
1299 if (--argc < 1)
1300 goto bad;
1301 alpn_client = *(++argv);
1302 } else if (strcmp(*argv, "-alpn_server") == 0) {
1303 if (--argc < 1)
1304 goto bad;
1305 alpn_server = *(++argv);
1306 } else if (strcmp(*argv, "-alpn_expected") == 0) {
1307 if (--argc < 1)
1308 goto bad;
1309 alpn_expected = *(++argv);
Kurt Roeckx7946ab32015-12-06 17:56:41 +01001310 } else if (strcmp(*argv, "-server_min_proto") == 0) {
1311 if (--argc < 1)
1312 goto bad;
1313 server_min_proto = *(++argv);
1314 } else if (strcmp(*argv, "-server_max_proto") == 0) {
1315 if (--argc < 1)
1316 goto bad;
1317 server_max_proto = *(++argv);
1318 } else if (strcmp(*argv, "-client_min_proto") == 0) {
1319 if (--argc < 1)
1320 goto bad;
1321 client_min_proto = *(++argv);
1322 } else if (strcmp(*argv, "-client_max_proto") == 0) {
1323 if (--argc < 1)
1324 goto bad;
1325 client_max_proto = *(++argv);
1326 } else if (strcmp(*argv, "-should_negotiate") == 0) {
1327 if (--argc < 1)
1328 goto bad;
1329 should_negotiate = *(++argv);
Matt Caswell0f113f32015-01-22 03:40:55 +00001330 } else {
1331 int rv;
1332 arg = argv[0];
1333 argn = argv[1];
1334 /* Try to process command using SSL_CONF */
1335 rv = SSL_CONF_cmd_argv(c_cctx, &argc, &argv);
1336 /* If not processed try server */
1337 if (rv == 0)
1338 rv = SSL_CONF_cmd_argv(s_cctx, &argc, &argv);
1339 /* Recognised: store it for later use */
1340 if (rv > 0) {
1341 if (rv == 1)
1342 argn = NULL;
1343 if (!conf_args) {
1344 conf_args = sk_OPENSSL_STRING_new_null();
1345 if (!conf_args)
1346 goto end;
1347 }
1348 if (!sk_OPENSSL_STRING_push(conf_args, arg))
1349 goto end;
1350 if (!sk_OPENSSL_STRING_push(conf_args, argn))
1351 goto end;
1352 continue;
1353 }
1354 if (rv == -3)
1355 BIO_printf(bio_err, "Missing argument for %s\n", arg);
1356 else if (rv < 0)
1357 BIO_printf(bio_err, "Error with command %s\n", arg);
1358 else if (rv == 0)
1359 BIO_printf(bio_err, "unknown option %s\n", arg);
1360 badop = 1;
1361 break;
1362 }
1363 argc--;
1364 argv++;
1365 }
1366 if (badop) {
1367 bad:
1368 sv_usage();
1369 goto end;
1370 }
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00001371
Matt Caswell0f113f32015-01-22 03:40:55 +00001372 /*
1373 * test_cipherlist prevails over protocol switch: we test the cipherlist
1374 * for all enabled protocols.
1375 */
1376 if (test_cipherlist == 1) {
1377 /*
1378 * ensure that the cipher list are correctly sorted and exit
1379 */
1380 fprintf(stdout, "Testing cipherlist order only. Ignoring all "
1381 "other options.\n");
1382 if (do_test_cipherlist() == 0)
1383 EXIT(1);
1384 ret = 0;
1385 goto end;
1386 }
Nils Larsch6e119bb2005-08-25 07:29:54 +00001387
Kurt Roeckx7946ab32015-12-06 17:56:41 +01001388 if (ssl3 + tls1 + dtls + dtls1 + dtls12 > 1) {
1389 fprintf(stderr, "At most one of -ssl3, -tls1, -dtls, -dtls1 or -dtls12 should "
Matt Caswell0f113f32015-01-22 03:40:55 +00001390 "be requested.\n");
1391 EXIT(1);
1392 }
Emilia Kasperfd28a412014-10-27 16:25:17 +01001393
Viktor Dukhovni6b01bed2016-01-18 13:10:21 -05001394#ifdef OPENSSL_NO_SSL3
1395 if (ssl3)
1396 no_protocol = 1;
1397 else
1398#endif
1399#ifdef OPENSSL_NO_TLS1
1400 if (tls1)
1401 no_protocol = 1;
1402 else
1403#endif
1404#if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1)
1405 if (dtls1)
1406 no_protocol = 1;
1407 else
1408#endif
1409#if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1_2)
1410 if (dtls12)
1411 no_protocol = 1;
1412 else
1413#endif
1414 no_protocol = 0;
1415
Matt Caswell0f113f32015-01-22 03:40:55 +00001416 /*
1417 * Testing was requested for a compiled-out protocol (e.g. SSLv3).
1418 * Ideally, we would error out, but the generic test wrapper can't know
1419 * when to expect failure. So we do nothing and return success.
1420 */
1421 if (no_protocol) {
1422 fprintf(stderr, "Testing was requested for a disabled protocol. "
1423 "Skipping tests.\n");
1424 ret = 0;
1425 goto end;
1426 }
Emilia Kasperfd28a412014-10-27 16:25:17 +01001427
Kurt Roeckx7946ab32015-12-06 17:56:41 +01001428 if (!ssl3 && !tls1 && !dtls && !dtls1 && !dtls12 && number > 1 && !reuse && !force) {
Matt Caswell0f113f32015-01-22 03:40:55 +00001429 fprintf(stderr, "This case cannot work. Use -f to perform "
1430 "the test anyway (and\n-d to see what happens), "
Kurt Roeckx7946ab32015-12-06 17:56:41 +01001431 "or add one of -ssl3, -tls1, -dtls, -dtls1, -dtls12, -reuse\n"
Matt Caswell0f113f32015-01-22 03:40:55 +00001432 "to avoid protocol mismatch.\n");
1433 EXIT(1);
1434 }
Dr. Stephen Henson086e32a2011-05-19 18:09:02 +00001435#ifdef OPENSSL_FIPS
Matt Caswell0f113f32015-01-22 03:40:55 +00001436 if (fips_mode) {
1437 if (!FIPS_mode_set(1)) {
Richard Levitte0f81f5f2015-09-04 14:07:57 +02001438 ERR_print_errors(bio_err);
Matt Caswell0f113f32015-01-22 03:40:55 +00001439 EXIT(1);
1440 } else
1441 fprintf(stderr, "*** IN FIPS MODE ***\n");
1442 }
Dr. Stephen Henson086e32a2011-05-19 18:09:02 +00001443#endif
1444
Matt Caswell0f113f32015-01-22 03:40:55 +00001445 if (print_time) {
Richard Levitte75d5bd42016-02-02 23:50:52 +01001446 if (bio_type != BIO_PAIR) {
Matt Caswell0f113f32015-01-22 03:40:55 +00001447 fprintf(stderr, "Using BIO pair (-bio_pair)\n");
Richard Levitte75d5bd42016-02-02 23:50:52 +01001448 bio_type = BIO_PAIR;
Matt Caswell0f113f32015-01-22 03:40:55 +00001449 }
1450 if (number < 50 && !force)
1451 fprintf(stderr,
1452 "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
1453 }
Bodo Möller563f1502000-03-13 15:06:54 +00001454
Matt Caswell0f113f32015-01-22 03:40:55 +00001455/* if (cipher == NULL) cipher=getenv("SSL_CIPHER"); */
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00001456
Dr. Stephen Henson09b6c2e2005-09-30 23:35:33 +00001457#ifndef OPENSSL_NO_COMP
Matt Caswell0f113f32015-01-22 03:40:55 +00001458 if (comp == COMP_ZLIB)
1459 cm = COMP_zlib();
Matt Caswell0f113f32015-01-22 03:40:55 +00001460 if (cm != NULL) {
Rich Salz9a555702015-05-08 12:05:36 -04001461 if (COMP_get_type(cm) != NID_undef) {
Matt Caswell0f113f32015-01-22 03:40:55 +00001462 if (SSL_COMP_add_compression_method(comp, cm) != 0) {
1463 fprintf(stderr, "Failed to add compression method\n");
1464 ERR_print_errors_fp(stderr);
1465 }
1466 } else {
1467 fprintf(stderr,
1468 "Warning: %s compression not supported\n",
Rich Salz45ddce22015-05-02 11:19:06 -04001469 comp == COMP_ZLIB ? "zlib" : "unknown");
Matt Caswell0f113f32015-01-22 03:40:55 +00001470 ERR_print_errors_fp(stderr);
1471 }
1472 }
1473 ssl_comp_methods = SSL_COMP_get_compression_methods();
Rich Salz3dca57f2015-04-21 15:52:51 -04001474 n = sk_SSL_COMP_num(ssl_comp_methods);
1475 if (n) {
1476 int j;
1477 printf("Available compression methods:");
1478 for (j = 0; j < n; j++) {
1479 SSL_COMP *c = sk_SSL_COMP_value(ssl_comp_methods, j);
1480 printf(" %s:%d", c->name, c->id);
Rich Salz22ebaae2015-04-02 15:58:10 -04001481 }
Rich Salz3dca57f2015-04-21 15:52:51 -04001482 printf("\n");
Matt Caswell0f113f32015-01-22 03:40:55 +00001483 }
Dr. Stephen Henson231b98a2005-10-02 12:28:40 +00001484#endif
Richard Levitte23f80f42000-11-30 11:57:31 +00001485
Matt Caswell0f113f32015-01-22 03:40:55 +00001486 /*
1487 * At this point, ssl3/tls1 is only set if the protocol is available.
1488 * (Otherwise we exit early.) However the compiler doesn't know this, so
1489 * we ifdef.
1490 */
Viktor Dukhovni6b01bed2016-01-18 13:10:21 -05001491#ifndef OPENSSL_NO_DTLS
1492#ifndef OPENSSL_NO_DTLS1
1493 if (dtls1)
1494 meth = DTLSv1_method();
1495 else
1496#endif
1497#ifndef OPENSSL_NO_DTLS1_2
1498 if (dtls12)
1499 meth = DTLSv1_2_method();
1500 else
1501#endif
1502 if (dtls)
1503 meth = DTLS_method();
1504 else
1505#endif
Emilia Kasperfd28a412014-10-27 16:25:17 +01001506#ifndef OPENSSL_NO_SSL3
Matt Caswell0f113f32015-01-22 03:40:55 +00001507 if (ssl3)
1508 meth = SSLv3_method();
1509 else
Emilia Kasperfd28a412014-10-27 16:25:17 +01001510#endif
Viktor Dukhovni6b01bed2016-01-18 13:10:21 -05001511#ifndef OPENSSL_NO_TLS1
Matt Caswell0f113f32015-01-22 03:40:55 +00001512 if (tls1)
1513 meth = TLSv1_method();
1514 else
Viktor Dukhovni6b01bed2016-01-18 13:10:21 -05001515#endif
Matt Caswell32ec4152015-03-27 23:01:51 +00001516 meth = TLS_method();
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00001517
Matt Caswell0f113f32015-01-22 03:40:55 +00001518 c_ctx = SSL_CTX_new(meth);
1519 s_ctx = SSL_CTX_new(meth);
1520 if ((c_ctx == NULL) || (s_ctx == NULL)) {
1521 ERR_print_errors(bio_err);
1522 goto end;
1523 }
1524 /*
1525 * Since we will use low security ciphersuites and keys for testing set
Emilia Kasper15a06482015-05-26 14:32:57 +02001526 * security level to zero by default. Tests can override this by adding
1527 * "@SECLEVEL=n" to the cipher string.
Matt Caswell0f113f32015-01-22 03:40:55 +00001528 */
1529 SSL_CTX_set_security_level(c_ctx, 0);
1530 SSL_CTX_set_security_level(s_ctx, 0);
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00001531
Matt Caswell0f113f32015-01-22 03:40:55 +00001532 if (cipher != NULL) {
Viktor Dukhovni61986d32015-04-16 01:50:03 -04001533 if (!SSL_CTX_set_cipher_list(c_ctx, cipher)
Matt Caswell69f68232015-03-06 14:37:17 +00001534 || !SSL_CTX_set_cipher_list(s_ctx, cipher)) {
1535 ERR_print_errors(bio_err);
1536 goto end;
1537 }
Matt Caswell0f113f32015-01-22 03:40:55 +00001538 }
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00001539
Rob Percivaldd696a52016-03-02 13:34:05 +00001540#ifndef OPENSSL_NO_CT
1541 if (!SSL_CTX_set_ct_validation_callback(c_ctx, ct_validation, NULL)) {
1542 ERR_print_errors(bio_err);
1543 goto end;
1544 }
1545#endif
1546
Matt Caswell0f113f32015-01-22 03:40:55 +00001547 /* Process SSL_CONF arguments */
1548 SSL_CONF_CTX_set_ssl_ctx(c_cctx, c_ctx);
1549 SSL_CONF_CTX_set_ssl_ctx(s_cctx, s_ctx);
Dr. Stephen Hensonde942222014-10-27 14:07:12 +00001550
Matt Caswell0f113f32015-01-22 03:40:55 +00001551 for (i = 0; i < sk_OPENSSL_STRING_num(conf_args); i += 2) {
1552 int rv;
1553 arg = sk_OPENSSL_STRING_value(conf_args, i);
1554 argn = sk_OPENSSL_STRING_value(conf_args, i + 1);
1555 rv = SSL_CONF_cmd(c_cctx, arg, argn);
1556 /* If not recognised use server context */
1557 if (rv == -2)
1558 rv = SSL_CONF_cmd(s_cctx, arg, argn);
1559 if (rv <= 0) {
1560 BIO_printf(bio_err, "Error processing %s %s\n",
1561 arg, argn ? argn : "");
1562 ERR_print_errors(bio_err);
1563 goto end;
1564 }
1565 }
Dr. Stephen Hensonde942222014-10-27 14:07:12 +00001566
Matt Caswell0f113f32015-01-22 03:40:55 +00001567 if (!SSL_CONF_CTX_finish(s_cctx) || !SSL_CONF_CTX_finish(c_cctx)) {
1568 BIO_puts(bio_err, "Error finishing context\n");
1569 ERR_print_errors(bio_err);
1570 goto end;
1571 }
Richard Levittebc36ee62001-02-20 08:13:47 +00001572#ifndef OPENSSL_NO_DH
Matt Caswell0f113f32015-01-22 03:40:55 +00001573 if (!no_dhe) {
1574 if (dhe1024dsa) {
1575 /*
1576 * use SSL_OP_SINGLE_DH_USE to avoid small subgroup attacks
1577 */
1578 SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_DH_USE);
1579 dh = get_dh1024dsa();
Emilia Kaspere8356e32015-05-22 18:35:50 +02001580 } else if (dhe512)
Matt Caswell0f113f32015-01-22 03:40:55 +00001581 dh = get_dh512();
Emilia Kaspere8356e32015-05-22 18:35:50 +02001582 else
1583 dh = get_dh1024();
Matt Caswell0f113f32015-01-22 03:40:55 +00001584 SSL_CTX_set_tmp_dh(s_ctx, dh);
1585 DH_free(dh);
1586 }
Bodo Möllere4589582000-03-10 13:23:20 +00001587#else
Matt Caswell0f113f32015-01-22 03:40:55 +00001588 (void)no_dhe;
Ralf S. Engelschall58964a41998-12-21 10:56:39 +00001589#endif
1590
Rich Salz10bf4fc2015-03-10 19:09:27 -04001591#ifndef OPENSSL_NO_EC
Matt Caswell0f113f32015-01-22 03:40:55 +00001592 if (!no_ecdhe) {
1593 int nid;
Nils Larsch9dd84052005-05-16 10:11:04 +00001594
Matt Caswell0f113f32015-01-22 03:40:55 +00001595 if (named_curve != NULL) {
1596 nid = OBJ_sn2nid(named_curve);
1597 if (nid == 0) {
1598 BIO_printf(bio_err, "unknown curve name (%s)\n", named_curve);
1599 goto end;
1600 }
Emilia Kasperde57d232015-05-20 15:47:51 +02001601 } else {
Matt Caswell0f113f32015-01-22 03:40:55 +00001602 nid = NID_X9_62_prime256v1;
Emilia Kasperde57d232015-05-20 15:47:51 +02001603 }
Matt Caswell0f113f32015-01-22 03:40:55 +00001604
1605 ecdh = EC_KEY_new_by_curve_name(nid);
1606 if (ecdh == NULL) {
1607 BIO_printf(bio_err, "unable to create curve\n");
1608 goto end;
1609 }
1610
1611 SSL_CTX_set_tmp_ecdh(s_ctx, ecdh);
1612 SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_ECDH_USE);
1613 EC_KEY_free(ecdh);
1614 }
Dr. Stephen Hensonb3310162011-02-12 17:23:32 +00001615#else
Matt Caswell0f113f32015-01-22 03:40:55 +00001616 (void)no_ecdhe;
Bodo Möllerea262262002-08-09 08:56:08 +00001617#endif
1618
Matt Caswell0f113f32015-01-22 03:40:55 +00001619 if ((!SSL_CTX_load_verify_locations(s_ctx, CAfile, CApath)) ||
1620 (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1621 (!SSL_CTX_load_verify_locations(c_ctx, CAfile, CApath)) ||
Rob Percivaldd696a52016-03-02 13:34:05 +00001622 (!SSL_CTX_set_default_verify_paths(c_ctx))) {
Matt Caswell0f113f32015-01-22 03:40:55 +00001623 /* fprintf(stderr,"SSL_load_verify_locations\n"); */
1624 ERR_print_errors(bio_err);
1625 /* goto end; */
1626 }
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00001627
Rob Percivaldd696a52016-03-02 13:34:05 +00001628 if (!SSL_CTX_set_default_ctlog_list_file(s_ctx) ||
1629 !SSL_CTX_set_default_ctlog_list_file(c_ctx)) {
1630 ERR_print_errors(bio_err);
1631 }
1632
Matt Caswell0f113f32015-01-22 03:40:55 +00001633 if (client_auth) {
Rich Salz3dca57f2015-04-21 15:52:51 -04001634 printf("client authentication\n");
Matt Caswell0f113f32015-01-22 03:40:55 +00001635 SSL_CTX_set_verify(s_ctx,
1636 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1637 verify_callback);
1638 SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback,
1639 &app_verify_arg);
1640 }
1641 if (server_auth) {
Rich Salz3dca57f2015-04-21 15:52:51 -04001642 printf("server authentication\n");
Matt Caswell0f113f32015-01-22 03:40:55 +00001643 SSL_CTX_set_verify(c_ctx, SSL_VERIFY_PEER, verify_callback);
1644 SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback,
1645 &app_verify_arg);
1646 }
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00001647
Matt Caswell0f113f32015-01-22 03:40:55 +00001648 {
1649 int session_id_context = 0;
Viktor Dukhovni61986d32015-04-16 01:50:03 -04001650 if (!SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context,
Matt Caswell69f68232015-03-06 14:37:17 +00001651 sizeof session_id_context)) {
1652 ERR_print_errors(bio_err);
1653 goto end;
1654 }
Matt Caswell0f113f32015-01-22 03:40:55 +00001655 }
1656
1657 /* Use PSK only if PSK key is given */
1658 if (psk_key != NULL) {
1659 /*
1660 * no_psk is used to avoid putting psk command to openssl tool
1661 */
1662 if (no_psk) {
1663 /*
1664 * if PSK is not compiled in and psk key is given, do nothing and
1665 * exit successfully
1666 */
1667 ret = 0;
1668 goto end;
1669 }
Nils Larschddac1972006-03-10 23:06:27 +00001670#ifndef OPENSSL_NO_PSK
Matt Caswell0f113f32015-01-22 03:40:55 +00001671 SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1672 SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1673 if (debug)
1674 BIO_printf(bio_err, "setting PSK identity hint to s_ctx\n");
1675 if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint")) {
1676 BIO_printf(bio_err, "error setting PSK identity hint to s_ctx\n");
1677 ERR_print_errors(bio_err);
1678 goto end;
1679 }
Nils Larschddac1972006-03-10 23:06:27 +00001680#endif
Matt Caswell0f113f32015-01-22 03:40:55 +00001681 }
Ben Laurieedc032b2011-03-12 17:01:19 +00001682#ifndef OPENSSL_NO_SRP
Matt Caswell0f113f32015-01-22 03:40:55 +00001683 if (srp_client_arg.srplogin) {
1684 if (!SSL_CTX_set_srp_username(c_ctx, srp_client_arg.srplogin)) {
1685 BIO_printf(bio_err, "Unable to set SRP username\n");
1686 goto end;
1687 }
1688 SSL_CTX_set_srp_cb_arg(c_ctx, &srp_client_arg);
1689 SSL_CTX_set_srp_client_pwd_callback(c_ctx,
1690 ssl_give_srp_client_pwd_cb);
1691 /*
1692 * SSL_CTX_set_srp_strength(c_ctx, srp_client_arg.strength);
1693 */
1694 }
Ben Laurieedc032b2011-03-12 17:01:19 +00001695
Matt Caswell0f113f32015-01-22 03:40:55 +00001696 if (srp_server_arg.expected_user != NULL) {
1697 SSL_CTX_set_verify(s_ctx, SSL_VERIFY_NONE, verify_callback);
1698 SSL_CTX_set_srp_cb_arg(s_ctx, &srp_server_arg);
1699 SSL_CTX_set_srp_username_callback(s_ctx, ssl_srp_server_param_cb);
1700 }
Ben Laurieedc032b2011-03-12 17:01:19 +00001701#endif
Nils Larschddac1972006-03-10 23:06:27 +00001702
Piotr Sikora29115752013-11-13 15:20:22 -08001703#ifndef OPENSSL_NO_NEXTPROTONEG
Matt Caswell0f113f32015-01-22 03:40:55 +00001704 if (npn_client) {
1705 SSL_CTX_set_next_proto_select_cb(c_ctx, cb_client_npn, NULL);
1706 }
1707 if (npn_server) {
1708 if (npn_server_reject) {
1709 BIO_printf(bio_err,
1710 "Can't have both -npn_server and -npn_server_reject\n");
1711 goto end;
1712 }
1713 SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_npn, NULL);
1714 }
1715 if (npn_server_reject) {
1716 SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_rejects_npn,
1717 NULL);
1718 }
Ben Lauried9a268b2010-09-05 16:35:10 +00001719#endif
1720
Matt Caswell69f68232015-03-06 14:37:17 +00001721 if (serverinfo_sct) {
Rob Percivaldd696a52016-03-02 13:34:05 +00001722 if (!SSL_CTX_add_client_custom_ext(c_ctx,
1723 TLSEXT_TYPE_signed_certificate_timestamp,
1724 NULL, NULL, NULL,
1725 serverinfo_cli_parse_cb, NULL)) {
Matt Caswell69f68232015-03-06 14:37:17 +00001726 BIO_printf(bio_err, "Error adding SCT extension\n");
1727 goto end;
1728 }
1729 }
1730 if (serverinfo_tack) {
Viktor Dukhovni61986d32015-04-16 01:50:03 -04001731 if (!SSL_CTX_add_client_custom_ext(c_ctx, TACK_EXT_TYPE,
Matt Caswell0f113f32015-01-22 03:40:55 +00001732 NULL, NULL, NULL,
Matt Caswell69f68232015-03-06 14:37:17 +00001733 serverinfo_cli_parse_cb, NULL)) {
1734 BIO_printf(bio_err, "Error adding TACK extension\n");
1735 goto end;
1736 }
1737 }
Matt Caswell0f113f32015-01-22 03:40:55 +00001738 if (serverinfo_file)
1739 if (!SSL_CTX_use_serverinfo_file(s_ctx, serverinfo_file)) {
1740 BIO_printf(bio_err, "missing serverinfo file\n");
1741 goto end;
1742 }
Trevora398f822013-05-12 18:55:27 -07001743
Matt Caswell0f113f32015-01-22 03:40:55 +00001744 if (custom_ext) {
Viktor Dukhovni61986d32015-04-16 01:50:03 -04001745 if (!SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_0,
Matt Caswell0f113f32015-01-22 03:40:55 +00001746 custom_ext_0_cli_add_cb,
1747 NULL, NULL,
Matt Caswell69f68232015-03-06 14:37:17 +00001748 custom_ext_0_cli_parse_cb, NULL)
Viktor Dukhovni61986d32015-04-16 01:50:03 -04001749 || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_1,
Matt Caswell0f113f32015-01-22 03:40:55 +00001750 custom_ext_1_cli_add_cb,
1751 NULL, NULL,
Matt Caswell69f68232015-03-06 14:37:17 +00001752 custom_ext_1_cli_parse_cb, NULL)
Viktor Dukhovni61986d32015-04-16 01:50:03 -04001753 || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_2,
Matt Caswell0f113f32015-01-22 03:40:55 +00001754 custom_ext_2_cli_add_cb,
1755 NULL, NULL,
Matt Caswell69f68232015-03-06 14:37:17 +00001756 custom_ext_2_cli_parse_cb, NULL)
Viktor Dukhovni61986d32015-04-16 01:50:03 -04001757 || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_3,
Matt Caswell0f113f32015-01-22 03:40:55 +00001758 custom_ext_3_cli_add_cb,
1759 NULL, NULL,
Matt Caswell69f68232015-03-06 14:37:17 +00001760 custom_ext_3_cli_parse_cb, NULL)
Viktor Dukhovni61986d32015-04-16 01:50:03 -04001761 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_0,
Matt Caswell0f113f32015-01-22 03:40:55 +00001762 custom_ext_0_srv_add_cb,
1763 NULL, NULL,
Matt Caswell69f68232015-03-06 14:37:17 +00001764 custom_ext_0_srv_parse_cb, NULL)
Viktor Dukhovni61986d32015-04-16 01:50:03 -04001765 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_1,
Matt Caswell0f113f32015-01-22 03:40:55 +00001766 custom_ext_1_srv_add_cb,
1767 NULL, NULL,
Matt Caswell69f68232015-03-06 14:37:17 +00001768 custom_ext_1_srv_parse_cb, NULL)
Viktor Dukhovni61986d32015-04-16 01:50:03 -04001769 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_2,
Matt Caswell0f113f32015-01-22 03:40:55 +00001770 custom_ext_2_srv_add_cb,
1771 NULL, NULL,
Matt Caswell69f68232015-03-06 14:37:17 +00001772 custom_ext_2_srv_parse_cb, NULL)
Viktor Dukhovni61986d32015-04-16 01:50:03 -04001773 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_3,
Matt Caswell0f113f32015-01-22 03:40:55 +00001774 custom_ext_3_srv_add_cb,
1775 NULL, NULL,
Matt Caswell69f68232015-03-06 14:37:17 +00001776 custom_ext_3_srv_parse_cb, NULL)) {
1777 BIO_printf(bio_err, "Error setting custom extensions\n");
1778 goto end;
1779 }
Matt Caswell0f113f32015-01-22 03:40:55 +00001780 }
Trevor9cd50f72013-06-13 22:36:45 -07001781
Matt Caswell0f113f32015-01-22 03:40:55 +00001782 if (alpn_server)
1783 SSL_CTX_set_alpn_select_cb(s_ctx, cb_server_alpn, NULL);
Trevor9cd50f72013-06-13 22:36:45 -07001784
Matt Caswell0f113f32015-01-22 03:40:55 +00001785 if (alpn_client) {
1786 unsigned short alpn_len;
1787 unsigned char *alpn = next_protos_parse(&alpn_len, alpn_client);
Adam Langleya8989362013-07-15 15:57:16 -04001788
Matt Caswell0f113f32015-01-22 03:40:55 +00001789 if (alpn == NULL) {
1790 BIO_printf(bio_err, "Error parsing -alpn_client argument\n");
1791 goto end;
1792 }
Matt Caswell69f68232015-03-06 14:37:17 +00001793 /* Returns 0 on success!! */
Viktor Dukhovni61986d32015-04-16 01:50:03 -04001794 if (SSL_CTX_set_alpn_protos(c_ctx, alpn, alpn_len)) {
Matt Caswell69f68232015-03-06 14:37:17 +00001795 BIO_printf(bio_err, "Error setting ALPN\n");
1796 OPENSSL_free(alpn);
1797 goto end;
1798 }
Matt Caswell0f113f32015-01-22 03:40:55 +00001799 OPENSSL_free(alpn);
1800 }
Adam Langleya8989362013-07-15 15:57:16 -04001801
Matt Caswell0f113f32015-01-22 03:40:55 +00001802 c_ssl = SSL_new(c_ctx);
1803 s_ssl = SSL_new(s_ctx);
Ralf S. Engelschall58964a41998-12-21 10:56:39 +00001804
Kurt Roeckx7946ab32015-12-06 17:56:41 +01001805 if (!set_protocol_version(server_min_proto, s_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1806 goto end;
1807 if (!set_protocol_version(server_max_proto, s_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1808 goto end;
1809 if (!set_protocol_version(client_min_proto, c_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1810 goto end;
1811 if (!set_protocol_version(client_max_proto, c_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1812 goto end;
1813
Rich Salz3dca57f2015-04-21 15:52:51 -04001814 BIO_printf(bio_stdout, "Doing handshakes=%d bytes=%ld\n", number, bytes);
Matt Caswell0f113f32015-01-22 03:40:55 +00001815 for (i = 0; i < number; i++) {
Matt Caswell69f68232015-03-06 14:37:17 +00001816 if (!reuse) {
Viktor Dukhovni61986d32015-04-16 01:50:03 -04001817 if (!SSL_set_session(c_ssl, NULL)) {
Matt Caswell69f68232015-03-06 14:37:17 +00001818 BIO_printf(bio_err, "Failed to set session\n");
1819 goto end;
1820 }
1821 }
Richard Levitte75d5bd42016-02-02 23:50:52 +01001822 switch (bio_type) {
1823 case BIO_MEM:
Matt Caswell0f113f32015-01-22 03:40:55 +00001824 ret = doit(s_ssl, c_ssl, bytes);
Richard Levitte75d5bd42016-02-02 23:50:52 +01001825 break;
1826 case BIO_PAIR:
1827 ret = doit_biopair(s_ssl, c_ssl, bytes, &s_time, &c_time);
1828 break;
1829 case BIO_IPV4:
1830 ret = doit_localhost(s_ssl, c_ssl, BIO_FAMILY_IPV4,
1831 bytes, &s_time, &c_time);
1832 break;
1833 case BIO_IPV6:
1834 ret = doit_localhost(s_ssl, c_ssl, BIO_FAMILY_IPV6,
1835 bytes, &s_time, &c_time);
1836 break;
1837 }
1838 if (ret) break;
Matt Caswell0f113f32015-01-22 03:40:55 +00001839 }
Ralf S. Engelschall58964a41998-12-21 10:56:39 +00001840
Kurt Roeckx7946ab32015-12-06 17:56:41 +01001841 if (should_negotiate && ret == 0 &&
1842 strcmp(should_negotiate, "fail-server") != 0 &&
1843 strcmp(should_negotiate, "fail-client") != 0) {
1844 int version = protocol_from_string(should_negotiate);
1845 if (version < 0) {
1846 BIO_printf(bio_err, "Error parsing: %s\n", should_negotiate);
1847 ret = 1;
1848 goto err;
1849 }
1850 if (SSL_version(c_ssl) != version) {
1851 BIO_printf(bio_err, "Unxpected version negotiated. "
1852 "Expected: %s, got %s\n", should_negotiate, SSL_get_version(c_ssl));
1853 ret = 1;
1854 goto err;
1855 }
1856 }
1857
Matt Caswell0f113f32015-01-22 03:40:55 +00001858 if (!verbose) {
1859 print_details(c_ssl, "");
1860 }
Matt Caswell0f113f32015-01-22 03:40:55 +00001861 if (print_time) {
Bodo Möller617d71b2000-03-26 12:27:30 +00001862#ifdef CLOCKS_PER_SEC
Matt Caswell0f113f32015-01-22 03:40:55 +00001863 /*
1864 * "To determine the time in seconds, the value returned by the clock
1865 * function should be divided by the value of the macro
1866 * CLOCKS_PER_SEC." -- ISO/IEC 9899
1867 */
1868 BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1869 "Approximate total client time: %6.2f s\n",
1870 (double)s_time / CLOCKS_PER_SEC,
1871 (double)c_time / CLOCKS_PER_SEC);
Bodo Möller617d71b2000-03-26 12:27:30 +00001872#else
Matt Caswell0f113f32015-01-22 03:40:55 +00001873 BIO_printf(bio_stdout,
1874 "Approximate total server time: %6.2f units\n"
1875 "Approximate total client time: %6.2f units\n",
1876 (double)s_time, (double)c_time);
Bodo Möller617d71b2000-03-26 12:27:30 +00001877#endif
Matt Caswell0f113f32015-01-22 03:40:55 +00001878 }
Ralf S. Engelschall58964a41998-12-21 10:56:39 +00001879
Kurt Roeckx7946ab32015-12-06 17:56:41 +01001880 err:
Matt Caswell0f113f32015-01-22 03:40:55 +00001881 SSL_free(s_ssl);
1882 SSL_free(c_ssl);
Ralf S. Engelschall58964a41998-12-21 10:56:39 +00001883
Matt Caswell0f113f32015-01-22 03:40:55 +00001884 end:
Rich Salz62adbce2015-04-11 10:22:36 -04001885 SSL_CTX_free(s_ctx);
1886 SSL_CTX_free(c_ctx);
Rich Salz62adbce2015-04-11 10:22:36 -04001887 SSL_CONF_CTX_free(s_cctx);
1888 SSL_CONF_CTX_free(c_cctx);
Matt Caswell0f113f32015-01-22 03:40:55 +00001889 sk_OPENSSL_STRING_free(conf_args);
Dr. Stephen Hensonde942222014-10-27 14:07:12 +00001890
Rich Salzca3a82c2015-03-25 11:31:18 -04001891 BIO_free(bio_stdout);
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00001892
Viktor Dukhovnic2e27312016-01-10 14:42:10 -05001893#ifndef OPENSSL_NO_CRYPTO_MDEBUG
Dr. Stephen Henson541e9562016-01-14 22:00:03 +00001894 if (CRYPTO_mem_leaks(bio_err) <= 0)
1895 ret = 1;
Rich Salzbbd86bf2016-01-07 15:06:38 -05001896#endif
Rich Salzca3a82c2015-03-25 11:31:18 -04001897 BIO_free(bio_err);
Matt Caswell0f113f32015-01-22 03:40:55 +00001898 EXIT(ret);
Matt Caswell0f113f32015-01-22 03:40:55 +00001899}
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00001900
Richard Levitte75d5bd42016-02-02 23:50:52 +01001901int doit_localhost(SSL *s_ssl, SSL *c_ssl, int family, long count,
1902 clock_t *s_time, clock_t *c_time)
1903{
1904 long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1905 BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1906 BIO *acpt = NULL, *server = NULL, *client = NULL;
1907 char addr_str[40];
1908 int ret = 1;
1909 int err_in_client = 0;
1910 int err_in_server = 0;
1911
1912 acpt = BIO_new_accept("0");
1913 if (acpt == NULL)
1914 goto err;
1915 BIO_set_accept_ip_family(acpt, family);
1916 BIO_set_bind_mode(acpt, BIO_SOCK_NONBLOCK | BIO_SOCK_REUSEADDR);
1917 if (BIO_do_accept(acpt) <= 0)
1918 goto err;
1919
Richard Levitte6339ece2016-02-03 22:41:14 +01001920 BIO_snprintf(addr_str, sizeof(addr_str), ":%s", BIO_get_accept_port(acpt));
Richard Levitte75d5bd42016-02-02 23:50:52 +01001921
1922 client = BIO_new_connect(addr_str);
1923 BIO_set_conn_ip_family(client, family);
1924 if (!client)
1925 goto err;
1926
1927 if (BIO_set_nbio(client, 1) <= 0)
1928 goto err;
1929 if (BIO_set_nbio(acpt, 1) <= 0)
1930 goto err;
1931
1932 {
1933 int st_connect = 0, st_accept = 0;
1934
1935 while(!st_connect || !st_accept) {
1936 if (!st_connect) {
1937 if (BIO_do_connect(client) <= 0) {
1938 if (!BIO_should_retry(client))
1939 goto err;
1940 } else {
1941 st_connect = 1;
1942 }
1943 }
1944 if (!st_accept) {
1945 if (BIO_do_accept(acpt) <= 0) {
1946 if (!BIO_should_retry(acpt))
1947 goto err;
1948 } else {
1949 st_accept = 1;
1950 }
1951 }
1952 }
1953 }
1954 /* We're not interested in accepting further connects */
1955 server = BIO_pop(acpt);
1956 BIO_free_all(acpt);
1957 acpt = NULL;
1958
1959 s_ssl_bio = BIO_new(BIO_f_ssl());
1960 if (!s_ssl_bio)
1961 goto err;
1962
1963 c_ssl_bio = BIO_new(BIO_f_ssl());
1964 if (!c_ssl_bio)
1965 goto err;
1966
1967 SSL_set_connect_state(c_ssl);
1968 SSL_set_bio(c_ssl, client, client);
1969 (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1970
1971 SSL_set_accept_state(s_ssl);
1972 SSL_set_bio(s_ssl, server, server);
1973 (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1974
1975 do {
1976 /*-
1977 * c_ssl_bio: SSL filter BIO
1978 *
1979 * client: I/O for SSL library
1980 *
1981 *
1982 * server: I/O for SSL library
1983 *
1984 * s_ssl_bio: SSL filter BIO
1985 */
1986
1987 /*
1988 * We have non-blocking behaviour throughout this test program, but
1989 * can be sure that there is *some* progress in each iteration; so we
1990 * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
1991 * we just try everything in each iteration
1992 */
1993
1994 {
1995 /* CLIENT */
1996
1997 char cbuf[1024 * 8];
1998 int i, r;
1999 clock_t c_clock = clock();
2000
2001 memset(cbuf, 0, sizeof(cbuf));
2002
2003 if (debug)
2004 if (SSL_in_init(c_ssl))
2005 printf("client waiting in SSL_connect - %s\n",
2006 SSL_state_string_long(c_ssl));
2007
2008 if (cw_num > 0) {
2009 /* Write to server. */
2010
2011 if (cw_num > (long)sizeof cbuf)
2012 i = sizeof cbuf;
2013 else
2014 i = (int)cw_num;
2015 r = BIO_write(c_ssl_bio, cbuf, i);
2016 if (r < 0) {
2017 if (!BIO_should_retry(c_ssl_bio)) {
2018 fprintf(stderr, "ERROR in CLIENT\n");
2019 err_in_client = 1;
2020 goto err;
2021 }
2022 /*
2023 * BIO_should_retry(...) can just be ignored here. The
2024 * library expects us to call BIO_write with the same
2025 * arguments again, and that's what we will do in the
2026 * next iteration.
2027 */
2028 } else if (r == 0) {
2029 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2030 goto err;
2031 } else {
2032 if (debug)
2033 printf("client wrote %d\n", r);
2034 cw_num -= r;
2035 }
2036 }
2037
2038 if (cr_num > 0) {
2039 /* Read from server. */
2040
2041 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
2042 if (r < 0) {
2043 if (!BIO_should_retry(c_ssl_bio)) {
2044 fprintf(stderr, "ERROR in CLIENT\n");
2045 err_in_client = 1;
2046 goto err;
2047 }
2048 /*
2049 * Again, "BIO_should_retry" can be ignored.
2050 */
2051 } else if (r == 0) {
2052 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2053 goto err;
2054 } else {
2055 if (debug)
2056 printf("client read %d\n", r);
2057 cr_num -= r;
2058 }
2059 }
2060
2061 /*
2062 * c_time and s_time increments will typically be very small
2063 * (depending on machine speed and clock tick intervals), but
2064 * sampling over a large number of connections should result in
2065 * fairly accurate figures. We cannot guarantee a lot, however
2066 * -- if each connection lasts for exactly one clock tick, it
2067 * will be counted only for the client or only for the server or
2068 * even not at all.
2069 */
2070 *c_time += (clock() - c_clock);
2071 }
2072
2073 {
2074 /* SERVER */
2075
2076 char sbuf[1024 * 8];
2077 int i, r;
2078 clock_t s_clock = clock();
2079
2080 memset(sbuf, 0, sizeof(sbuf));
2081
2082 if (debug)
2083 if (SSL_in_init(s_ssl))
2084 printf("server waiting in SSL_accept - %s\n",
2085 SSL_state_string_long(s_ssl));
2086
2087 if (sw_num > 0) {
2088 /* Write to client. */
2089
2090 if (sw_num > (long)sizeof sbuf)
2091 i = sizeof sbuf;
2092 else
2093 i = (int)sw_num;
2094 r = BIO_write(s_ssl_bio, sbuf, i);
2095 if (r < 0) {
2096 if (!BIO_should_retry(s_ssl_bio)) {
2097 fprintf(stderr, "ERROR in SERVER\n");
2098 err_in_server = 1;
2099 goto err;
2100 }
2101 /* Ignore "BIO_should_retry". */
2102 } else if (r == 0) {
2103 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2104 goto err;
2105 } else {
2106 if (debug)
2107 printf("server wrote %d\n", r);
2108 sw_num -= r;
2109 }
2110 }
2111
2112 if (sr_num > 0) {
2113 /* Read from client. */
2114
2115 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2116 if (r < 0) {
2117 if (!BIO_should_retry(s_ssl_bio)) {
2118 fprintf(stderr, "ERROR in SERVER\n");
2119 err_in_server = 1;
2120 goto err;
2121 }
2122 /* blah, blah */
2123 } else if (r == 0) {
2124 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2125 goto err;
2126 } else {
2127 if (debug)
2128 printf("server read %d\n", r);
2129 sr_num -= r;
2130 }
2131 }
2132
2133 *s_time += (clock() - s_clock);
2134 }
2135 }
2136 while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2137
2138 if (verbose)
2139 print_details(c_ssl, "DONE via TCP connect: ");
2140#ifndef OPENSSL_NO_NEXTPROTONEG
2141 if (verify_npn(c_ssl, s_ssl) < 0) {
2142 ret = 1;
2143 goto end;
2144 }
2145#endif
2146 if (verify_serverinfo() < 0) {
2147 fprintf(stderr, "Server info verify error\n");
2148 ret = 1;
2149 goto err;
2150 }
2151 if (verify_alpn(c_ssl, s_ssl) < 0) {
2152 ret = 1;
2153 goto err;
2154 }
2155
2156 if (custom_ext_error) {
2157 fprintf(stderr, "Custom extension error\n");
2158 ret = 1;
2159 goto err;
2160 }
2161
2162 end:
2163 ret = 0;
2164
2165 err:
2166 ERR_print_errors(bio_err);
2167
2168 BIO_free_all(acpt);
2169 BIO_free(server);
2170 BIO_free(client);
2171 BIO_free(s_ssl_bio);
2172 BIO_free(c_ssl_bio);
2173
2174 if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2175 ret = (err_in_client != 0) ? 0 : 1;
2176 else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2177 ret = (err_in_server != 0) ? 0 : 1;
2178
2179 return ret;
2180}
2181
Bodo Möller563f1502000-03-13 15:06:54 +00002182int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
Matt Caswell0f113f32015-01-22 03:40:55 +00002183 clock_t *s_time, clock_t *c_time)
2184{
2185 long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
2186 BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
2187 BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
2188 int ret = 1;
Kurt Roeckx7946ab32015-12-06 17:56:41 +01002189 int err_in_client = 0;
2190 int err_in_server = 0;
Bodo Möller95d29591999-06-12 01:03:40 +00002191
Matt Caswell0f113f32015-01-22 03:40:55 +00002192 size_t bufsiz = 256; /* small buffer for testing */
Bodo Möller95d29591999-06-12 01:03:40 +00002193
Matt Caswell0f113f32015-01-22 03:40:55 +00002194 if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
2195 goto err;
2196 if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
2197 goto err;
Bodo Möller95d29591999-06-12 01:03:40 +00002198
Matt Caswell0f113f32015-01-22 03:40:55 +00002199 s_ssl_bio = BIO_new(BIO_f_ssl());
2200 if (!s_ssl_bio)
2201 goto err;
Bodo Möller95d29591999-06-12 01:03:40 +00002202
Matt Caswell0f113f32015-01-22 03:40:55 +00002203 c_ssl_bio = BIO_new(BIO_f_ssl());
2204 if (!c_ssl_bio)
2205 goto err;
Bodo Möller95d29591999-06-12 01:03:40 +00002206
Matt Caswell0f113f32015-01-22 03:40:55 +00002207 SSL_set_connect_state(c_ssl);
2208 SSL_set_bio(c_ssl, client, client);
2209 (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
Bodo Möller95d29591999-06-12 01:03:40 +00002210
Matt Caswell0f113f32015-01-22 03:40:55 +00002211 SSL_set_accept_state(s_ssl);
2212 SSL_set_bio(s_ssl, server, server);
2213 (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
Bodo Möller95d29591999-06-12 01:03:40 +00002214
Matt Caswell0f113f32015-01-22 03:40:55 +00002215 do {
Matt Caswell35a1cc92015-01-17 00:06:54 +00002216 /*-
2217 * c_ssl_bio: SSL filter BIO
2218 *
2219 * client: pseudo-I/O for SSL library
2220 *
2221 * client_io: client's SSL communication; usually to be
2222 * relayed over some I/O facility, but in this
2223 * test program, we're the server, too:
2224 *
2225 * server_io: server's SSL communication
2226 *
2227 * server: pseudo-I/O for SSL library
2228 *
2229 * s_ssl_bio: SSL filter BIO
2230 *
2231 * The client and the server each employ a "BIO pair":
2232 * client + client_io, server + server_io.
2233 * BIO pairs are symmetric. A BIO pair behaves similar
2234 * to a non-blocking socketpair (but both endpoints must
2235 * be handled by the same thread).
2236 * [Here we could connect client and server to the ends
2237 * of a single BIO pair, but then this code would be less
2238 * suitable as an example for BIO pairs in general.]
2239 *
2240 * Useful functions for querying the state of BIO pair endpoints:
2241 *
2242 * BIO_ctrl_pending(bio) number of bytes we can read now
2243 * BIO_ctrl_get_read_request(bio) number of bytes needed to fulfil
2244 * other side's read attempt
2245 * BIO_ctrl_get_write_guarantee(bio) number of bytes we can write now
2246 *
2247 * ..._read_request is never more than ..._write_guarantee;
2248 * it depends on the application which one you should use.
2249 */
Bodo Möller95d29591999-06-12 01:03:40 +00002250
Matt Caswell0f113f32015-01-22 03:40:55 +00002251 /*
2252 * We have non-blocking behaviour throughout this test program, but
2253 * can be sure that there is *some* progress in each iteration; so we
2254 * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
2255 * we just try everything in each iteration
2256 */
Bodo Möller896e4fe2002-11-05 13:54:41 +00002257
Matt Caswell0f113f32015-01-22 03:40:55 +00002258 {
2259 /* CLIENT */
Bodo Möller95d29591999-06-12 01:03:40 +00002260
Rich Salz68b00c22015-01-23 11:58:26 -05002261 char cbuf[1024 * 8];
Matt Caswell0f113f32015-01-22 03:40:55 +00002262 int i, r;
2263 clock_t c_clock = clock();
Bodo Möller95d29591999-06-12 01:03:40 +00002264
Matt Caswell0f113f32015-01-22 03:40:55 +00002265 memset(cbuf, 0, sizeof(cbuf));
Bodo Möller95d29591999-06-12 01:03:40 +00002266
Matt Caswell0f113f32015-01-22 03:40:55 +00002267 if (debug)
2268 if (SSL_in_init(c_ssl))
2269 printf("client waiting in SSL_connect - %s\n",
2270 SSL_state_string_long(c_ssl));
Bodo Möller563f1502000-03-13 15:06:54 +00002271
Matt Caswell0f113f32015-01-22 03:40:55 +00002272 if (cw_num > 0) {
2273 /* Write to server. */
Bodo Möller95d29591999-06-12 01:03:40 +00002274
Matt Caswell0f113f32015-01-22 03:40:55 +00002275 if (cw_num > (long)sizeof cbuf)
2276 i = sizeof cbuf;
2277 else
2278 i = (int)cw_num;
2279 r = BIO_write(c_ssl_bio, cbuf, i);
2280 if (r < 0) {
2281 if (!BIO_should_retry(c_ssl_bio)) {
2282 fprintf(stderr, "ERROR in CLIENT\n");
Kurt Roeckx7946ab32015-12-06 17:56:41 +01002283 err_in_client = 1;
Matt Caswell0f113f32015-01-22 03:40:55 +00002284 goto err;
2285 }
2286 /*
2287 * BIO_should_retry(...) can just be ignored here. The
2288 * library expects us to call BIO_write with the same
2289 * arguments again, and that's what we will do in the
2290 * next iteration.
2291 */
2292 } else if (r == 0) {
2293 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2294 goto err;
2295 } else {
2296 if (debug)
2297 printf("client wrote %d\n", r);
2298 cw_num -= r;
2299 }
2300 }
Bodo Möller95d29591999-06-12 01:03:40 +00002301
Matt Caswell0f113f32015-01-22 03:40:55 +00002302 if (cr_num > 0) {
2303 /* Read from server. */
Bodo Möller896e4fe2002-11-05 13:54:41 +00002304
Matt Caswell0f113f32015-01-22 03:40:55 +00002305 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
2306 if (r < 0) {
2307 if (!BIO_should_retry(c_ssl_bio)) {
2308 fprintf(stderr, "ERROR in CLIENT\n");
Kurt Roeckx7946ab32015-12-06 17:56:41 +01002309 err_in_client = 1;
Matt Caswell0f113f32015-01-22 03:40:55 +00002310 goto err;
2311 }
2312 /*
2313 * Again, "BIO_should_retry" can be ignored.
2314 */
2315 } else if (r == 0) {
2316 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2317 goto err;
2318 } else {
2319 if (debug)
2320 printf("client read %d\n", r);
2321 cr_num -= r;
2322 }
2323 }
Bodo Möller95d29591999-06-12 01:03:40 +00002324
Matt Caswell0f113f32015-01-22 03:40:55 +00002325 /*
2326 * c_time and s_time increments will typically be very small
2327 * (depending on machine speed and clock tick intervals), but
2328 * sampling over a large number of connections should result in
2329 * fairly accurate figures. We cannot guarantee a lot, however
2330 * -- if each connection lasts for exactly one clock tick, it
2331 * will be counted only for the client or only for the server or
2332 * even not at all.
2333 */
2334 *c_time += (clock() - c_clock);
2335 }
Bodo Möller95d29591999-06-12 01:03:40 +00002336
Matt Caswell0f113f32015-01-22 03:40:55 +00002337 {
2338 /* SERVER */
Bodo Möller95d29591999-06-12 01:03:40 +00002339
Rich Salz68b00c22015-01-23 11:58:26 -05002340 char sbuf[1024 * 8];
Matt Caswell0f113f32015-01-22 03:40:55 +00002341 int i, r;
2342 clock_t s_clock = clock();
Bodo Möller563f1502000-03-13 15:06:54 +00002343
Matt Caswell0f113f32015-01-22 03:40:55 +00002344 memset(sbuf, 0, sizeof(sbuf));
Bodo Möller95d29591999-06-12 01:03:40 +00002345
Matt Caswell0f113f32015-01-22 03:40:55 +00002346 if (debug)
2347 if (SSL_in_init(s_ssl))
2348 printf("server waiting in SSL_accept - %s\n",
2349 SSL_state_string_long(s_ssl));
Bodo Möller6f7af151999-09-10 14:03:21 +00002350
Matt Caswell0f113f32015-01-22 03:40:55 +00002351 if (sw_num > 0) {
2352 /* Write to client. */
Bodo Möller95d29591999-06-12 01:03:40 +00002353
Matt Caswell0f113f32015-01-22 03:40:55 +00002354 if (sw_num > (long)sizeof sbuf)
2355 i = sizeof sbuf;
2356 else
2357 i = (int)sw_num;
2358 r = BIO_write(s_ssl_bio, sbuf, i);
2359 if (r < 0) {
2360 if (!BIO_should_retry(s_ssl_bio)) {
2361 fprintf(stderr, "ERROR in SERVER\n");
Kurt Roeckx7946ab32015-12-06 17:56:41 +01002362 err_in_server = 1;
Matt Caswell0f113f32015-01-22 03:40:55 +00002363 goto err;
2364 }
2365 /* Ignore "BIO_should_retry". */
2366 } else if (r == 0) {
2367 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2368 goto err;
2369 } else {
2370 if (debug)
2371 printf("server wrote %d\n", r);
2372 sw_num -= r;
2373 }
2374 }
Bodo Möller6f7af151999-09-10 14:03:21 +00002375
Matt Caswell0f113f32015-01-22 03:40:55 +00002376 if (sr_num > 0) {
2377 /* Read from client. */
Bodo Möller95d29591999-06-12 01:03:40 +00002378
Matt Caswell0f113f32015-01-22 03:40:55 +00002379 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2380 if (r < 0) {
2381 if (!BIO_should_retry(s_ssl_bio)) {
2382 fprintf(stderr, "ERROR in SERVER\n");
Kurt Roeckx7946ab32015-12-06 17:56:41 +01002383 err_in_server = 1;
Matt Caswell0f113f32015-01-22 03:40:55 +00002384 goto err;
2385 }
2386 /* blah, blah */
2387 } else if (r == 0) {
2388 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2389 goto err;
2390 } else {
2391 if (debug)
2392 printf("server read %d\n", r);
2393 sr_num -= r;
2394 }
2395 }
Bodo Möller95d29591999-06-12 01:03:40 +00002396
Matt Caswell0f113f32015-01-22 03:40:55 +00002397 *s_time += (clock() - s_clock);
2398 }
Bodo Möller95d29591999-06-12 01:03:40 +00002399
Matt Caswell0f113f32015-01-22 03:40:55 +00002400 {
2401 /* "I/O" BETWEEN CLIENT AND SERVER. */
Bodo Möller6f7af151999-09-10 14:03:21 +00002402
Matt Caswell0f113f32015-01-22 03:40:55 +00002403 size_t r1, r2;
2404 BIO *io1 = server_io, *io2 = client_io;
2405 /*
2406 * we use the non-copying interface for io1 and the standard
2407 * BIO_write/BIO_read interface for io2
2408 */
Bodo Möller95d29591999-06-12 01:03:40 +00002409
Matt Caswell0f113f32015-01-22 03:40:55 +00002410 static int prev_progress = 1;
2411 int progress = 0;
Bodo Möller95d29591999-06-12 01:03:40 +00002412
Matt Caswell0f113f32015-01-22 03:40:55 +00002413 /* io1 to io2 */
2414 do {
2415 size_t num;
2416 int r;
2417
2418 r1 = BIO_ctrl_pending(io1);
2419 r2 = BIO_ctrl_get_write_guarantee(io2);
2420
2421 num = r1;
2422 if (r2 < num)
2423 num = r2;
2424 if (num) {
2425 char *dataptr;
2426
2427 if (INT_MAX < num) /* yeah, right */
2428 num = INT_MAX;
2429
2430 r = BIO_nread(io1, &dataptr, (int)num);
2431 assert(r > 0);
2432 assert(r <= (int)num);
2433 /*
2434 * possibly r < num (non-contiguous data)
2435 */
2436 num = r;
2437 r = BIO_write(io2, dataptr, (int)num);
2438 if (r != (int)num) { /* can't happen */
2439 fprintf(stderr, "ERROR: BIO_write could not write "
2440 "BIO_ctrl_get_write_guarantee() bytes");
2441 goto err;
2442 }
2443 progress = 1;
2444
2445 if (debug)
2446 printf((io1 == client_io) ?
2447 "C->S relaying: %d bytes\n" :
2448 "S->C relaying: %d bytes\n", (int)num);
2449 }
2450 }
2451 while (r1 && r2);
2452
2453 /* io2 to io1 */
2454 {
2455 size_t num;
2456 int r;
2457
2458 r1 = BIO_ctrl_pending(io2);
2459 r2 = BIO_ctrl_get_read_request(io1);
2460 /*
2461 * here we could use ..._get_write_guarantee instead of
2462 * ..._get_read_request, but by using the latter we test
2463 * restartability of the SSL implementation more thoroughly
2464 */
2465 num = r1;
2466 if (r2 < num)
2467 num = r2;
2468 if (num) {
2469 char *dataptr;
2470
2471 if (INT_MAX < num)
2472 num = INT_MAX;
2473
2474 if (num > 1)
2475 --num; /* test restartability even more thoroughly */
2476
2477 r = BIO_nwrite0(io1, &dataptr);
2478 assert(r > 0);
2479 if (r < (int)num)
2480 num = r;
2481 r = BIO_read(io2, dataptr, (int)num);
2482 if (r != (int)num) { /* can't happen */
2483 fprintf(stderr, "ERROR: BIO_read could not read "
2484 "BIO_ctrl_pending() bytes");
2485 goto err;
2486 }
2487 progress = 1;
2488 r = BIO_nwrite(io1, &dataptr, (int)num);
2489 if (r != (int)num) { /* can't happen */
2490 fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
2491 "BIO_nwrite0() bytes");
2492 goto err;
2493 }
2494
2495 if (debug)
2496 printf((io2 == client_io) ?
2497 "C->S relaying: %d bytes\n" :
2498 "S->C relaying: %d bytes\n", (int)num);
2499 }
2500 } /* no loop, BIO_ctrl_get_read_request now
2501 * returns 0 anyway */
2502
2503 if (!progress && !prev_progress)
2504 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0) {
2505 fprintf(stderr, "ERROR: got stuck\n");
2506 fprintf(stderr, " ERROR.\n");
2507 goto err;
2508 }
2509 prev_progress = progress;
2510 }
2511 }
2512 while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2513
2514 if (verbose)
2515 print_details(c_ssl, "DONE via BIO pair: ");
Piotr Sikora29115752013-11-13 15:20:22 -08002516#ifndef OPENSSL_NO_NEXTPROTONEG
Matt Caswell0f113f32015-01-22 03:40:55 +00002517 if (verify_npn(c_ssl, s_ssl) < 0) {
2518 ret = 1;
2519 goto end;
2520 }
Ben Lauried9a268b2010-09-05 16:35:10 +00002521#endif
Matt Caswell0f113f32015-01-22 03:40:55 +00002522 if (verify_serverinfo() < 0) {
2523 fprintf(stderr, "Server info verify error\n");
2524 ret = 1;
2525 goto err;
2526 }
2527 if (verify_alpn(c_ssl, s_ssl) < 0) {
2528 ret = 1;
2529 goto err;
2530 }
Trevora398f822013-05-12 18:55:27 -07002531
Matt Caswell0f113f32015-01-22 03:40:55 +00002532 if (custom_ext_error) {
2533 fprintf(stderr, "Custom extension error\n");
2534 ret = 1;
2535 goto err;
2536 }
Trevor9cd50f72013-06-13 22:36:45 -07002537
Matt Caswell0f113f32015-01-22 03:40:55 +00002538 end:
2539 ret = 0;
Bodo Möller95d29591999-06-12 01:03:40 +00002540
2541 err:
Matt Caswell0f113f32015-01-22 03:40:55 +00002542 ERR_print_errors(bio_err);
Bodo Möller95d29591999-06-12 01:03:40 +00002543
Rich Salzca3a82c2015-03-25 11:31:18 -04002544 BIO_free(server);
2545 BIO_free(server_io);
2546 BIO_free(client);
2547 BIO_free(client_io);
2548 BIO_free(s_ssl_bio);
2549 BIO_free(c_ssl_bio);
Bodo Möller95d29591999-06-12 01:03:40 +00002550
Kurt Roeckx7946ab32015-12-06 17:56:41 +01002551 if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2552 ret = (err_in_client != 0) ? 0 : 1;
2553 else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2554 ret = (err_in_server != 0) ? 0 : 1;
2555
Matt Caswell0f113f32015-01-22 03:40:55 +00002556 return ret;
2557}
Bodo Möller95d29591999-06-12 01:03:40 +00002558
Matt Caswell0f113f32015-01-22 03:40:55 +00002559#define W_READ 1
2560#define W_WRITE 2
2561#define C_DONE 1
2562#define S_DONE 2
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002563
Ulf Möller6b691a51999-04-19 21:31:43 +00002564int doit(SSL *s_ssl, SSL *c_ssl, long count)
Matt Caswell0f113f32015-01-22 03:40:55 +00002565{
2566 char *cbuf = NULL, *sbuf = NULL;
2567 long bufsiz;
2568 long cw_num = count, cr_num = count;
2569 long sw_num = count, sr_num = count;
2570 int ret = 1;
2571 BIO *c_to_s = NULL;
2572 BIO *s_to_c = NULL;
2573 BIO *c_bio = NULL;
2574 BIO *s_bio = NULL;
2575 int c_r, c_w, s_r, s_w;
2576 int i, j;
2577 int done = 0;
2578 int c_write, s_write;
2579 int do_server = 0, do_client = 0;
2580 int max_frag = 5 * 1024;
Kurt Roeckx7946ab32015-12-06 17:56:41 +01002581 int err_in_client = 0;
2582 int err_in_server = 0;
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002583
Matt Caswell0f113f32015-01-22 03:40:55 +00002584 bufsiz = count > 40 * 1024 ? 40 * 1024 : count;
Andy Polyakov77a27a52014-06-11 20:40:51 +02002585
Rich Salzb51bce92015-08-25 13:25:58 -04002586 if ((cbuf = OPENSSL_zalloc(bufsiz)) == NULL)
Matt Caswell0f113f32015-01-22 03:40:55 +00002587 goto err;
Rich Salzb51bce92015-08-25 13:25:58 -04002588 if ((sbuf = OPENSSL_zalloc(bufsiz)) == NULL)
Matt Caswell0f113f32015-01-22 03:40:55 +00002589 goto err;
Andy Polyakov77a27a52014-06-11 20:40:51 +02002590
Matt Caswell0f113f32015-01-22 03:40:55 +00002591 c_to_s = BIO_new(BIO_s_mem());
2592 s_to_c = BIO_new(BIO_s_mem());
2593 if ((s_to_c == NULL) || (c_to_s == NULL)) {
2594 ERR_print_errors(bio_err);
2595 goto err;
2596 }
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002597
Matt Caswell0f113f32015-01-22 03:40:55 +00002598 c_bio = BIO_new(BIO_f_ssl());
2599 s_bio = BIO_new(BIO_f_ssl());
2600 if ((c_bio == NULL) || (s_bio == NULL)) {
2601 ERR_print_errors(bio_err);
2602 goto err;
2603 }
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002604
Matt Caswell0f113f32015-01-22 03:40:55 +00002605 SSL_set_connect_state(c_ssl);
2606 SSL_set_bio(c_ssl, s_to_c, c_to_s);
2607 SSL_set_max_send_fragment(c_ssl, max_frag);
2608 BIO_set_ssl(c_bio, c_ssl, BIO_NOCLOSE);
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002609
Matt Caswell0f113f32015-01-22 03:40:55 +00002610 SSL_set_accept_state(s_ssl);
2611 SSL_set_bio(s_ssl, c_to_s, s_to_c);
2612 SSL_set_max_send_fragment(s_ssl, max_frag);
2613 BIO_set_ssl(s_bio, s_ssl, BIO_NOCLOSE);
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002614
Matt Caswell0f113f32015-01-22 03:40:55 +00002615 c_r = 0;
2616 s_r = 1;
2617 c_w = 1;
2618 s_w = 0;
2619 c_write = 1, s_write = 0;
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002620
Matt Caswell0f113f32015-01-22 03:40:55 +00002621 /* We can always do writes */
2622 for (;;) {
2623 do_server = 0;
2624 do_client = 0;
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002625
Matt Caswell0f113f32015-01-22 03:40:55 +00002626 i = (int)BIO_pending(s_bio);
2627 if ((i && s_r) || s_w)
2628 do_server = 1;
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002629
Matt Caswell0f113f32015-01-22 03:40:55 +00002630 i = (int)BIO_pending(c_bio);
2631 if ((i && c_r) || c_w)
2632 do_client = 1;
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002633
Matt Caswell0f113f32015-01-22 03:40:55 +00002634 if (do_server && debug) {
2635 if (SSL_in_init(s_ssl))
2636 printf("server waiting in SSL_accept - %s\n",
2637 SSL_state_string_long(s_ssl));
Matt Caswell3a834622015-01-05 00:34:00 +00002638/*-
Matt Caswell35a1cc92015-01-17 00:06:54 +00002639 else if (s_write)
2640 printf("server:SSL_write()\n");
2641 else
2642 printf("server:SSL_read()\n"); */
Matt Caswell0f113f32015-01-22 03:40:55 +00002643 }
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002644
Matt Caswell0f113f32015-01-22 03:40:55 +00002645 if (do_client && debug) {
2646 if (SSL_in_init(c_ssl))
2647 printf("client waiting in SSL_connect - %s\n",
2648 SSL_state_string_long(c_ssl));
Matt Caswell3a834622015-01-05 00:34:00 +00002649/*-
Matt Caswell35a1cc92015-01-17 00:06:54 +00002650 else if (c_write)
2651 printf("client:SSL_write()\n");
2652 else
2653 printf("client:SSL_read()\n"); */
Matt Caswell0f113f32015-01-22 03:40:55 +00002654 }
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002655
Matt Caswell0f113f32015-01-22 03:40:55 +00002656 if (!do_client && !do_server) {
2657 fprintf(stdout, "ERROR IN STARTUP\n");
2658 ERR_print_errors(bio_err);
Matt Caswellae632972015-02-05 10:19:55 +00002659 goto err;
Matt Caswell0f113f32015-01-22 03:40:55 +00002660 }
2661 if (do_client && !(done & C_DONE)) {
2662 if (c_write) {
2663 j = (cw_num > bufsiz) ? (int)bufsiz : (int)cw_num;
2664 i = BIO_write(c_bio, cbuf, j);
2665 if (i < 0) {
2666 c_r = 0;
2667 c_w = 0;
2668 if (BIO_should_retry(c_bio)) {
2669 if (BIO_should_read(c_bio))
2670 c_r = 1;
2671 if (BIO_should_write(c_bio))
2672 c_w = 1;
2673 } else {
2674 fprintf(stderr, "ERROR in CLIENT\n");
Kurt Roeckx7946ab32015-12-06 17:56:41 +01002675 err_in_client = 1;
Matt Caswell0f113f32015-01-22 03:40:55 +00002676 ERR_print_errors(bio_err);
2677 goto err;
2678 }
2679 } else if (i == 0) {
2680 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2681 goto err;
2682 } else {
2683 if (debug)
2684 printf("client wrote %d\n", i);
2685 /* ok */
2686 s_r = 1;
2687 c_write = 0;
2688 cw_num -= i;
2689 if (max_frag > 1029)
2690 SSL_set_max_send_fragment(c_ssl, max_frag -= 5);
2691 }
2692 } else {
2693 i = BIO_read(c_bio, cbuf, bufsiz);
2694 if (i < 0) {
2695 c_r = 0;
2696 c_w = 0;
2697 if (BIO_should_retry(c_bio)) {
2698 if (BIO_should_read(c_bio))
2699 c_r = 1;
2700 if (BIO_should_write(c_bio))
2701 c_w = 1;
2702 } else {
2703 fprintf(stderr, "ERROR in CLIENT\n");
Kurt Roeckx7946ab32015-12-06 17:56:41 +01002704 err_in_client = 1;
Matt Caswell0f113f32015-01-22 03:40:55 +00002705 ERR_print_errors(bio_err);
2706 goto err;
2707 }
2708 } else if (i == 0) {
2709 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2710 goto err;
2711 } else {
2712 if (debug)
2713 printf("client read %d\n", i);
2714 cr_num -= i;
2715 if (sw_num > 0) {
2716 s_write = 1;
2717 s_w = 1;
2718 }
2719 if (cr_num <= 0) {
2720 s_write = 1;
2721 s_w = 1;
2722 done = S_DONE | C_DONE;
2723 }
2724 }
2725 }
2726 }
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002727
Matt Caswell0f113f32015-01-22 03:40:55 +00002728 if (do_server && !(done & S_DONE)) {
2729 if (!s_write) {
2730 i = BIO_read(s_bio, sbuf, bufsiz);
2731 if (i < 0) {
2732 s_r = 0;
2733 s_w = 0;
2734 if (BIO_should_retry(s_bio)) {
2735 if (BIO_should_read(s_bio))
2736 s_r = 1;
2737 if (BIO_should_write(s_bio))
2738 s_w = 1;
2739 } else {
2740 fprintf(stderr, "ERROR in SERVER\n");
Kurt Roeckx7946ab32015-12-06 17:56:41 +01002741 err_in_server = 1;
Matt Caswell0f113f32015-01-22 03:40:55 +00002742 ERR_print_errors(bio_err);
2743 goto err;
2744 }
2745 } else if (i == 0) {
2746 ERR_print_errors(bio_err);
2747 fprintf(stderr,
2748 "SSL SERVER STARTUP FAILED in SSL_read\n");
2749 goto err;
2750 } else {
2751 if (debug)
2752 printf("server read %d\n", i);
2753 sr_num -= i;
2754 if (cw_num > 0) {
2755 c_write = 1;
2756 c_w = 1;
2757 }
2758 if (sr_num <= 0) {
2759 s_write = 1;
2760 s_w = 1;
2761 c_write = 0;
2762 }
2763 }
2764 } else {
2765 j = (sw_num > bufsiz) ? (int)bufsiz : (int)sw_num;
2766 i = BIO_write(s_bio, sbuf, j);
2767 if (i < 0) {
2768 s_r = 0;
2769 s_w = 0;
2770 if (BIO_should_retry(s_bio)) {
2771 if (BIO_should_read(s_bio))
2772 s_r = 1;
2773 if (BIO_should_write(s_bio))
2774 s_w = 1;
2775 } else {
2776 fprintf(stderr, "ERROR in SERVER\n");
Kurt Roeckx7946ab32015-12-06 17:56:41 +01002777 err_in_server = 1;
Matt Caswell0f113f32015-01-22 03:40:55 +00002778 ERR_print_errors(bio_err);
2779 goto err;
2780 }
2781 } else if (i == 0) {
2782 ERR_print_errors(bio_err);
2783 fprintf(stderr,
2784 "SSL SERVER STARTUP FAILED in SSL_write\n");
2785 goto err;
2786 } else {
2787 if (debug)
2788 printf("server wrote %d\n", i);
2789 sw_num -= i;
2790 s_write = 0;
2791 c_r = 1;
2792 if (sw_num <= 0)
2793 done |= S_DONE;
2794 if (max_frag > 1029)
2795 SSL_set_max_send_fragment(s_ssl, max_frag -= 5);
2796 }
2797 }
2798 }
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002799
Matt Caswell0f113f32015-01-22 03:40:55 +00002800 if ((done & S_DONE) && (done & C_DONE))
2801 break;
2802 }
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002803
Matt Caswell0f113f32015-01-22 03:40:55 +00002804 if (verbose)
2805 print_details(c_ssl, "DONE: ");
Piotr Sikora29115752013-11-13 15:20:22 -08002806#ifndef OPENSSL_NO_NEXTPROTONEG
Matt Caswell0f113f32015-01-22 03:40:55 +00002807 if (verify_npn(c_ssl, s_ssl) < 0) {
2808 ret = 1;
2809 goto err;
2810 }
Ben Lauried9a268b2010-09-05 16:35:10 +00002811#endif
Matt Caswell0f113f32015-01-22 03:40:55 +00002812 if (verify_serverinfo() < 0) {
2813 fprintf(stderr, "Server info verify error\n");
2814 ret = 1;
2815 goto err;
2816 }
2817 if (custom_ext_error) {
2818 fprintf(stderr, "Custom extension error\n");
2819 ret = 1;
2820 goto err;
2821 }
2822 ret = 0;
2823 err:
2824 /*
2825 * We have to set the BIO's to NULL otherwise they will be
2826 * OPENSSL_free()ed twice. Once when th s_ssl is SSL_free()ed and again
2827 * when c_ssl is SSL_free()ed. This is a hack required because s_ssl and
2828 * c_ssl are sharing the same BIO structure and SSL_set_bio() and
2829 * SSL_free() automatically BIO_free non NULL entries. You should not
2830 * normally do this or be required to do this
2831 */
2832 if (s_ssl != NULL) {
2833 s_ssl->rbio = NULL;
2834 s_ssl->wbio = NULL;
2835 }
2836 if (c_ssl != NULL) {
2837 c_ssl->rbio = NULL;
2838 c_ssl->wbio = NULL;
2839 }
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002840
Rich Salzca3a82c2015-03-25 11:31:18 -04002841 BIO_free(c_to_s);
2842 BIO_free(s_to_c);
2843 BIO_free_all(c_bio);
2844 BIO_free_all(s_bio);
Rich Salzb548a1f2015-05-01 10:02:07 -04002845 OPENSSL_free(cbuf);
2846 OPENSSL_free(sbuf);
Andy Polyakov77a27a52014-06-11 20:40:51 +02002847
Kurt Roeckx7946ab32015-12-06 17:56:41 +01002848 if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2849 ret = (err_in_client != 0) ? 0 : 1;
2850 else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2851 ret = (err_in_server != 0) ? 0 : 1;
2852
Matt Caswell0f113f32015-01-22 03:40:55 +00002853 return (ret);
2854}
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002855
Richard Levittea7201e92005-01-17 17:06:58 +00002856static int get_proxy_auth_ex_data_idx(void)
Matt Caswell0f113f32015-01-22 03:40:55 +00002857{
2858 static volatile int idx = -1;
2859 if (idx < 0) {
2860 CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
2861 if (idx < 0) {
2862 idx = X509_STORE_CTX_get_ex_new_index(0,
2863 "SSLtest for verify callback",
2864 NULL, NULL, NULL);
2865 }
2866 CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
2867 }
2868 return idx;
2869}
Richard Levittea7201e92005-01-17 17:06:58 +00002870
Rich Salz6d23cf92015-01-12 17:29:26 -05002871static int verify_callback(int ok, X509_STORE_CTX *ctx)
Matt Caswell0f113f32015-01-22 03:40:55 +00002872{
2873 char *s, buf[256];
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002874
Matt Caswell0f113f32015-01-22 03:40:55 +00002875 s = X509_NAME_oneline(X509_get_subject_name(ctx->current_cert), buf,
2876 sizeof buf);
2877 if (s != NULL) {
2878 if (ok)
Rich Salz3dca57f2015-04-21 15:52:51 -04002879 printf("depth=%d %s\n", ctx->error_depth, buf);
Matt Caswell0f113f32015-01-22 03:40:55 +00002880 else {
2881 fprintf(stderr, "depth=%d error=%d %s\n",
2882 ctx->error_depth, ctx->error, buf);
2883 }
2884 }
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002885
Matt Caswell0f113f32015-01-22 03:40:55 +00002886 if (ok == 0) {
Matt Caswell0f113f32015-01-22 03:40:55 +00002887 switch (ctx->error) {
Rich Salz3dca57f2015-04-21 15:52:51 -04002888 default:
2889 fprintf(stderr, "Error string: %s\n",
2890 X509_verify_cert_error_string(ctx->error));
2891 break;
Matt Caswell0f113f32015-01-22 03:40:55 +00002892 case X509_V_ERR_CERT_NOT_YET_VALID:
2893 case X509_V_ERR_CERT_HAS_EXPIRED:
2894 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
Matt Caswell0f113f32015-01-22 03:40:55 +00002895 ok = 1;
2896 }
2897 }
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002898
Matt Caswell0f113f32015-01-22 03:40:55 +00002899 if (ok == 1) {
2900 X509 *xs = ctx->current_cert;
Dr. Stephen Hensona8d8e062015-09-02 22:01:18 +01002901 if (X509_get_extension_flags(xs) & EXFLAG_PROXY) {
Matt Caswell0f113f32015-01-22 03:40:55 +00002902 unsigned int *letters = X509_STORE_CTX_get_ex_data(ctx,
2903 get_proxy_auth_ex_data_idx
2904 ());
Richard Levittea7201e92005-01-17 17:06:58 +00002905
Matt Caswell0f113f32015-01-22 03:40:55 +00002906 if (letters) {
2907 int found_any = 0;
2908 int i;
2909 PROXY_CERT_INFO_EXTENSION *pci =
2910 X509_get_ext_d2i(xs, NID_proxyCertInfo,
2911 NULL, NULL);
Richard Levittea7201e92005-01-17 17:06:58 +00002912
Matt Caswell0f113f32015-01-22 03:40:55 +00002913 switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage)) {
2914 case NID_Independent:
2915 /*
2916 * Completely meaningless in this program, as there's no
2917 * way to grant explicit rights to a specific PrC.
2918 * Basically, using id-ppl-Independent is the perfect way
2919 * to grant no rights at all.
2920 */
2921 fprintf(stderr, " Independent proxy certificate");
2922 for (i = 0; i < 26; i++)
2923 letters[i] = 0;
2924 break;
2925 case NID_id_ppl_inheritAll:
2926 /*
2927 * This is basically a NOP, we simply let the current
2928 * rights stand as they are.
2929 */
2930 fprintf(stderr, " Proxy certificate inherits all");
2931 break;
2932 default:
2933 s = (char *)
2934 pci->proxyPolicy->policy->data;
2935 i = pci->proxyPolicy->policy->length;
Richard Levittea7201e92005-01-17 17:06:58 +00002936
Matt Caswell0f113f32015-01-22 03:40:55 +00002937 /*
2938 * The algorithm works as follows: it is assumed that
2939 * previous iterations or the initial granted rights has
2940 * already set some elements of `letters'. What we need
2941 * to do is to clear those that weren't granted by the
2942 * current PrC as well. The easiest way to do this is to
2943 * add 1 to all the elements whose letters are given with
2944 * the current policy. That way, all elements that are
2945 * set by the current policy and were already set by
2946 * earlier policies and through the original grant of
2947 * rights will get the value 2 or higher. The last thing
2948 * to do is to sweep through `letters' and keep the
2949 * elements having the value 2 as set, and clear all the
2950 * others.
2951 */
Richard Levittea7201e92005-01-17 17:06:58 +00002952
Rich Salz3dca57f2015-04-21 15:52:51 -04002953 printf(" Certificate proxy rights = %*.*s", i,
Matt Caswell0f113f32015-01-22 03:40:55 +00002954 i, s);
2955 while (i-- > 0) {
2956 int c = *s++;
2957 if (isascii(c) && isalpha(c)) {
2958 if (islower(c))
2959 c = toupper(c);
2960 letters[c - 'A']++;
2961 }
2962 }
2963 for (i = 0; i < 26; i++)
2964 if (letters[i] < 2)
2965 letters[i] = 0;
2966 else
2967 letters[i] = 1;
2968 }
Richard Levittea7201e92005-01-17 17:06:58 +00002969
Matt Caswell0f113f32015-01-22 03:40:55 +00002970 found_any = 0;
Rich Salz3dca57f2015-04-21 15:52:51 -04002971 printf(", resulting proxy rights = ");
Matt Caswell0f113f32015-01-22 03:40:55 +00002972 for (i = 0; i < 26; i++)
2973 if (letters[i]) {
Rich Salz3dca57f2015-04-21 15:52:51 -04002974 printf("%c", i + 'A');
Matt Caswell0f113f32015-01-22 03:40:55 +00002975 found_any = 1;
2976 }
2977 if (!found_any)
Rich Salz3dca57f2015-04-21 15:52:51 -04002978 printf("none");
2979 printf("\n");
Richard Levittea7201e92005-01-17 17:06:58 +00002980
Matt Caswell0f113f32015-01-22 03:40:55 +00002981 PROXY_CERT_INFO_EXTENSION_free(pci);
2982 }
2983 }
2984 }
Richard Levittea7201e92005-01-17 17:06:58 +00002985
Matt Caswell0f113f32015-01-22 03:40:55 +00002986 return (ok);
2987}
Ralf S. Engelschalld02b48c1998-12-21 10:52:47 +00002988
Richard Levittea7201e92005-01-17 17:06:58 +00002989static void process_proxy_debug(int indent, const char *format, ...)
Matt Caswell0f113f32015-01-22 03:40:55 +00002990{
2991 /* That's 80 > */
2992 static const char indentation[] =
2993 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
2994 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
2995 char my_format[256];
2996 va_list args;
Richard Levittea7201e92005-01-17 17:06:58 +00002997
Matt Caswell0f113f32015-01-22 03:40:55 +00002998 BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
2999 indent, indent, indentation, format);
Richard Levittea7201e92005-01-17 17:06:58 +00003000
Matt Caswell0f113f32015-01-22 03:40:55 +00003001 va_start(args, format);
3002 vfprintf(stderr, my_format, args);
3003 va_end(args);
3004}
3005
Tim Hudson1d97c842014-12-28 12:48:40 +10003006/*-
3007 * Priority levels:
Matt Caswell0f113f32015-01-22 03:40:55 +00003008 * 0 [!]var, ()
3009 * 1 & ^
3010 * 2 |
Tim Hudson1d97c842014-12-28 12:48:40 +10003011 */
Richard Levittea7201e92005-01-17 17:06:58 +00003012static int process_proxy_cond_adders(unsigned int letters[26],
Matt Caswell0f113f32015-01-22 03:40:55 +00003013 const char *cond, const char **cond_end,
3014 int *pos, int indent);
3015static int process_proxy_cond_val(unsigned int letters[26], const char *cond,
3016 const char **cond_end, int *pos, int indent)
3017{
3018 int c;
3019 int ok = 1;
3020 int negate = 0;
Richard Levittea7201e92005-01-17 17:06:58 +00003021
Matt Caswell0f113f32015-01-22 03:40:55 +00003022 while (isspace((int)*cond)) {
3023 cond++;
3024 (*pos)++;
3025 }
3026 c = *cond;
Richard Levittea7201e92005-01-17 17:06:58 +00003027
Matt Caswell0f113f32015-01-22 03:40:55 +00003028 if (debug)
3029 process_proxy_debug(indent,
3030 "Start process_proxy_cond_val at position %d: %s\n",
3031 *pos, cond);
Richard Levittea7201e92005-01-17 17:06:58 +00003032
Matt Caswell0f113f32015-01-22 03:40:55 +00003033 while (c == '!') {
3034 negate = !negate;
3035 cond++;
3036 (*pos)++;
3037 while (isspace((int)*cond)) {
3038 cond++;
3039 (*pos)++;
3040 }
3041 c = *cond;
3042 }
Richard Levittea7201e92005-01-17 17:06:58 +00003043
Matt Caswell0f113f32015-01-22 03:40:55 +00003044 if (c == '(') {
3045 cond++;
3046 (*pos)++;
3047 ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
3048 indent + 1);
3049 cond = *cond_end;
3050 if (ok < 0)
3051 goto end;
3052 while (isspace((int)*cond)) {
3053 cond++;
3054 (*pos)++;
3055 }
3056 c = *cond;
3057 if (c != ')') {
3058 fprintf(stderr,
3059 "Weird condition character in position %d: "
3060 "%c\n", *pos, c);
3061 ok = -1;
3062 goto end;
3063 }
3064 cond++;
3065 (*pos)++;
3066 } else if (isascii(c) && isalpha(c)) {
3067 if (islower(c))
3068 c = toupper(c);
3069 ok = letters[c - 'A'];
3070 cond++;
3071 (*pos)++;
3072 } else {
3073 fprintf(stderr,
3074 "Weird condition character in position %d: " "%c\n", *pos, c);
3075 ok = -1;
3076 goto end;
3077 }
Richard Levittea7201e92005-01-17 17:06:58 +00003078 end:
Matt Caswell0f113f32015-01-22 03:40:55 +00003079 *cond_end = cond;
3080 if (ok >= 0 && negate)
3081 ok = !ok;
Richard Levittea7201e92005-01-17 17:06:58 +00003082
Matt Caswell0f113f32015-01-22 03:40:55 +00003083 if (debug)
3084 process_proxy_debug(indent,
3085 "End process_proxy_cond_val at position %d: %s, returning %d\n",
3086 *pos, cond, ok);
Richard Levittea7201e92005-01-17 17:06:58 +00003087
Matt Caswell0f113f32015-01-22 03:40:55 +00003088 return ok;
3089}
3090
Richard Levittea7201e92005-01-17 17:06:58 +00003091static int process_proxy_cond_multipliers(unsigned int letters[26],
Matt Caswell0f113f32015-01-22 03:40:55 +00003092 const char *cond,
3093 const char **cond_end, int *pos,
3094 int indent)
3095{
3096 int ok;
3097 char c;
Richard Levittea7201e92005-01-17 17:06:58 +00003098
Matt Caswell0f113f32015-01-22 03:40:55 +00003099 if (debug)
3100 process_proxy_debug(indent,
3101 "Start process_proxy_cond_multipliers at position %d: %s\n",
3102 *pos, cond);
Richard Levittea7201e92005-01-17 17:06:58 +00003103
Matt Caswell0f113f32015-01-22 03:40:55 +00003104 ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
3105 cond = *cond_end;
3106 if (ok < 0)
3107 goto end;
Richard Levittea7201e92005-01-17 17:06:58 +00003108
Matt Caswell0f113f32015-01-22 03:40:55 +00003109 while (ok >= 0) {
3110 while (isspace((int)*cond)) {
3111 cond++;
3112 (*pos)++;
3113 }
3114 c = *cond;
Richard Levittea7201e92005-01-17 17:06:58 +00003115
Matt Caswell0f113f32015-01-22 03:40:55 +00003116 switch (c) {
3117 case '&':
3118 case '^':
3119 {
3120 int save_ok = ok;
Richard Levittea7201e92005-01-17 17:06:58 +00003121
Matt Caswell0f113f32015-01-22 03:40:55 +00003122 cond++;
3123 (*pos)++;
3124 ok = process_proxy_cond_val(letters,
3125 cond, cond_end, pos, indent + 1);
3126 cond = *cond_end;
3127 if (ok < 0)
3128 break;
Richard Levittea7201e92005-01-17 17:06:58 +00003129
Matt Caswell0f113f32015-01-22 03:40:55 +00003130 switch (c) {
3131 case '&':
3132 ok &= save_ok;
3133 break;
3134 case '^':
3135 ok ^= save_ok;
3136 break;
3137 default:
3138 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
3139 " STOPPING\n");
3140 EXIT(1);
3141 }
3142 }
3143 break;
3144 default:
3145 goto end;
3146 }
3147 }
Richard Levittea7201e92005-01-17 17:06:58 +00003148 end:
Matt Caswell0f113f32015-01-22 03:40:55 +00003149 if (debug)
3150 process_proxy_debug(indent,
3151 "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
3152 *pos, cond, ok);
Richard Levittea7201e92005-01-17 17:06:58 +00003153
Matt Caswell0f113f32015-01-22 03:40:55 +00003154 *cond_end = cond;
3155 return ok;
3156}
3157
Richard Levittea7201e92005-01-17 17:06:58 +00003158static int process_proxy_cond_adders(unsigned int letters[26],
Matt Caswell0f113f32015-01-22 03:40:55 +00003159 const char *cond, const char **cond_end,
3160 int *pos, int indent)
3161{
3162 int ok;
3163 char c;
Richard Levittea7201e92005-01-17 17:06:58 +00003164
Matt Caswell0f113f32015-01-22 03:40:55 +00003165 if (debug)
3166 process_proxy_debug(indent,
3167 "Start process_proxy_cond_adders at position %d: %s\n",
3168 *pos, cond);
Richard Levittea7201e92005-01-17 17:06:58 +00003169
Matt Caswell0f113f32015-01-22 03:40:55 +00003170 ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
3171 indent + 1);
3172 cond = *cond_end;
3173 if (ok < 0)
3174 goto end;
Richard Levittea7201e92005-01-17 17:06:58 +00003175
Matt Caswell0f113f32015-01-22 03:40:55 +00003176 while (ok >= 0) {
3177 while (isspace((int)*cond)) {
3178 cond++;
3179 (*pos)++;
3180 }
3181 c = *cond;
Richard Levittea7201e92005-01-17 17:06:58 +00003182
Matt Caswell0f113f32015-01-22 03:40:55 +00003183 switch (c) {
3184 case '|':
3185 {
3186 int save_ok = ok;
Richard Levittea7201e92005-01-17 17:06:58 +00003187
Matt Caswell0f113f32015-01-22 03:40:55 +00003188 cond++;
3189 (*pos)++;
3190 ok = process_proxy_cond_multipliers(letters,
3191 cond, cond_end, pos,
3192 indent + 1);
3193 cond = *cond_end;
3194 if (ok < 0)
3195 break;
Richard Levittea7201e92005-01-17 17:06:58 +00003196
Matt Caswell0f113f32015-01-22 03:40:55 +00003197 switch (c) {
3198 case '|':
3199 ok |= save_ok;
3200 break;
3201 default:
3202 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
3203 " STOPPING\n");
3204 EXIT(1);
3205 }
3206 }
3207 break;
3208 default:
3209 goto end;
3210 }
3211 }
Richard Levittea7201e92005-01-17 17:06:58 +00003212 end:
Matt Caswell0f113f32015-01-22 03:40:55 +00003213 if (debug)
3214 process_proxy_debug(indent,
3215 "End process_proxy_cond_adders at position %d: %s, returning %d\n",
3216 *pos, cond, ok);
Richard Levittea7201e92005-01-17 17:06:58 +00003217
Matt Caswell0f113f32015-01-22 03:40:55 +00003218 *cond_end = cond;
3219 return ok;
3220}
Richard Levittea7201e92005-01-17 17:06:58 +00003221
3222static int process_proxy_cond(unsigned int letters[26],
Matt Caswell0f113f32015-01-22 03:40:55 +00003223 const char *cond, const char **cond_end)
3224{
3225 int pos = 1;
3226 return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
3227}
Richard Levittea7201e92005-01-17 17:06:58 +00003228
Rich Salz6d23cf92015-01-12 17:29:26 -05003229static int app_verify_callback(X509_STORE_CTX *ctx, void *arg)
Matt Caswell0f113f32015-01-22 03:40:55 +00003230{
3231 int ok = 1;
3232 struct app_verify_arg *cb_arg = arg;
3233 unsigned int letters[26]; /* only used with proxy_auth */
Bodo Möller023ec152002-02-28 10:52:56 +00003234
Matt Caswell0f113f32015-01-22 03:40:55 +00003235 if (cb_arg->app_verify) {
3236 char *s = NULL, buf[256];
Richard Levittea7201e92005-01-17 17:06:58 +00003237
Rich Salz3dca57f2015-04-21 15:52:51 -04003238 printf("In app_verify_callback, allowing cert. ");
3239 printf("Arg is: %s\n", cb_arg->string);
3240 printf("Finished printing do we have a context? 0x%p a cert? 0x%p\n",
Matt Caswell0f113f32015-01-22 03:40:55 +00003241 (void *)ctx, (void *)ctx->cert);
3242 if (ctx->cert)
3243 s = X509_NAME_oneline(X509_get_subject_name(ctx->cert), buf, 256);
3244 if (s != NULL) {
Rich Salz3dca57f2015-04-21 15:52:51 -04003245 printf("cert depth=%d %s\n", ctx->error_depth, buf);
Matt Caswell0f113f32015-01-22 03:40:55 +00003246 }
3247 return (1);
3248 }
3249 if (cb_arg->proxy_auth) {
3250 int found_any = 0, i;
3251 char *sp;
Richard Levittea7201e92005-01-17 17:06:58 +00003252
Matt Caswell0f113f32015-01-22 03:40:55 +00003253 for (i = 0; i < 26; i++)
3254 letters[i] = 0;
3255 for (sp = cb_arg->proxy_auth; *sp; sp++) {
3256 int c = *sp;
3257 if (isascii(c) && isalpha(c)) {
3258 if (islower(c))
3259 c = toupper(c);
3260 letters[c - 'A'] = 1;
3261 }
3262 }
Richard Levittea7201e92005-01-17 17:06:58 +00003263
Rich Salz3dca57f2015-04-21 15:52:51 -04003264 printf(" Initial proxy rights = ");
Matt Caswell0f113f32015-01-22 03:40:55 +00003265 for (i = 0; i < 26; i++)
3266 if (letters[i]) {
Rich Salz3dca57f2015-04-21 15:52:51 -04003267 printf("%c", i + 'A');
Matt Caswell0f113f32015-01-22 03:40:55 +00003268 found_any = 1;
3269 }
3270 if (!found_any)
Rich Salz3dca57f2015-04-21 15:52:51 -04003271 printf("none");
3272 printf("\n");
Richard Levittea7201e92005-01-17 17:06:58 +00003273
Matt Caswell0f113f32015-01-22 03:40:55 +00003274 X509_STORE_CTX_set_ex_data(ctx,
3275 get_proxy_auth_ex_data_idx(), letters);
3276 }
3277 if (cb_arg->allow_proxy_certs) {
3278 X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
3279 }
Matt Caswell0f113f32015-01-22 03:40:55 +00003280 ok = X509_verify_cert(ctx);
Richard Levittea7201e92005-01-17 17:06:58 +00003281
Matt Caswell0f113f32015-01-22 03:40:55 +00003282 if (cb_arg->proxy_auth) {
3283 if (ok > 0) {
3284 const char *cond_end = NULL;
Richard Levittea7201e92005-01-17 17:06:58 +00003285
Matt Caswell0f113f32015-01-22 03:40:55 +00003286 ok = process_proxy_cond(letters, cb_arg->proxy_cond, &cond_end);
Richard Levittea7201e92005-01-17 17:06:58 +00003287
Matt Caswell0f113f32015-01-22 03:40:55 +00003288 if (ok < 0)
3289 EXIT(3);
3290 if (*cond_end) {
3291 fprintf(stderr,
3292 "Stopped processing condition before it's end.\n");
3293 ok = 0;
3294 }
3295 if (!ok)
3296 fprintf(stderr,
Rich Salz3dca57f2015-04-21 15:52:51 -04003297 "Proxy rights check with condition '%s' invalid\n",
Matt Caswell0f113f32015-01-22 03:40:55 +00003298 cb_arg->proxy_cond);
3299 else
Rich Salz3dca57f2015-04-21 15:52:51 -04003300 printf("Proxy rights check with condition '%s' ok\n",
Matt Caswell0f113f32015-01-22 03:40:55 +00003301 cb_arg->proxy_cond);
3302 }
3303 }
3304 return (ok);
3305}
Bodo Möller023ec152002-02-28 10:52:56 +00003306
Richard Levittebc36ee62001-02-20 08:13:47 +00003307#ifndef OPENSSL_NO_DH
Tim Hudson1d97c842014-12-28 12:48:40 +10003308/*-
3309 * These DH parameters have been generated as follows:
Bodo Möllere4589582000-03-10 13:23:20 +00003310 * $ openssl dhparam -C -noout 512
3311 * $ openssl dhparam -C -noout 1024
3312 * $ openssl dhparam -C -noout -dsaparam 1024
3313 * (The third function has been renamed to avoid name conflicts.)
3314 */
Richard Levittef3f316f2000-10-22 12:45:33 +00003315static DH *get_dh512()
Matt Caswell0f113f32015-01-22 03:40:55 +00003316{
3317 static unsigned char dh512_p[] = {
3318 0xCB, 0xC8, 0xE1, 0x86, 0xD0, 0x1F, 0x94, 0x17, 0xA6, 0x99, 0xF0,
3319 0xC6,
3320 0x1F, 0x0D, 0xAC, 0xB6, 0x25, 0x3E, 0x06, 0x39, 0xCA, 0x72, 0x04,
3321 0xB0,
3322 0x6E, 0xDA, 0xC0, 0x61, 0xE6, 0x7A, 0x77, 0x25, 0xE8, 0x3B, 0xB9,
3323 0x5F,
3324 0x9A, 0xB6, 0xB5, 0xFE, 0x99, 0x0B, 0xA1, 0x93, 0x4E, 0x35, 0x33,
3325 0xB8,
3326 0xE1, 0xF1, 0x13, 0x4F, 0x59, 0x1A, 0xD2, 0x57, 0xC0, 0x26, 0x21,
3327 0x33,
3328 0x02, 0xC5, 0xAE, 0x23,
3329 };
3330 static unsigned char dh512_g[] = {
3331 0x02,
3332 };
3333 DH *dh;
Bodo Möller53002dc2000-02-04 11:21:18 +00003334
Matt Caswell0f113f32015-01-22 03:40:55 +00003335 if ((dh = DH_new()) == NULL)
3336 return (NULL);
3337 dh->p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
3338 dh->g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
3339 if ((dh->p == NULL) || (dh->g == NULL)) {
3340 DH_free(dh);
3341 return (NULL);
3342 }
3343 return (dh);
3344}
Bodo Möller53002dc2000-02-04 11:21:18 +00003345
Richard Levittef3f316f2000-10-22 12:45:33 +00003346static DH *get_dh1024()
Matt Caswell0f113f32015-01-22 03:40:55 +00003347{
3348 static unsigned char dh1024_p[] = {
3349 0xF8, 0x81, 0x89, 0x7D, 0x14, 0x24, 0xC5, 0xD1, 0xE6, 0xF7, 0xBF,
3350 0x3A,
3351 0xE4, 0x90, 0xF4, 0xFC, 0x73, 0xFB, 0x34, 0xB5, 0xFA, 0x4C, 0x56,
3352 0xA2,
3353 0xEA, 0xA7, 0xE9, 0xC0, 0xC0, 0xCE, 0x89, 0xE1, 0xFA, 0x63, 0x3F,
3354 0xB0,
3355 0x6B, 0x32, 0x66, 0xF1, 0xD1, 0x7B, 0xB0, 0x00, 0x8F, 0xCA, 0x87,
3356 0xC2,
3357 0xAE, 0x98, 0x89, 0x26, 0x17, 0xC2, 0x05, 0xD2, 0xEC, 0x08, 0xD0,
3358 0x8C,
3359 0xFF, 0x17, 0x52, 0x8C, 0xC5, 0x07, 0x93, 0x03, 0xB1, 0xF6, 0x2F,
3360 0xB8,
3361 0x1C, 0x52, 0x47, 0x27, 0x1B, 0xDB, 0xD1, 0x8D, 0x9D, 0x69, 0x1D,
3362 0x52,
3363 0x4B, 0x32, 0x81, 0xAA, 0x7F, 0x00, 0xC8, 0xDC, 0xE6, 0xD9, 0xCC,
3364 0xC1,
3365 0x11, 0x2D, 0x37, 0x34, 0x6C, 0xEA, 0x02, 0x97, 0x4B, 0x0E, 0xBB,
3366 0xB1,
3367 0x71, 0x33, 0x09, 0x15, 0xFD, 0xDD, 0x23, 0x87, 0x07, 0x5E, 0x89,
3368 0xAB,
3369 0x6B, 0x7C, 0x5F, 0xEC, 0xA6, 0x24, 0xDC, 0x53,
3370 };
3371 static unsigned char dh1024_g[] = {
3372 0x02,
3373 };
3374 DH *dh;
Bodo Möllere4589582000-03-10 13:23:20 +00003375
Matt Caswell0f113f32015-01-22 03:40:55 +00003376 if ((dh = DH_new()) == NULL)
3377 return (NULL);
3378 dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
3379 dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
3380 if ((dh->p == NULL) || (dh->g == NULL)) {
3381 DH_free(dh);
3382 return (NULL);
3383 }
3384 return (dh);
3385}
Bodo Möllere4589582000-03-10 13:23:20 +00003386
Richard Levittef3f316f2000-10-22 12:45:33 +00003387static DH *get_dh1024dsa()
Matt Caswell0f113f32015-01-22 03:40:55 +00003388{
3389 static unsigned char dh1024_p[] = {
3390 0xC8, 0x00, 0xF7, 0x08, 0x07, 0x89, 0x4D, 0x90, 0x53, 0xF3, 0xD5,
3391 0x00,
3392 0x21, 0x1B, 0xF7, 0x31, 0xA6, 0xA2, 0xDA, 0x23, 0x9A, 0xC7, 0x87,
3393 0x19,
3394 0x3B, 0x47, 0xB6, 0x8C, 0x04, 0x6F, 0xFF, 0xC6, 0x9B, 0xB8, 0x65,
3395 0xD2,
3396 0xC2, 0x5F, 0x31, 0x83, 0x4A, 0xA7, 0x5F, 0x2F, 0x88, 0x38, 0xB6,
3397 0x55,
3398 0xCF, 0xD9, 0x87, 0x6D, 0x6F, 0x9F, 0xDA, 0xAC, 0xA6, 0x48, 0xAF,
3399 0xFC,
3400 0x33, 0x84, 0x37, 0x5B, 0x82, 0x4A, 0x31, 0x5D, 0xE7, 0xBD, 0x52,
3401 0x97,
3402 0xA1, 0x77, 0xBF, 0x10, 0x9E, 0x37, 0xEA, 0x64, 0xFA, 0xCA, 0x28,
3403 0x8D,
3404 0x9D, 0x3B, 0xD2, 0x6E, 0x09, 0x5C, 0x68, 0xC7, 0x45, 0x90, 0xFD,
3405 0xBB,
3406 0x70, 0xC9, 0x3A, 0xBB, 0xDF, 0xD4, 0x21, 0x0F, 0xC4, 0x6A, 0x3C,
3407 0xF6,
3408 0x61, 0xCF, 0x3F, 0xD6, 0x13, 0xF1, 0x5F, 0xBC, 0xCF, 0xBC, 0x26,
3409 0x9E,
3410 0xBC, 0x0B, 0xBD, 0xAB, 0x5D, 0xC9, 0x54, 0x39,
3411 };
3412 static unsigned char dh1024_g[] = {
3413 0x3B, 0x40, 0x86, 0xE7, 0xF3, 0x6C, 0xDE, 0x67, 0x1C, 0xCC, 0x80,
3414 0x05,
3415 0x5A, 0xDF, 0xFE, 0xBD, 0x20, 0x27, 0x74, 0x6C, 0x24, 0xC9, 0x03,
3416 0xF3,
3417 0xE1, 0x8D, 0xC3, 0x7D, 0x98, 0x27, 0x40, 0x08, 0xB8, 0x8C, 0x6A,
3418 0xE9,
3419 0xBB, 0x1A, 0x3A, 0xD6, 0x86, 0x83, 0x5E, 0x72, 0x41, 0xCE, 0x85,
3420 0x3C,
3421 0xD2, 0xB3, 0xFC, 0x13, 0xCE, 0x37, 0x81, 0x9E, 0x4C, 0x1C, 0x7B,
3422 0x65,
3423 0xD3, 0xE6, 0xA6, 0x00, 0xF5, 0x5A, 0x95, 0x43, 0x5E, 0x81, 0xCF,
3424 0x60,
3425 0xA2, 0x23, 0xFC, 0x36, 0xA7, 0x5D, 0x7A, 0x4C, 0x06, 0x91, 0x6E,
3426 0xF6,
3427 0x57, 0xEE, 0x36, 0xCB, 0x06, 0xEA, 0xF5, 0x3D, 0x95, 0x49, 0xCB,
3428 0xA7,
3429 0xDD, 0x81, 0xDF, 0x80, 0x09, 0x4A, 0x97, 0x4D, 0xA8, 0x22, 0x72,
3430 0xA1,
3431 0x7F, 0xC4, 0x70, 0x56, 0x70, 0xE8, 0x20, 0x10, 0x18, 0x8F, 0x2E,
3432 0x60,
3433 0x07, 0xE7, 0x68, 0x1A, 0x82, 0x5D, 0x32, 0xA2,
3434 };
3435 DH *dh;
Bodo Möllere4589582000-03-10 13:23:20 +00003436
Matt Caswell0f113f32015-01-22 03:40:55 +00003437 if ((dh = DH_new()) == NULL)
3438 return (NULL);
3439 dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
3440 dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
3441 if ((dh->p == NULL) || (dh->g == NULL)) {
3442 DH_free(dh);
3443 return (NULL);
3444 }
3445 dh->length = 160;
3446 return (dh);
3447}
Nils Larschf71165b2006-02-24 17:58:43 +00003448#endif
Nils Larsch6e119bb2005-08-25 07:29:54 +00003449
Nils Larschddac1972006-03-10 23:06:27 +00003450#ifndef OPENSSL_NO_PSK
3451/* convert the PSK key (psk_key) in ascii to binary (psk) */
3452static int psk_key2bn(const char *pskkey, unsigned char *psk,
Matt Caswell0f113f32015-01-22 03:40:55 +00003453 unsigned int max_psk_len)
3454{
3455 int ret;
3456 BIGNUM *bn = NULL;
Nils Larschddac1972006-03-10 23:06:27 +00003457
Matt Caswell0f113f32015-01-22 03:40:55 +00003458 ret = BN_hex2bn(&bn, pskkey);
3459 if (!ret) {
3460 BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
3461 pskkey);
Rich Salz23a1d5e2015-04-30 21:37:06 -04003462 BN_free(bn);
Matt Caswell0f113f32015-01-22 03:40:55 +00003463 return 0;
3464 }
3465 if (BN_num_bytes(bn) > (int)max_psk_len) {
3466 BIO_printf(bio_err,
3467 "psk buffer of callback is too small (%d) for key (%d)\n",
3468 max_psk_len, BN_num_bytes(bn));
3469 BN_free(bn);
3470 return 0;
3471 }
3472 ret = BN_bn2bin(bn, psk);
3473 BN_free(bn);
3474 return ret;
3475}
Nils Larschddac1972006-03-10 23:06:27 +00003476
Matt Caswell0f113f32015-01-22 03:40:55 +00003477static unsigned int psk_client_callback(SSL *ssl, const char *hint,
3478 char *identity,
3479 unsigned int max_identity_len,
3480 unsigned char *psk,
3481 unsigned int max_psk_len)
3482{
3483 int ret;
3484 unsigned int psk_len = 0;
Nils Larschddac1972006-03-10 23:06:27 +00003485
Matt Caswell0f113f32015-01-22 03:40:55 +00003486 ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3487 if (ret < 0)
3488 goto out_err;
3489 if (debug)
3490 fprintf(stderr, "client: created identity '%s' len=%d\n", identity,
3491 ret);
3492 ret = psk_key2bn(psk_key, psk, max_psk_len);
3493 if (ret < 0)
3494 goto out_err;
3495 psk_len = ret;
3496 out_err:
3497 return psk_len;
3498}
Nils Larschddac1972006-03-10 23:06:27 +00003499
3500static unsigned int psk_server_callback(SSL *ssl, const char *identity,
Matt Caswell0f113f32015-01-22 03:40:55 +00003501 unsigned char *psk,
3502 unsigned int max_psk_len)
3503{
3504 unsigned int psk_len = 0;
Nils Larschddac1972006-03-10 23:06:27 +00003505
Matt Caswell0f113f32015-01-22 03:40:55 +00003506 if (strcmp(identity, "Client_identity") != 0) {
3507 BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3508 return 0;
3509 }
3510 psk_len = psk_key2bn(psk_key, psk, max_psk_len);
3511 return psk_len;
3512}
Nils Larschddac1972006-03-10 23:06:27 +00003513#endif
3514
Nils Larsch6e119bb2005-08-25 07:29:54 +00003515static int do_test_cipherlist(void)
Matt Caswell0f113f32015-01-22 03:40:55 +00003516{
Viktor Dukhovni6b01bed2016-01-18 13:10:21 -05003517#if !defined(OPENSSL_NO_SSL3) || !defined(OPENSSL_NO_TLS1)
Matt Caswell0f113f32015-01-22 03:40:55 +00003518 int i = 0;
3519 const SSL_METHOD *meth;
3520 const SSL_CIPHER *ci, *tci = NULL;
Viktor Dukhovni6b01bed2016-01-18 13:10:21 -05003521#endif
Nils Larsch6e119bb2005-08-25 07:29:54 +00003522
Nils Larsch00fe8652006-01-15 17:35:28 +00003523#ifndef OPENSSL_NO_SSL3
Matt Caswell0f113f32015-01-22 03:40:55 +00003524 meth = SSLv3_method();
3525 tci = NULL;
3526 while ((ci = meth->get_cipher(i++)) != NULL) {
3527 if (tci != NULL)
3528 if (ci->id >= tci->id) {
Rich Salz3dca57f2015-04-21 15:52:51 -04003529 fprintf(stderr, "testing SSLv3 cipher list order: ");
Dr. Stephen Henson90d9e492015-11-05 16:14:17 +00003530 fprintf(stderr, "failed %x vs. %x\n", ci->id, tci->id);
Matt Caswell0f113f32015-01-22 03:40:55 +00003531 return 0;
3532 }
3533 tci = ci;
3534 }
Nils Larsch00fe8652006-01-15 17:35:28 +00003535#endif
Viktor Dukhovni6b01bed2016-01-18 13:10:21 -05003536#ifndef OPENSSL_NO_TLS1
Matt Caswell0f113f32015-01-22 03:40:55 +00003537 meth = TLSv1_method();
3538 tci = NULL;
3539 while ((ci = meth->get_cipher(i++)) != NULL) {
3540 if (tci != NULL)
3541 if (ci->id >= tci->id) {
Rich Salz3dca57f2015-04-21 15:52:51 -04003542 fprintf(stderr, "testing TLSv1 cipher list order: ");
Dr. Stephen Henson90d9e492015-11-05 16:14:17 +00003543 fprintf(stderr, "failed %x vs. %x\n", ci->id, tci->id);
Matt Caswell0f113f32015-01-22 03:40:55 +00003544 return 0;
3545 }
3546 tci = ci;
3547 }
Viktor Dukhovni6b01bed2016-01-18 13:10:21 -05003548#endif
Nils Larsch6e119bb2005-08-25 07:29:54 +00003549
Matt Caswell0f113f32015-01-22 03:40:55 +00003550 return 1;
3551}