ssl/ssltest.c

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