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