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