ssl/ssltest.c

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