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