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