test/ssltest.c

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