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 OpenSSL license (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 OPENSSL_UNISTD
  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()
 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_server_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 = SSL3_VERSION;
1335         max_version = TLS_MAX_VERSION;
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 = DTLS_MIN_VERSION;
1349             max_version = DTLS_MAX_VERSION;
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 (!SSL_CTX_set_cipher_list(c_ctx, cipher)
1386             || !SSL_CTX_set_cipher_list(s_ctx, cipher)
1387             || !SSL_CTX_set_cipher_list(s_ctx2, cipher)) {
1388             ERR_print_errors(bio_err);
1389             goto end;
1390         }
1391     }
1392     if (ciphersuites != NULL) {
1393         if (!SSL_CTX_set_ciphersuites(c_ctx, ciphersuites)
1394             || !SSL_CTX_set_ciphersuites(s_ctx, ciphersuites)
1395             || !SSL_CTX_set_ciphersuites(s_ctx2, ciphersuites)) {
1396             ERR_print_errors(bio_err);
1397             goto end;
1398         }
1399     }
1400
1401 #ifndef OPENSSL_NO_CT
1402     if (ct_validation &&
1403         !SSL_CTX_enable_ct(c_ctx, SSL_CT_VALIDATION_STRICT)) {
1404         ERR_print_errors(bio_err);
1405         goto end;
1406     }
1407 #endif
1408
1409     /* Process SSL_CONF arguments */
1410     SSL_CONF_CTX_set_ssl_ctx(c_cctx, c_ctx);
1411     SSL_CONF_CTX_set_ssl_ctx(s_cctx, s_ctx);
1412     SSL_CONF_CTX_set_ssl_ctx(s_cctx2, s_ctx2);
1413
1414     for (i = 0; i < sk_OPENSSL_STRING_num(conf_args); i += 2) {
1415         int rv;
1416         arg = sk_OPENSSL_STRING_value(conf_args, i);
1417         argn = sk_OPENSSL_STRING_value(conf_args, i + 1);
1418         rv = SSL_CONF_cmd(c_cctx, arg, argn);
1419         /* If not recognised use server context */
1420         if (rv == -2) {
1421             rv = SSL_CONF_cmd(s_cctx2, arg, argn);
1422             if (rv > 0)
1423                 rv = SSL_CONF_cmd(s_cctx, arg, argn);
1424         }
1425         if (rv <= 0) {
1426             BIO_printf(bio_err, "Error processing %s %s\n",
1427                        arg, argn ? argn : "");
1428             ERR_print_errors(bio_err);
1429             goto end;
1430         }
1431     }
1432
1433     if (!SSL_CONF_CTX_finish(s_cctx) || !SSL_CONF_CTX_finish(c_cctx) || !SSL_CONF_CTX_finish(s_cctx2)) {
1434         BIO_puts(bio_err, "Error finishing context\n");
1435         ERR_print_errors(bio_err);
1436         goto end;
1437     }
1438 #ifndef OPENSSL_NO_DH
1439     if (!no_dhe) {
1440         if (dhe1024dsa) {
1441             dh = get_dh1024dsa();
1442         } else if (dhe512)
1443             dh = get_dh512();
1444         else
1445             dh = get_dh1024();
1446         SSL_CTX_set_tmp_dh(s_ctx, dh);
1447         SSL_CTX_set_tmp_dh(s_ctx2, dh);
1448         DH_free(dh);
1449     }
1450 #else
1451     (void)no_dhe;
1452 #endif
1453
1454     if ((!SSL_CTX_load_verify_locations(s_ctx, CAfile, CApath)) ||
1455         (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1456         (!SSL_CTX_load_verify_locations(s_ctx2, CAfile, CApath)) ||
1457         (!SSL_CTX_set_default_verify_paths(s_ctx2)) ||
1458         (!SSL_CTX_load_verify_locations(c_ctx, CAfile, CApath)) ||
1459         (!SSL_CTX_set_default_verify_paths(c_ctx))) {
1460         ERR_print_errors(bio_err);
1461     }
1462
1463 #ifndef OPENSSL_NO_CT
1464     if (!SSL_CTX_set_default_ctlog_list_file(s_ctx) ||
1465         !SSL_CTX_set_default_ctlog_list_file(s_ctx2) ||
1466         !SSL_CTX_set_default_ctlog_list_file(c_ctx)) {
1467         ERR_print_errors(bio_err);
1468     }
1469 #endif
1470
1471     if (client_auth) {
1472         printf("client authentication\n");
1473         SSL_CTX_set_verify(s_ctx,
1474                            SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1475                            verify_callback);
1476         SSL_CTX_set_verify(s_ctx2,
1477                            SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1478                            verify_callback);
1479         SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback,
1480                                          &app_verify_arg);
1481         SSL_CTX_set_cert_verify_callback(s_ctx2, app_verify_callback,
1482                                          &app_verify_arg);
1483     }
1484     if (server_auth) {
1485         printf("server authentication\n");
1486         SSL_CTX_set_verify(c_ctx, SSL_VERIFY_PEER, verify_callback);
1487         SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback,
1488                                          &app_verify_arg);
1489     }
1490
1491     {
1492         int session_id_context = 0;
1493         if (!SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context,
1494                                             sizeof(session_id_context)) ||
1495             !SSL_CTX_set_session_id_context(s_ctx2, (void *)&session_id_context,
1496                                             sizeof(session_id_context))) {
1497             ERR_print_errors(bio_err);
1498             goto end;
1499         }
1500     }
1501
1502     /* Use PSK only if PSK key is given */
1503     if (psk_key != NULL) {
1504         /*
1505          * no_psk is used to avoid putting psk command to openssl tool
1506          */
1507         if (no_psk) {
1508             /*
1509              * if PSK is not compiled in and psk key is given, do nothing and
1510              * exit successfully
1511              */
1512             ret = EXIT_SUCCESS;
1513             goto end;
1514         }
1515 #ifndef OPENSSL_NO_PSK
1516         SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1517         SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1518         SSL_CTX_set_psk_server_callback(s_ctx2, psk_server_callback);
1519         if (debug)
1520             BIO_printf(bio_err, "setting PSK identity hint to s_ctx\n");
1521         if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint") ||
1522             !SSL_CTX_use_psk_identity_hint(s_ctx2, "ctx server identity_hint")) {
1523             BIO_printf(bio_err, "error setting PSK identity hint to s_ctx\n");
1524             ERR_print_errors(bio_err);
1525             goto end;
1526         }
1527 #endif
1528     }
1529
1530 #ifndef OPENSSL_NO_NEXTPROTONEG
1531     if (npn_client) {
1532         SSL_CTX_set_next_proto_select_cb(c_ctx, cb_client_npn, NULL);
1533     }
1534     if (npn_server) {
1535         if (npn_server_reject) {
1536             BIO_printf(bio_err,
1537                        "Can't have both -npn_server and -npn_server_reject\n");
1538             goto end;
1539         }
1540         SSL_CTX_set_npn_advertised_cb(s_ctx, cb_server_npn, NULL);
1541         SSL_CTX_set_npn_advertised_cb(s_ctx2, cb_server_npn, NULL);
1542     }
1543     if (npn_server_reject) {
1544         SSL_CTX_set_npn_advertised_cb(s_ctx, cb_server_rejects_npn, NULL);
1545         SSL_CTX_set_npn_advertised_cb(s_ctx2, cb_server_rejects_npn, NULL);
1546     }
1547 #endif
1548
1549     if (serverinfo_sct) {
1550         if (!SSL_CTX_add_client_custom_ext(c_ctx,
1551                 TLSEXT_TYPE_signed_certificate_timestamp,
1552                 NULL, NULL, NULL,
1553                 serverinfo_cli_parse_cb, NULL)) {
1554             BIO_printf(bio_err, "Error adding SCT extension\n");
1555             goto end;
1556         }
1557     }
1558     if (serverinfo_tack) {
1559         if (!SSL_CTX_add_client_custom_ext(c_ctx, TACK_EXT_TYPE,
1560                                       NULL, NULL, NULL,
1561                                       serverinfo_cli_parse_cb, NULL)) {
1562             BIO_printf(bio_err, "Error adding TACK extension\n");
1563             goto end;
1564         }
1565     }
1566     if (serverinfo_file)
1567         if (!SSL_CTX_use_serverinfo_file(s_ctx, serverinfo_file) ||
1568             !SSL_CTX_use_serverinfo_file(s_ctx2, serverinfo_file)) {
1569             BIO_printf(bio_err, "missing serverinfo file\n");
1570             goto end;
1571         }
1572
1573     if (custom_ext) {
1574         if (!SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_0,
1575                                       custom_ext_0_cli_add_cb,
1576                                       NULL, NULL,
1577                                       custom_ext_0_cli_parse_cb, NULL)
1578             || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_1,
1579                                       custom_ext_1_cli_add_cb,
1580                                       NULL, NULL,
1581                                       custom_ext_1_cli_parse_cb, NULL)
1582             || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_2,
1583                                       custom_ext_2_cli_add_cb,
1584                                       NULL, NULL,
1585                                       custom_ext_2_cli_parse_cb, NULL)
1586             || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_3,
1587                                       custom_ext_3_cli_add_cb,
1588                                       NULL, NULL,
1589                                       custom_ext_3_cli_parse_cb, NULL)
1590             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_0,
1591                                       custom_ext_0_srv_add_cb,
1592                                       NULL, NULL,
1593                                       custom_ext_0_srv_parse_cb, NULL)
1594             || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_0,
1595                                       custom_ext_0_srv_add_cb,
1596                                       NULL, NULL,
1597                                       custom_ext_0_srv_parse_cb, NULL)
1598             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_1,
1599                                       custom_ext_1_srv_add_cb,
1600                                       NULL, NULL,
1601                                       custom_ext_1_srv_parse_cb, NULL)
1602             || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_1,
1603                                       custom_ext_1_srv_add_cb,
1604                                       NULL, NULL,
1605                                       custom_ext_1_srv_parse_cb, NULL)
1606             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_2,
1607                                       custom_ext_2_srv_add_cb,
1608                                       NULL, NULL,
1609                                       custom_ext_2_srv_parse_cb, NULL)
1610             || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_2,
1611                                       custom_ext_2_srv_add_cb,
1612                                       NULL, NULL,
1613                                       custom_ext_2_srv_parse_cb, NULL)
1614             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_3,
1615                                       custom_ext_3_srv_add_cb,
1616                                       NULL, NULL,
1617                                       custom_ext_3_srv_parse_cb, NULL)
1618             || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_3,
1619                                       custom_ext_3_srv_add_cb,
1620                                       NULL, NULL,
1621                                       custom_ext_3_srv_parse_cb, NULL)) {
1622             BIO_printf(bio_err, "Error setting custom extensions\n");
1623             goto end;
1624         }
1625     }
1626
1627     if (alpn_server)
1628         SSL_CTX_set_alpn_select_cb(s_ctx, cb_server_alpn, alpn_server);
1629     if (alpn_server2)
1630         SSL_CTX_set_alpn_select_cb(s_ctx2, cb_server_alpn, alpn_server2);
1631
1632     if (alpn_client) {
1633         size_t alpn_len;
1634         unsigned char *alpn = next_protos_parse(&alpn_len, alpn_client);
1635
1636         if (alpn == NULL) {
1637             BIO_printf(bio_err, "Error parsing -alpn_client argument\n");
1638             goto end;
1639         }
1640         /* Returns 0 on success!! */
1641         if (SSL_CTX_set_alpn_protos(c_ctx, alpn, alpn_len)) {
1642             BIO_printf(bio_err, "Error setting ALPN\n");
1643             OPENSSL_free(alpn);
1644             goto end;
1645         }
1646         OPENSSL_free(alpn);
1647     }
1648
1649     if (server_sess_in != NULL) {
1650         server_sess = read_session(server_sess_in);
1651         if (server_sess == NULL)
1652             goto end;
1653     }
1654     if (client_sess_in != NULL) {
1655         client_sess = read_session(client_sess_in);
1656         if (client_sess == NULL)
1657             goto end;
1658     }
1659
1660     if (server_sess_out != NULL || server_sess_in != NULL) {
1661         char *keys;
1662         long size;
1663
1664         /* Use a fixed key so that we can decrypt the ticket. */
1665         size = SSL_CTX_set_tlsext_ticket_keys(s_ctx, NULL, 0);
1666         keys = OPENSSL_zalloc(size);
1667         SSL_CTX_set_tlsext_ticket_keys(s_ctx, keys, size);
1668         OPENSSL_free(keys);
1669     }
1670
1671     if (sn_server1 != NULL || sn_server2 != NULL)
1672         SSL_CTX_set_tlsext_servername_callback(s_ctx, servername_cb);
1673
1674     c_ssl = SSL_new(c_ctx);
1675     s_ssl = SSL_new(s_ctx);
1676
1677     if (sn_client)
1678         SSL_set_tlsext_host_name(c_ssl, sn_client);
1679
1680     if (!set_protocol_version(server_min_proto, s_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1681         goto end;
1682     if (!set_protocol_version(server_max_proto, s_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1683         goto end;
1684     if (!set_protocol_version(client_min_proto, c_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1685         goto end;
1686     if (!set_protocol_version(client_max_proto, c_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1687         goto end;
1688
1689     if (server_sess) {
1690         if (SSL_CTX_add_session(s_ctx, server_sess) == 0) {
1691             BIO_printf(bio_err, "Can't add server session\n");
1692             ERR_print_errors(bio_err);
1693             goto end;
1694         }
1695     }
1696
1697     BIO_printf(bio_stdout, "Doing handshakes=%d bytes=%ld\n", number, bytes);
1698     for (i = 0; i < number; i++) {
1699         if (!reuse) {
1700             if (!SSL_set_session(c_ssl, NULL)) {
1701                 BIO_printf(bio_err, "Failed to set session\n");
1702                 goto end;
1703             }
1704         }
1705         if (client_sess_in != NULL) {
1706             if (SSL_set_session(c_ssl, client_sess) == 0) {
1707                 BIO_printf(bio_err, "Can't set client session\n");
1708                 ERR_print_errors(bio_err);
1709                 goto end;
1710             }
1711         }
1712         switch (bio_type) {
1713         case BIO_MEM:
1714             ret = doit(s_ssl, c_ssl, bytes);
1715             break;
1716         case BIO_PAIR:
1717             ret = doit_biopair(s_ssl, c_ssl, bytes, &s_time, &c_time);
1718             break;
1719 #ifndef OPENSSL_NO_SOCK
1720         case BIO_IPV4:
1721             ret = doit_localhost(s_ssl, c_ssl, BIO_FAMILY_IPV4,
1722                                  bytes, &s_time, &c_time);
1723             break;
1724         case BIO_IPV6:
1725             ret = doit_localhost(s_ssl, c_ssl, BIO_FAMILY_IPV6,
1726                                  bytes, &s_time, &c_time);
1727             break;
1728 #else
1729         case BIO_IPV4:
1730         case BIO_IPV6:
1731             ret = EXIT_FAILURE;
1732             goto err;
1733 #endif
1734         }
1735         if (ret != EXIT_SUCCESS)  break;
1736     }
1737
1738     if (should_negotiate && ret == EXIT_SUCCESS &&
1739         strcmp(should_negotiate, "fail-server") != 0 &&
1740         strcmp(should_negotiate, "fail-client") != 0) {
1741         int version = protocol_from_string(should_negotiate);
1742         if (version < 0) {
1743             BIO_printf(bio_err, "Error parsing: %s\n", should_negotiate);
1744             ret = EXIT_FAILURE;
1745             goto err;
1746         }
1747         if (SSL_version(c_ssl) != version) {
1748             BIO_printf(bio_err, "Unexpected version negotiated. "
1749                 "Expected: %s, got %s\n", should_negotiate, SSL_get_version(c_ssl));
1750             ret = EXIT_FAILURE;
1751             goto err;
1752         }
1753     }
1754
1755     if (should_reuse != -1) {
1756         if (SSL_session_reused(s_ssl) != should_reuse ||
1757             SSL_session_reused(c_ssl) != should_reuse) {
1758             BIO_printf(bio_err, "Unexpected session reuse state. "
1759                 "Expected: %d, server: %d, client: %d\n", should_reuse,
1760                 SSL_session_reused(s_ssl), SSL_session_reused(c_ssl));
1761             ret = EXIT_FAILURE;
1762             goto err;
1763         }
1764     }
1765
1766     if (server_sess_out != NULL) {
1767         if (write_session(server_sess_out, SSL_get_session(s_ssl)) == 0) {
1768             ret = EXIT_FAILURE;
1769             goto err;
1770         }
1771     }
1772     if (client_sess_out != NULL) {
1773         if (write_session(client_sess_out, SSL_get_session(c_ssl)) == 0) {
1774             ret = EXIT_FAILURE;
1775             goto err;
1776         }
1777     }
1778
1779     if (!verbose) {
1780         print_details(c_ssl, "");
1781     }
1782     if (print_time) {
1783 #ifdef CLOCKS_PER_SEC
1784         /*
1785          * "To determine the time in seconds, the value returned by the clock
1786          * function should be divided by the value of the macro
1787          * CLOCKS_PER_SEC." -- ISO/IEC 9899
1788          */
1789         BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1790                    "Approximate total client time: %6.2f s\n",
1791                    (double)s_time / CLOCKS_PER_SEC,
1792                    (double)c_time / CLOCKS_PER_SEC);
1793 #else
1794         BIO_printf(bio_stdout,
1795                    "Approximate total server time: %6.2f units\n"
1796                    "Approximate total client time: %6.2f units\n",
1797                    (double)s_time, (double)c_time);
1798 #endif
1799     }
1800
1801  err:
1802     SSL_free(s_ssl);
1803     SSL_free(c_ssl);
1804
1805  end:
1806     SSL_CTX_free(s_ctx);
1807     SSL_CTX_free(s_ctx2);
1808     SSL_CTX_free(c_ctx);
1809     SSL_CONF_CTX_free(s_cctx);
1810     SSL_CONF_CTX_free(s_cctx2);
1811     SSL_CONF_CTX_free(c_cctx);
1812     sk_OPENSSL_STRING_free(conf_args);
1813
1814     BIO_free(bio_stdout);
1815
1816     SSL_SESSION_free(server_sess);
1817     SSL_SESSION_free(client_sess);
1818
1819 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
1820     if (CRYPTO_mem_leaks(bio_err) <= 0)
1821         ret = EXIT_FAILURE;
1822 #endif
1823     BIO_free(bio_err);
1824     EXIT(ret);
1825 }
1826
1827 #ifndef OPENSSL_NO_SOCK
1828 int doit_localhost(SSL *s_ssl, SSL *c_ssl, int family, long count,
1829                    clock_t *s_time, clock_t *c_time)
1830 {
1831     long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1832     BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1833     BIO *acpt = NULL, *server = NULL, *client = NULL;
1834     char addr_str[40];
1835     int ret = EXIT_FAILURE;
1836     int err_in_client = 0;
1837     int err_in_server = 0;
1838
1839     acpt = BIO_new_accept(family == BIO_FAMILY_IPV4 ? "127.0.0.1:0"
1840                                                     : "[::1]:0");
1841     if (acpt == NULL)
1842         goto err;
1843     BIO_set_accept_ip_family(acpt, family);
1844     BIO_set_bind_mode(acpt, BIO_SOCK_NONBLOCK | BIO_SOCK_REUSEADDR);
1845     if (BIO_do_accept(acpt) <= 0)
1846         goto err;
1847
1848     BIO_snprintf(addr_str, sizeof(addr_str), ":%s", BIO_get_accept_port(acpt));
1849
1850     client = BIO_new_connect(addr_str);
1851     BIO_set_conn_ip_family(client, family);
1852     if (!client)
1853         goto err;
1854
1855     if (BIO_set_nbio(client, 1) <= 0)
1856         goto err;
1857     if (BIO_set_nbio(acpt, 1) <= 0)
1858         goto err;
1859
1860     {
1861         int st_connect = 0, st_accept = 0;
1862
1863         while(!st_connect || !st_accept) {
1864             if (!st_connect) {
1865                 if (BIO_do_connect(client) <= 0) {
1866                     if (!BIO_should_retry(client))
1867                         goto err;
1868                 } else {
1869                     st_connect = 1;
1870                 }
1871             }
1872             if (!st_accept) {
1873                 if (BIO_do_accept(acpt) <= 0) {
1874                     if (!BIO_should_retry(acpt))
1875                         goto err;
1876                 } else {
1877                     st_accept = 1;
1878                 }
1879             }
1880         }
1881     }
1882     /* We're not interested in accepting further connects */
1883     server = BIO_pop(acpt);
1884     BIO_free_all(acpt);
1885     acpt = NULL;
1886
1887     s_ssl_bio = BIO_new(BIO_f_ssl());
1888     if (!s_ssl_bio)
1889         goto err;
1890
1891     c_ssl_bio = BIO_new(BIO_f_ssl());
1892     if (!c_ssl_bio)
1893         goto err;
1894
1895     SSL_set_connect_state(c_ssl);
1896     SSL_set_bio(c_ssl, client, client);
1897     (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1898
1899     SSL_set_accept_state(s_ssl);
1900     SSL_set_bio(s_ssl, server, server);
1901     (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1902
1903     do {
1904         /*-
1905          * c_ssl_bio:          SSL filter BIO
1906          *
1907          * client:             I/O for SSL library
1908          *
1909          *
1910          * server:             I/O for SSL library
1911          *
1912          * s_ssl_bio:          SSL filter BIO
1913          */
1914
1915         /*
1916          * We have non-blocking behaviour throughout this test program, but
1917          * can be sure that there is *some* progress in each iteration; so we
1918          * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
1919          * we just try everything in each iteration
1920          */
1921
1922         {
1923             /* CLIENT */
1924
1925             char cbuf[1024 * 8];
1926             int i, r;
1927             clock_t c_clock = clock();
1928
1929             memset(cbuf, 0, sizeof(cbuf));
1930
1931             if (debug)
1932                 if (SSL_in_init(c_ssl))
1933                     printf("client waiting in SSL_connect - %s\n",
1934                            SSL_state_string_long(c_ssl));
1935
1936             if (cw_num > 0) {
1937                 /* Write to server. */
1938
1939                 if (cw_num > (long)sizeof(cbuf))
1940                     i = sizeof(cbuf);
1941                 else
1942                     i = (int)cw_num;
1943                 r = BIO_write(c_ssl_bio, cbuf, i);
1944                 if (r < 0) {
1945                     if (!BIO_should_retry(c_ssl_bio)) {
1946                         fprintf(stderr, "ERROR in CLIENT\n");
1947                         err_in_client = 1;
1948                         goto err;
1949                     }
1950                     /*
1951                      * BIO_should_retry(...) can just be ignored here. The
1952                      * library expects us to call BIO_write with the same
1953                      * arguments again, and that's what we will do in the
1954                      * next iteration.
1955                      */
1956                 } else if (r == 0) {
1957                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1958                     goto err;
1959                 } else {
1960                     if (debug)
1961                         printf("client wrote %d\n", r);
1962                     cw_num -= r;
1963                 }
1964             }
1965
1966             if (cr_num > 0) {
1967                 /* Read from server. */
1968
1969                 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1970                 if (r < 0) {
1971                     if (!BIO_should_retry(c_ssl_bio)) {
1972                         fprintf(stderr, "ERROR in CLIENT\n");
1973                         err_in_client = 1;
1974                         goto err;
1975                     }
1976                     /*
1977                      * Again, "BIO_should_retry" can be ignored.
1978                      */
1979                 } else if (r == 0) {
1980                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1981                     goto err;
1982                 } else {
1983                     if (debug)
1984                         printf("client read %d\n", r);
1985                     cr_num -= r;
1986                 }
1987             }
1988
1989             /*
1990              * c_time and s_time increments will typically be very small
1991              * (depending on machine speed and clock tick intervals), but
1992              * sampling over a large number of connections should result in
1993              * fairly accurate figures.  We cannot guarantee a lot, however
1994              * -- if each connection lasts for exactly one clock tick, it
1995              * will be counted only for the client or only for the server or
1996              * even not at all.
1997              */
1998             *c_time += (clock() - c_clock);
1999         }
2000
2001         {
2002             /* SERVER */
2003
2004             char sbuf[1024 * 8];
2005             int i, r;
2006             clock_t s_clock = clock();
2007
2008             memset(sbuf, 0, sizeof(sbuf));
2009
2010             if (debug)
2011                 if (SSL_in_init(s_ssl))
2012                     printf("server waiting in SSL_accept - %s\n",
2013                            SSL_state_string_long(s_ssl));
2014
2015             if (sw_num > 0) {
2016                 /* Write to client. */
2017
2018                 if (sw_num > (long)sizeof(sbuf))
2019                     i = sizeof(sbuf);
2020                 else
2021                     i = (int)sw_num;
2022                 r = BIO_write(s_ssl_bio, sbuf, i);
2023                 if (r < 0) {
2024                     if (!BIO_should_retry(s_ssl_bio)) {
2025                         fprintf(stderr, "ERROR in SERVER\n");
2026                         err_in_server = 1;
2027                         goto err;
2028                     }
2029                     /* Ignore "BIO_should_retry". */
2030                 } else if (r == 0) {
2031                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2032                     goto err;
2033                 } else {
2034                     if (debug)
2035                         printf("server wrote %d\n", r);
2036                     sw_num -= r;
2037                 }
2038             }
2039
2040             if (sr_num > 0) {
2041                 /* Read from client. */
2042
2043                 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2044                 if (r < 0) {
2045                     if (!BIO_should_retry(s_ssl_bio)) {
2046                         fprintf(stderr, "ERROR in SERVER\n");
2047                         err_in_server = 1;
2048                         goto err;
2049                     }
2050                     /* blah, blah */
2051                 } else if (r == 0) {
2052                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2053                     goto err;
2054                 } else {
2055                     if (debug)
2056                         printf("server read %d\n", r);
2057                     sr_num -= r;
2058                 }
2059             }
2060
2061             *s_time += (clock() - s_clock);
2062         }
2063     }
2064     while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2065
2066     if (verbose)
2067         print_details(c_ssl, "DONE via TCP connect: ");
2068 # ifndef OPENSSL_NO_NEXTPROTONEG
2069     if (verify_npn(c_ssl, s_ssl) < 0)
2070         goto end;
2071 # endif
2072     if (verify_serverinfo() < 0) {
2073         fprintf(stderr, "Server info verify error\n");
2074         goto err;
2075     }
2076     if (verify_alpn(c_ssl, s_ssl) < 0
2077             || verify_servername(c_ssl, s_ssl) < 0)
2078         goto err;
2079
2080     if (custom_ext_error) {
2081         fprintf(stderr, "Custom extension error\n");
2082         goto err;
2083     }
2084
2085 # ifndef OPENSSL_NO_NEXTPROTONEG
2086  end:
2087 # endif
2088     ret = EXIT_SUCCESS;
2089
2090  err:
2091     ERR_print_errors(bio_err);
2092
2093     BIO_free_all(acpt);
2094     BIO_free(server);
2095     BIO_free(client);
2096     BIO_free(s_ssl_bio);
2097     BIO_free(c_ssl_bio);
2098
2099     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2100         ret = (err_in_client != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2101     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2102         ret = (err_in_server != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2103
2104     return ret;
2105 }
2106 #endif
2107
2108 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
2109                  clock_t *s_time, clock_t *c_time)
2110 {
2111     long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
2112     BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
2113     BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
2114     int ret = EXIT_FAILURE;
2115     int err_in_client = 0;
2116     int err_in_server = 0;
2117
2118     size_t bufsiz = 256;        /* small buffer for testing */
2119
2120     if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
2121         goto err;
2122     if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
2123         goto err;
2124
2125     s_ssl_bio = BIO_new(BIO_f_ssl());
2126     if (!s_ssl_bio)
2127         goto err;
2128
2129     c_ssl_bio = BIO_new(BIO_f_ssl());
2130     if (!c_ssl_bio)
2131         goto err;
2132
2133     SSL_set_connect_state(c_ssl);
2134     SSL_set_bio(c_ssl, client, client);
2135     (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
2136
2137     SSL_set_accept_state(s_ssl);
2138     SSL_set_bio(s_ssl, server, server);
2139     (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
2140
2141     do {
2142         /*-
2143          * c_ssl_bio:          SSL filter BIO
2144          *
2145          * client:             pseudo-I/O for SSL library
2146          *
2147          * client_io:          client's SSL communication; usually to be
2148          *                     relayed over some I/O facility, but in this
2149          *                     test program, we're the server, too:
2150          *
2151          * server_io:          server's SSL communication
2152          *
2153          * server:             pseudo-I/O for SSL library
2154          *
2155          * s_ssl_bio:          SSL filter BIO
2156          *
2157          * The client and the server each employ a "BIO pair":
2158          * client + client_io, server + server_io.
2159          * BIO pairs are symmetric.  A BIO pair behaves similar
2160          * to a non-blocking socketpair (but both endpoints must
2161          * be handled by the same thread).
2162          * [Here we could connect client and server to the ends
2163          * of a single BIO pair, but then this code would be less
2164          * suitable as an example for BIO pairs in general.]
2165          *
2166          * Useful functions for querying the state of BIO pair endpoints:
2167          *
2168          * BIO_ctrl_pending(bio)              number of bytes we can read now
2169          * BIO_ctrl_get_read_request(bio)     number of bytes needed to fulfill
2170          *                                      other side's read attempt
2171          * BIO_ctrl_get_write_guarantee(bio)   number of bytes we can write now
2172          *
2173          * ..._read_request is never more than ..._write_guarantee;
2174          * it depends on the application which one you should use.
2175          */
2176
2177         /*
2178          * We have non-blocking behaviour throughout this test program, but
2179          * can be sure that there is *some* progress in each iteration; so we
2180          * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
2181          * we just try everything in each iteration
2182          */
2183
2184         {
2185             /* CLIENT */
2186
2187             char cbuf[1024 * 8];
2188             int i, r;
2189             clock_t c_clock = clock();
2190
2191             memset(cbuf, 0, sizeof(cbuf));
2192
2193             if (debug)
2194                 if (SSL_in_init(c_ssl))
2195                     printf("client waiting in SSL_connect - %s\n",
2196                            SSL_state_string_long(c_ssl));
2197
2198             if (cw_num > 0) {
2199                 /* Write to server. */
2200
2201                 if (cw_num > (long)sizeof(cbuf))
2202                     i = sizeof(cbuf);
2203                 else
2204                     i = (int)cw_num;
2205                 r = BIO_write(c_ssl_bio, cbuf, i);
2206                 if (r < 0) {
2207                     if (!BIO_should_retry(c_ssl_bio)) {
2208                         fprintf(stderr, "ERROR in CLIENT\n");
2209                         err_in_client = 1;
2210                         goto err;
2211                     }
2212                     /*
2213                      * BIO_should_retry(...) can just be ignored here. The
2214                      * library expects us to call BIO_write with the same
2215                      * arguments again, and that's what we will do in the
2216                      * next iteration.
2217                      */
2218                 } else if (r == 0) {
2219                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2220                     goto err;
2221                 } else {
2222                     if (debug)
2223                         printf("client wrote %d\n", r);
2224                     cw_num -= r;
2225                 }
2226             }
2227
2228             if (cr_num > 0) {
2229                 /* Read from server. */
2230
2231                 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
2232                 if (r < 0) {
2233                     if (!BIO_should_retry(c_ssl_bio)) {
2234                         fprintf(stderr, "ERROR in CLIENT\n");
2235                         err_in_client = 1;
2236                         goto err;
2237                     }
2238                     /*
2239                      * Again, "BIO_should_retry" can be ignored.
2240                      */
2241                 } else if (r == 0) {
2242                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2243                     goto err;
2244                 } else {
2245                     if (debug)
2246                         printf("client read %d\n", r);
2247                     cr_num -= r;
2248                 }
2249             }
2250
2251             /*
2252              * c_time and s_time increments will typically be very small
2253              * (depending on machine speed and clock tick intervals), but
2254              * sampling over a large number of connections should result in
2255              * fairly accurate figures.  We cannot guarantee a lot, however
2256              * -- if each connection lasts for exactly one clock tick, it
2257              * will be counted only for the client or only for the server or
2258              * even not at all.
2259              */
2260             *c_time += (clock() - c_clock);
2261         }
2262
2263         {
2264             /* SERVER */
2265
2266             char sbuf[1024 * 8];
2267             int i, r;
2268             clock_t s_clock = clock();
2269
2270             memset(sbuf, 0, sizeof(sbuf));
2271
2272             if (debug)
2273                 if (SSL_in_init(s_ssl))
2274                     printf("server waiting in SSL_accept - %s\n",
2275                            SSL_state_string_long(s_ssl));
2276
2277             if (sw_num > 0) {
2278                 /* Write to client. */
2279
2280                 if (sw_num > (long)sizeof(sbuf))
2281                     i = sizeof(sbuf);
2282                 else
2283                     i = (int)sw_num;
2284                 r = BIO_write(s_ssl_bio, sbuf, i);
2285                 if (r < 0) {
2286                     if (!BIO_should_retry(s_ssl_bio)) {
2287                         fprintf(stderr, "ERROR in SERVER\n");
2288                         err_in_server = 1;
2289                         goto err;
2290                     }
2291                     /* Ignore "BIO_should_retry". */
2292                 } else if (r == 0) {
2293                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2294                     goto err;
2295                 } else {
2296                     if (debug)
2297                         printf("server wrote %d\n", r);
2298                     sw_num -= r;
2299                 }
2300             }
2301
2302             if (sr_num > 0) {
2303                 /* Read from client. */
2304
2305                 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2306                 if (r < 0) {
2307                     if (!BIO_should_retry(s_ssl_bio)) {
2308                         fprintf(stderr, "ERROR in SERVER\n");
2309                         err_in_server = 1;
2310                         goto err;
2311                     }
2312                     /* blah, blah */
2313                 } else if (r == 0) {
2314                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2315                     goto err;
2316                 } else {
2317                     if (debug)
2318                         printf("server read %d\n", r);
2319                     sr_num -= r;
2320                 }
2321             }
2322
2323             *s_time += (clock() - s_clock);
2324         }
2325
2326         {
2327             /* "I/O" BETWEEN CLIENT AND SERVER. */
2328
2329             size_t r1, r2;
2330             BIO *io1 = server_io, *io2 = client_io;
2331             /*
2332              * we use the non-copying interface for io1 and the standard
2333              * BIO_write/BIO_read interface for io2
2334              */
2335
2336             static int prev_progress = 1;
2337             int progress = 0;
2338
2339             /* io1 to io2 */
2340             do {
2341                 size_t num;
2342                 int r;
2343
2344                 r1 = BIO_ctrl_pending(io1);
2345                 r2 = BIO_ctrl_get_write_guarantee(io2);
2346
2347                 num = r1;
2348                 if (r2 < num)
2349                     num = r2;
2350                 if (num) {
2351                     char *dataptr;
2352
2353                     if (INT_MAX < num) /* yeah, right */
2354                         num = INT_MAX;
2355
2356                     r = BIO_nread(io1, &dataptr, (int)num);
2357                     assert(r > 0);
2358                     assert(r <= (int)num);
2359                     /*
2360                      * possibly r < num (non-contiguous data)
2361                      */
2362                     num = r;
2363                     r = BIO_write(io2, dataptr, (int)num);
2364                     if (r != (int)num) { /* can't happen */
2365                         fprintf(stderr, "ERROR: BIO_write could not write "
2366                                 "BIO_ctrl_get_write_guarantee() bytes");
2367                         goto err;
2368                     }
2369                     progress = 1;
2370
2371                     if (debug)
2372                         printf((io1 == client_io) ?
2373                                "C->S relaying: %d bytes\n" :
2374                                "S->C relaying: %d bytes\n", (int)num);
2375                 }
2376             }
2377             while (r1 && r2);
2378
2379             /* io2 to io1 */
2380             {
2381                 size_t num;
2382                 int r;
2383
2384                 r1 = BIO_ctrl_pending(io2);
2385                 r2 = BIO_ctrl_get_read_request(io1);
2386                 /*
2387                  * here we could use ..._get_write_guarantee instead of
2388                  * ..._get_read_request, but by using the latter we test
2389                  * restartability of the SSL implementation more thoroughly
2390                  */
2391                 num = r1;
2392                 if (r2 < num)
2393                     num = r2;
2394                 if (num) {
2395                     char *dataptr;
2396
2397                     if (INT_MAX < num)
2398                         num = INT_MAX;
2399
2400                     if (num > 1)
2401                         --num;  /* test restartability even more thoroughly */
2402
2403                     r = BIO_nwrite0(io1, &dataptr);
2404                     assert(r > 0);
2405                     if (r < (int)num)
2406                         num = r;
2407                     r = BIO_read(io2, dataptr, (int)num);
2408                     if (r != (int)num) { /* can't happen */
2409                         fprintf(stderr, "ERROR: BIO_read could not read "
2410                                 "BIO_ctrl_pending() bytes");
2411                         goto err;
2412                     }
2413                     progress = 1;
2414                     r = BIO_nwrite(io1, &dataptr, (int)num);
2415                     if (r != (int)num) { /* can't happen */
2416                         fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
2417                                 "BIO_nwrite0() bytes");
2418                         goto err;
2419                     }
2420
2421                     if (debug)
2422                         printf((io2 == client_io) ?
2423                                "C->S relaying: %d bytes\n" :
2424                                "S->C relaying: %d bytes\n", (int)num);
2425                 }
2426             }                   /* no loop, BIO_ctrl_get_read_request now
2427                                  * returns 0 anyway */
2428
2429             if (!progress && !prev_progress)
2430                 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0) {
2431                     fprintf(stderr, "ERROR: got stuck\n");
2432                     fprintf(stderr, " ERROR.\n");
2433                     goto err;
2434                 }
2435             prev_progress = progress;
2436         }
2437     }
2438     while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2439
2440     if (verbose)
2441         print_details(c_ssl, "DONE via BIO pair: ");
2442 #ifndef OPENSSL_NO_NEXTPROTONEG
2443     if (verify_npn(c_ssl, s_ssl) < 0)
2444         goto end;
2445 #endif
2446     if (verify_serverinfo() < 0) {
2447         fprintf(stderr, "Server info verify error\n");
2448         goto err;
2449     }
2450     if (verify_alpn(c_ssl, s_ssl) < 0
2451             || verify_servername(c_ssl, s_ssl) < 0)
2452         goto err;
2453
2454     if (custom_ext_error) {
2455         fprintf(stderr, "Custom extension error\n");
2456         goto err;
2457     }
2458
2459 #ifndef OPENSSL_NO_NEXTPROTONEG
2460  end:
2461 #endif
2462     ret = EXIT_SUCCESS;
2463
2464  err:
2465     ERR_print_errors(bio_err);
2466
2467     BIO_free(server);
2468     BIO_free(server_io);
2469     BIO_free(client);
2470     BIO_free(client_io);
2471     BIO_free(s_ssl_bio);
2472     BIO_free(c_ssl_bio);
2473
2474     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2475         ret = (err_in_client != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2476     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2477         ret = (err_in_server != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2478
2479     return ret;
2480 }
2481
2482 #define W_READ  1
2483 #define W_WRITE 2
2484 #define C_DONE  1
2485 #define S_DONE  2
2486
2487 int doit(SSL *s_ssl, SSL *c_ssl, long count)
2488 {
2489     char *cbuf = NULL, *sbuf = NULL;
2490     long bufsiz;
2491     long cw_num = count, cr_num = count;
2492     long sw_num = count, sr_num = count;
2493     int ret = EXIT_FAILURE;
2494     BIO *c_to_s = NULL;
2495     BIO *s_to_c = NULL;
2496     BIO *c_bio = NULL;
2497     BIO *s_bio = NULL;
2498     int c_r, c_w, s_r, s_w;
2499     int i, j;
2500     int done = 0;
2501     int c_write, s_write;
2502     int do_server = 0, do_client = 0;
2503     int max_frag = 5 * 1024;
2504     int err_in_client = 0;
2505     int err_in_server = 0;
2506
2507     bufsiz = count > 40 * 1024 ? 40 * 1024 : count;
2508
2509     if ((cbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2510         goto err;
2511     if ((sbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2512         goto err;
2513
2514     c_to_s = BIO_new(BIO_s_mem());
2515     s_to_c = BIO_new(BIO_s_mem());
2516     if ((s_to_c == NULL) || (c_to_s == NULL)) {
2517         ERR_print_errors(bio_err);
2518         goto err;
2519     }
2520
2521     c_bio = BIO_new(BIO_f_ssl());
2522     s_bio = BIO_new(BIO_f_ssl());
2523     if ((c_bio == NULL) || (s_bio == NULL)) {
2524         ERR_print_errors(bio_err);
2525         goto err;
2526     }
2527
2528     SSL_set_connect_state(c_ssl);
2529     SSL_set_bio(c_ssl, s_to_c, c_to_s);
2530     SSL_set_max_send_fragment(c_ssl, max_frag);
2531     BIO_set_ssl(c_bio, c_ssl, BIO_NOCLOSE);
2532
2533     /*
2534      * We've just given our ref to these BIOs to c_ssl. We need another one to
2535      * give to s_ssl
2536      */
2537     if (!BIO_up_ref(c_to_s)) {
2538         /* c_to_s and s_to_c will get freed when we free c_ssl */
2539         c_to_s = NULL;
2540         s_to_c = NULL;
2541         goto err;
2542     }
2543     if (!BIO_up_ref(s_to_c)) {
2544         /* s_to_c will get freed when we free c_ssl */
2545         s_to_c = NULL;
2546         goto err;
2547     }
2548
2549     SSL_set_accept_state(s_ssl);
2550     SSL_set_bio(s_ssl, c_to_s, s_to_c);
2551
2552     /* We've used up all our refs to these now */
2553     c_to_s = NULL;
2554     s_to_c = NULL;
2555
2556     SSL_set_max_send_fragment(s_ssl, max_frag);
2557     BIO_set_ssl(s_bio, s_ssl, BIO_NOCLOSE);
2558
2559     c_r = 0;
2560     s_r = 1;
2561     c_w = 1;
2562     s_w = 0;
2563     c_write = 1, s_write = 0;
2564
2565     /* We can always do writes */
2566     for (;;) {
2567         do_server = 0;
2568         do_client = 0;
2569
2570         i = (int)BIO_pending(s_bio);
2571         if ((i && s_r) || s_w)
2572             do_server = 1;
2573
2574         i = (int)BIO_pending(c_bio);
2575         if ((i && c_r) || c_w)
2576             do_client = 1;
2577
2578         if (do_server && debug) {
2579             if (SSL_in_init(s_ssl))
2580                 printf("server waiting in SSL_accept - %s\n",
2581                        SSL_state_string_long(s_ssl));
2582         }
2583
2584         if (do_client && debug) {
2585             if (SSL_in_init(c_ssl))
2586                 printf("client waiting in SSL_connect - %s\n",
2587                        SSL_state_string_long(c_ssl));
2588         }
2589
2590         if (!do_client && !do_server) {
2591             fprintf(stdout, "ERROR IN STARTUP\n");
2592             ERR_print_errors(bio_err);
2593             goto err;
2594         }
2595         if (do_client && !(done & C_DONE)) {
2596             if (c_write) {
2597                 j = (cw_num > bufsiz) ? (int)bufsiz : (int)cw_num;
2598                 i = BIO_write(c_bio, cbuf, j);
2599                 if (i < 0) {
2600                     c_r = 0;
2601                     c_w = 0;
2602                     if (BIO_should_retry(c_bio)) {
2603                         if (BIO_should_read(c_bio))
2604                             c_r = 1;
2605                         if (BIO_should_write(c_bio))
2606                             c_w = 1;
2607                     } else {
2608                         fprintf(stderr, "ERROR in CLIENT\n");
2609                         err_in_client = 1;
2610                         ERR_print_errors(bio_err);
2611                         goto err;
2612                     }
2613                 } else if (i == 0) {
2614                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2615                     goto err;
2616                 } else {
2617                     if (debug)
2618                         printf("client wrote %d\n", i);
2619                     /* ok */
2620                     s_r = 1;
2621                     c_write = 0;
2622                     cw_num -= i;
2623                     if (max_frag > 1029)
2624                         SSL_set_max_send_fragment(c_ssl, max_frag -= 5);
2625                 }
2626             } else {
2627                 i = BIO_read(c_bio, cbuf, bufsiz);
2628                 if (i < 0) {
2629                     c_r = 0;
2630                     c_w = 0;
2631                     if (BIO_should_retry(c_bio)) {
2632                         if (BIO_should_read(c_bio))
2633                             c_r = 1;
2634                         if (BIO_should_write(c_bio))
2635                             c_w = 1;
2636                     } else {
2637                         fprintf(stderr, "ERROR in CLIENT\n");
2638                         err_in_client = 1;
2639                         ERR_print_errors(bio_err);
2640                         goto err;
2641                     }
2642                 } else if (i == 0) {
2643                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2644                     goto err;
2645                 } else {
2646                     if (debug)
2647                         printf("client read %d\n", i);
2648                     cr_num -= i;
2649                     if (sw_num > 0) {
2650                         s_write = 1;
2651                         s_w = 1;
2652                     }
2653                     if (cr_num <= 0) {
2654                         s_write = 1;
2655                         s_w = 1;
2656                         done = S_DONE | C_DONE;
2657                     }
2658                 }
2659             }
2660         }
2661
2662         if (do_server && !(done & S_DONE)) {
2663             if (!s_write) {
2664                 i = BIO_read(s_bio, sbuf, bufsiz);
2665                 if (i < 0) {
2666                     s_r = 0;
2667                     s_w = 0;
2668                     if (BIO_should_retry(s_bio)) {
2669                         if (BIO_should_read(s_bio))
2670                             s_r = 1;
2671                         if (BIO_should_write(s_bio))
2672                             s_w = 1;
2673                     } else {
2674                         fprintf(stderr, "ERROR in SERVER\n");
2675                         err_in_server = 1;
2676                         ERR_print_errors(bio_err);
2677                         goto err;
2678                     }
2679                 } else if (i == 0) {
2680                     ERR_print_errors(bio_err);
2681                     fprintf(stderr,
2682                             "SSL SERVER STARTUP FAILED in SSL_read\n");
2683                     goto err;
2684                 } else {
2685                     if (debug)
2686                         printf("server read %d\n", i);
2687                     sr_num -= i;
2688                     if (cw_num > 0) {
2689                         c_write = 1;
2690                         c_w = 1;
2691                     }
2692                     if (sr_num <= 0) {
2693                         s_write = 1;
2694                         s_w = 1;
2695                         c_write = 0;
2696                     }
2697                 }
2698             } else {
2699                 j = (sw_num > bufsiz) ? (int)bufsiz : (int)sw_num;
2700                 i = BIO_write(s_bio, sbuf, j);
2701                 if (i < 0) {
2702                     s_r = 0;
2703                     s_w = 0;
2704                     if (BIO_should_retry(s_bio)) {
2705                         if (BIO_should_read(s_bio))
2706                             s_r = 1;
2707                         if (BIO_should_write(s_bio))
2708                             s_w = 1;
2709                     } else {
2710                         fprintf(stderr, "ERROR in SERVER\n");
2711                         err_in_server = 1;
2712                         ERR_print_errors(bio_err);
2713                         goto err;
2714                     }
2715                 } else if (i == 0) {
2716                     ERR_print_errors(bio_err);
2717                     fprintf(stderr,
2718                             "SSL SERVER STARTUP FAILED in SSL_write\n");
2719                     goto err;
2720                 } else {
2721                     if (debug)
2722                         printf("server wrote %d\n", i);
2723                     sw_num -= i;
2724                     s_write = 0;
2725                     c_r = 1;
2726                     if (sw_num <= 0)
2727                         done |= S_DONE;
2728                     if (max_frag > 1029)
2729                         SSL_set_max_send_fragment(s_ssl, max_frag -= 5);
2730                 }
2731             }
2732         }
2733
2734         if ((done & S_DONE) && (done & C_DONE))
2735             break;
2736     }
2737
2738     if (verbose)
2739         print_details(c_ssl, "DONE: ");
2740 #ifndef OPENSSL_NO_NEXTPROTONEG
2741     if (verify_npn(c_ssl, s_ssl) < 0)
2742         goto err;
2743 #endif
2744     if (verify_serverinfo() < 0) {
2745         fprintf(stderr, "Server info verify error\n");
2746         goto err;
2747     }
2748     if (custom_ext_error) {
2749         fprintf(stderr, "Custom extension error\n");
2750         goto err;
2751     }
2752     ret = EXIT_SUCCESS;
2753  err:
2754     BIO_free(c_to_s);
2755     BIO_free(s_to_c);
2756     BIO_free_all(c_bio);
2757     BIO_free_all(s_bio);
2758     OPENSSL_free(cbuf);
2759     OPENSSL_free(sbuf);
2760
2761     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2762         ret = (err_in_client != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2763     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2764         ret = (err_in_server != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2765
2766     return ret;
2767 }
2768
2769 static int verify_callback(int ok, X509_STORE_CTX *ctx)
2770 {
2771     char *s, buf[256];
2772
2773     s = X509_NAME_oneline(X509_get_subject_name(X509_STORE_CTX_get_current_cert(ctx)),
2774                           buf, sizeof(buf));
2775     if (s != NULL) {
2776         if (ok)
2777             printf("depth=%d %s\n", X509_STORE_CTX_get_error_depth(ctx), buf);
2778         else {
2779             fprintf(stderr, "depth=%d error=%d %s\n",
2780                     X509_STORE_CTX_get_error_depth(ctx),
2781                     X509_STORE_CTX_get_error(ctx), buf);
2782         }
2783     }
2784
2785     if (ok == 0) {
2786         int i = X509_STORE_CTX_get_error(ctx);
2787
2788         switch (i) {
2789         default:
2790             fprintf(stderr, "Error string: %s\n",
2791                     X509_verify_cert_error_string(i));
2792             break;
2793         case X509_V_ERR_CERT_NOT_YET_VALID:
2794         case X509_V_ERR_CERT_HAS_EXPIRED:
2795         case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2796             ok = 1;
2797             break;
2798         }
2799     }
2800
2801     return ok;
2802 }
2803
2804 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2805 {
2806     int ok = 1;
2807     struct app_verify_arg *cb_arg = arg;
2808
2809     if (cb_arg->app_verify) {
2810         char *s = NULL, buf[256];
2811         X509 *c = X509_STORE_CTX_get0_cert(ctx);
2812
2813         printf("In app_verify_callback, allowing cert. ");
2814         printf("Arg is: %s\n", cb_arg->string);
2815         printf("Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2816                 (void *)ctx, (void *)c);
2817         if (c)
2818             s = X509_NAME_oneline(X509_get_subject_name(c), buf, 256);
2819         if (s != NULL) {
2820             printf("cert depth=%d %s\n",
2821                     X509_STORE_CTX_get_error_depth(ctx), buf);
2822         }
2823         return 1;
2824     }
2825
2826     ok = X509_verify_cert(ctx);
2827
2828     return ok;
2829 }
2830
2831 #ifndef OPENSSL_NO_DH
2832 /*-
2833  * These DH parameters have been generated as follows:
2834  *    $ openssl dhparam -C -noout 512
2835  *    $ openssl dhparam -C -noout 1024
2836  *    $ openssl dhparam -C -noout -dsaparam 1024
2837  * (The third function has been renamed to avoid name conflicts.)
2838  */
2839 static DH *get_dh512()
2840 {
2841     static unsigned char dh512_p[] = {
2842         0xCB, 0xC8, 0xE1, 0x86, 0xD0, 0x1F, 0x94, 0x17, 0xA6, 0x99, 0xF0,
2843         0xC6,
2844         0x1F, 0x0D, 0xAC, 0xB6, 0x25, 0x3E, 0x06, 0x39, 0xCA, 0x72, 0x04,
2845         0xB0,
2846         0x6E, 0xDA, 0xC0, 0x61, 0xE6, 0x7A, 0x77, 0x25, 0xE8, 0x3B, 0xB9,
2847         0x5F,
2848         0x9A, 0xB6, 0xB5, 0xFE, 0x99, 0x0B, 0xA1, 0x93, 0x4E, 0x35, 0x33,
2849         0xB8,
2850         0xE1, 0xF1, 0x13, 0x4F, 0x59, 0x1A, 0xD2, 0x57, 0xC0, 0x26, 0x21,
2851         0x33,
2852         0x02, 0xC5, 0xAE, 0x23,
2853     };
2854     static unsigned char dh512_g[] = {
2855         0x02,
2856     };
2857     DH *dh;
2858     BIGNUM *p, *g;
2859
2860     if ((dh = DH_new()) == NULL)
2861         return NULL;
2862     p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
2863     g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
2864     if ((p == NULL) || (g == NULL) || !DH_set0_pqg(dh, p, NULL, g)) {
2865         DH_free(dh);
2866         BN_free(p);
2867         BN_free(g);
2868         return NULL;
2869     }
2870     return dh;
2871 }
2872
2873 static DH *get_dh1024()
2874 {
2875     static unsigned char dh1024_p[] = {
2876         0xF8, 0x81, 0x89, 0x7D, 0x14, 0x24, 0xC5, 0xD1, 0xE6, 0xF7, 0xBF,
2877         0x3A,
2878         0xE4, 0x90, 0xF4, 0xFC, 0x73, 0xFB, 0x34, 0xB5, 0xFA, 0x4C, 0x56,
2879         0xA2,
2880         0xEA, 0xA7, 0xE9, 0xC0, 0xC0, 0xCE, 0x89, 0xE1, 0xFA, 0x63, 0x3F,
2881         0xB0,
2882         0x6B, 0x32, 0x66, 0xF1, 0xD1, 0x7B, 0xB0, 0x00, 0x8F, 0xCA, 0x87,
2883         0xC2,
2884         0xAE, 0x98, 0x89, 0x26, 0x17, 0xC2, 0x05, 0xD2, 0xEC, 0x08, 0xD0,
2885         0x8C,
2886         0xFF, 0x17, 0x52, 0x8C, 0xC5, 0x07, 0x93, 0x03, 0xB1, 0xF6, 0x2F,
2887         0xB8,
2888         0x1C, 0x52, 0x47, 0x27, 0x1B, 0xDB, 0xD1, 0x8D, 0x9D, 0x69, 0x1D,
2889         0x52,
2890         0x4B, 0x32, 0x81, 0xAA, 0x7F, 0x00, 0xC8, 0xDC, 0xE6, 0xD9, 0xCC,
2891         0xC1,
2892         0x11, 0x2D, 0x37, 0x34, 0x6C, 0xEA, 0x02, 0x97, 0x4B, 0x0E, 0xBB,
2893         0xB1,
2894         0x71, 0x33, 0x09, 0x15, 0xFD, 0xDD, 0x23, 0x87, 0x07, 0x5E, 0x89,
2895         0xAB,
2896         0x6B, 0x7C, 0x5F, 0xEC, 0xA6, 0x24, 0xDC, 0x53,
2897     };
2898     static unsigned char dh1024_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(dh1024_p, sizeof(dh1024_p), NULL);
2907     g = BN_bin2bn(dh1024_g, sizeof(dh1024_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_dh1024dsa()
2918 {
2919     static unsigned char dh1024_p[] = {
2920         0xC8, 0x00, 0xF7, 0x08, 0x07, 0x89, 0x4D, 0x90, 0x53, 0xF3, 0xD5,
2921         0x00,
2922         0x21, 0x1B, 0xF7, 0x31, 0xA6, 0xA2, 0xDA, 0x23, 0x9A, 0xC7, 0x87,
2923         0x19,
2924         0x3B, 0x47, 0xB6, 0x8C, 0x04, 0x6F, 0xFF, 0xC6, 0x9B, 0xB8, 0x65,
2925         0xD2,
2926         0xC2, 0x5F, 0x31, 0x83, 0x4A, 0xA7, 0x5F, 0x2F, 0x88, 0x38, 0xB6,
2927         0x55,
2928         0xCF, 0xD9, 0x87, 0x6D, 0x6F, 0x9F, 0xDA, 0xAC, 0xA6, 0x48, 0xAF,
2929         0xFC,
2930         0x33, 0x84, 0x37, 0x5B, 0x82, 0x4A, 0x31, 0x5D, 0xE7, 0xBD, 0x52,
2931         0x97,
2932         0xA1, 0x77, 0xBF, 0x10, 0x9E, 0x37, 0xEA, 0x64, 0xFA, 0xCA, 0x28,
2933         0x8D,
2934         0x9D, 0x3B, 0xD2, 0x6E, 0x09, 0x5C, 0x68, 0xC7, 0x45, 0x90, 0xFD,
2935         0xBB,
2936         0x70, 0xC9, 0x3A, 0xBB, 0xDF, 0xD4, 0x21, 0x0F, 0xC4, 0x6A, 0x3C,
2937         0xF6,
2938         0x61, 0xCF, 0x3F, 0xD6, 0x13, 0xF1, 0x5F, 0xBC, 0xCF, 0xBC, 0x26,
2939         0x9E,
2940         0xBC, 0x0B, 0xBD, 0xAB, 0x5D, 0xC9, 0x54, 0x39,
2941     };
2942     static unsigned char dh1024_g[] = {
2943         0x3B, 0x40, 0x86, 0xE7, 0xF3, 0x6C, 0xDE, 0x67, 0x1C, 0xCC, 0x80,
2944         0x05,
2945         0x5A, 0xDF, 0xFE, 0xBD, 0x20, 0x27, 0x74, 0x6C, 0x24, 0xC9, 0x03,
2946         0xF3,
2947         0xE1, 0x8D, 0xC3, 0x7D, 0x98, 0x27, 0x40, 0x08, 0xB8, 0x8C, 0x6A,
2948         0xE9,
2949         0xBB, 0x1A, 0x3A, 0xD6, 0x86, 0x83, 0x5E, 0x72, 0x41, 0xCE, 0x85,
2950         0x3C,
2951         0xD2, 0xB3, 0xFC, 0x13, 0xCE, 0x37, 0x81, 0x9E, 0x4C, 0x1C, 0x7B,
2952         0x65,
2953         0xD3, 0xE6, 0xA6, 0x00, 0xF5, 0x5A, 0x95, 0x43, 0x5E, 0x81, 0xCF,
2954         0x60,
2955         0xA2, 0x23, 0xFC, 0x36, 0xA7, 0x5D, 0x7A, 0x4C, 0x06, 0x91, 0x6E,
2956         0xF6,
2957         0x57, 0xEE, 0x36, 0xCB, 0x06, 0xEA, 0xF5, 0x3D, 0x95, 0x49, 0xCB,
2958         0xA7,
2959         0xDD, 0x81, 0xDF, 0x80, 0x09, 0x4A, 0x97, 0x4D, 0xA8, 0x22, 0x72,
2960         0xA1,
2961         0x7F, 0xC4, 0x70, 0x56, 0x70, 0xE8, 0x20, 0x10, 0x18, 0x8F, 0x2E,
2962         0x60,
2963         0x07, 0xE7, 0x68, 0x1A, 0x82, 0x5D, 0x32, 0xA2,
2964     };
2965     DH *dh;
2966     BIGNUM *p, *g;
2967
2968     if ((dh = DH_new()) == NULL)
2969         return NULL;
2970     p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
2971     g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
2972     if ((p == NULL) || (g == NULL) || !DH_set0_pqg(dh, p, NULL, g)) {
2973         DH_free(dh);
2974         BN_free(p);
2975         BN_free(g);
2976         return NULL;
2977     }
2978     DH_set_length(dh, 160);
2979     return dh;
2980 }
2981 #endif
2982
2983 #ifndef OPENSSL_NO_PSK
2984 /* convert the PSK key (psk_key) in ascii to binary (psk) */
2985 static int psk_key2bn(const char *pskkey, unsigned char *psk,
2986                       unsigned int max_psk_len)
2987 {
2988     int ret;
2989     BIGNUM *bn = NULL;
2990
2991     ret = BN_hex2bn(&bn, pskkey);
2992     if (!ret) {
2993         BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
2994                    pskkey);
2995         BN_free(bn);
2996         return 0;
2997     }
2998     if (BN_num_bytes(bn) > (int)max_psk_len) {
2999         BIO_printf(bio_err,
3000                    "psk buffer of callback is too small (%d) for key (%d)\n",
3001                    max_psk_len, BN_num_bytes(bn));
3002         BN_free(bn);
3003         return 0;
3004     }
3005     ret = BN_bn2bin(bn, psk);
3006     BN_free(bn);
3007     return ret;
3008 }
3009
3010 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
3011                                         char *identity,
3012                                         unsigned int max_identity_len,
3013                                         unsigned char *psk,
3014                                         unsigned int max_psk_len)
3015 {
3016     int ret;
3017     unsigned int psk_len = 0;
3018
3019     ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3020     if (ret < 0)
3021         goto out_err;
3022     if (debug)
3023         fprintf(stderr, "client: created identity '%s' len=%d\n", identity,
3024                 ret);
3025     ret = psk_key2bn(psk_key, psk, max_psk_len);
3026     if (ret < 0)
3027         goto out_err;
3028     psk_len = ret;
3029  out_err:
3030     return psk_len;
3031 }
3032
3033 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3034                                         unsigned char *psk,
3035                                         unsigned int max_psk_len)
3036 {
3037     unsigned int psk_len = 0;
3038
3039     if (strcmp(identity, "Client_identity") != 0) {
3040         BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3041         return 0;
3042     }
3043     psk_len = psk_key2bn(psk_key, psk, max_psk_len);
3044     return psk_len;
3045 }
3046 #endif