test/ssltest_old.c

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