test/ssltest.c

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