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