test/ssltest_old.c

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