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("0");
1840     if (acpt == NULL)
1841         goto err;
1842     BIO_set_accept_ip_family(acpt, family);
1843     BIO_set_bind_mode(acpt, BIO_SOCK_NONBLOCK | BIO_SOCK_REUSEADDR);
1844     if (BIO_do_accept(acpt) <= 0)
1845         goto err;
1846
1847     BIO_snprintf(addr_str, sizeof(addr_str), ":%s", BIO_get_accept_port(acpt));
1848
1849     client = BIO_new_connect(addr_str);
1850     BIO_set_conn_ip_family(client, family);
1851     if (!client)
1852         goto err;
1853
1854     if (BIO_set_nbio(client, 1) <= 0)
1855         goto err;
1856     if (BIO_set_nbio(acpt, 1) <= 0)
1857         goto err;
1858
1859     {
1860         int st_connect = 0, st_accept = 0;
1861
1862         while(!st_connect || !st_accept) {
1863             if (!st_connect) {
1864                 if (BIO_do_connect(client) <= 0) {
1865                     if (!BIO_should_retry(client))
1866                         goto err;
1867                 } else {
1868                     st_connect = 1;
1869                 }
1870             }
1871             if (!st_accept) {
1872                 if (BIO_do_accept(acpt) <= 0) {
1873                     if (!BIO_should_retry(acpt))
1874                         goto err;
1875                 } else {
1876                     st_accept = 1;
1877                 }
1878             }
1879         }
1880     }
1881     /* We're not interested in accepting further connects */
1882     server = BIO_pop(acpt);
1883     BIO_free_all(acpt);
1884     acpt = NULL;
1885
1886     s_ssl_bio = BIO_new(BIO_f_ssl());
1887     if (!s_ssl_bio)
1888         goto err;
1889
1890     c_ssl_bio = BIO_new(BIO_f_ssl());
1891     if (!c_ssl_bio)
1892         goto err;
1893
1894     SSL_set_connect_state(c_ssl);
1895     SSL_set_bio(c_ssl, client, client);
1896     (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1897
1898     SSL_set_accept_state(s_ssl);
1899     SSL_set_bio(s_ssl, server, server);
1900     (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1901
1902     do {
1903         /*-
1904          * c_ssl_bio:          SSL filter BIO
1905          *
1906          * client:             I/O for SSL library
1907          *
1908          *
1909          * server:             I/O for SSL library
1910          *
1911          * s_ssl_bio:          SSL filter BIO
1912          */
1913
1914         /*
1915          * We have non-blocking behaviour throughout this test program, but
1916          * can be sure that there is *some* progress in each iteration; so we
1917          * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
1918          * we just try everything in each iteration
1919          */
1920
1921         {
1922             /* CLIENT */
1923
1924             char cbuf[1024 * 8];
1925             int i, r;
1926             clock_t c_clock = clock();
1927
1928             memset(cbuf, 0, sizeof(cbuf));
1929
1930             if (debug)
1931                 if (SSL_in_init(c_ssl))
1932                     printf("client waiting in SSL_connect - %s\n",
1933                            SSL_state_string_long(c_ssl));
1934
1935             if (cw_num > 0) {
1936                 /* Write to server. */
1937
1938                 if (cw_num > (long)sizeof(cbuf))
1939                     i = sizeof(cbuf);
1940                 else
1941                     i = (int)cw_num;
1942                 r = BIO_write(c_ssl_bio, cbuf, i);
1943                 if (r < 0) {
1944                     if (!BIO_should_retry(c_ssl_bio)) {
1945                         fprintf(stderr, "ERROR in CLIENT\n");
1946                         err_in_client = 1;
1947                         goto err;
1948                     }
1949                     /*
1950                      * BIO_should_retry(...) can just be ignored here. The
1951                      * library expects us to call BIO_write with the same
1952                      * arguments again, and that's what we will do in the
1953                      * next iteration.
1954                      */
1955                 } else if (r == 0) {
1956                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1957                     goto err;
1958                 } else {
1959                     if (debug)
1960                         printf("client wrote %d\n", r);
1961                     cw_num -= r;
1962                 }
1963             }
1964
1965             if (cr_num > 0) {
1966                 /* Read from server. */
1967
1968                 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1969                 if (r < 0) {
1970                     if (!BIO_should_retry(c_ssl_bio)) {
1971                         fprintf(stderr, "ERROR in CLIENT\n");
1972                         err_in_client = 1;
1973                         goto err;
1974                     }
1975                     /*
1976                      * Again, "BIO_should_retry" can be ignored.
1977                      */
1978                 } else if (r == 0) {
1979                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1980                     goto err;
1981                 } else {
1982                     if (debug)
1983                         printf("client read %d\n", r);
1984                     cr_num -= r;
1985                 }
1986             }
1987
1988             /*
1989              * c_time and s_time increments will typically be very small
1990              * (depending on machine speed and clock tick intervals), but
1991              * sampling over a large number of connections should result in
1992              * fairly accurate figures.  We cannot guarantee a lot, however
1993              * -- if each connection lasts for exactly one clock tick, it
1994              * will be counted only for the client or only for the server or
1995              * even not at all.
1996              */
1997             *c_time += (clock() - c_clock);
1998         }
1999
2000         {
2001             /* SERVER */
2002
2003             char sbuf[1024 * 8];
2004             int i, r;
2005             clock_t s_clock = clock();
2006
2007             memset(sbuf, 0, sizeof(sbuf));
2008
2009             if (debug)
2010                 if (SSL_in_init(s_ssl))
2011                     printf("server waiting in SSL_accept - %s\n",
2012                            SSL_state_string_long(s_ssl));
2013
2014             if (sw_num > 0) {
2015                 /* Write to client. */
2016
2017                 if (sw_num > (long)sizeof(sbuf))
2018                     i = sizeof(sbuf);
2019                 else
2020                     i = (int)sw_num;
2021                 r = BIO_write(s_ssl_bio, sbuf, i);
2022                 if (r < 0) {
2023                     if (!BIO_should_retry(s_ssl_bio)) {
2024                         fprintf(stderr, "ERROR in SERVER\n");
2025                         err_in_server = 1;
2026                         goto err;
2027                     }
2028                     /* Ignore "BIO_should_retry". */
2029                 } else if (r == 0) {
2030                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2031                     goto err;
2032                 } else {
2033                     if (debug)
2034                         printf("server wrote %d\n", r);
2035                     sw_num -= r;
2036                 }
2037             }
2038
2039             if (sr_num > 0) {
2040                 /* Read from client. */
2041
2042                 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2043                 if (r < 0) {
2044                     if (!BIO_should_retry(s_ssl_bio)) {
2045                         fprintf(stderr, "ERROR in SERVER\n");
2046                         err_in_server = 1;
2047                         goto err;
2048                     }
2049                     /* blah, blah */
2050                 } else if (r == 0) {
2051                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2052                     goto err;
2053                 } else {
2054                     if (debug)
2055                         printf("server read %d\n", r);
2056                     sr_num -= r;
2057                 }
2058             }
2059
2060             *s_time += (clock() - s_clock);
2061         }
2062     }
2063     while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2064
2065     if (verbose)
2066         print_details(c_ssl, "DONE via TCP connect: ");
2067 # ifndef OPENSSL_NO_NEXTPROTONEG
2068     if (verify_npn(c_ssl, s_ssl) < 0)
2069         goto end;
2070 # endif
2071     if (verify_serverinfo() < 0) {
2072         fprintf(stderr, "Server info verify error\n");
2073         goto err;
2074     }
2075     if (verify_alpn(c_ssl, s_ssl) < 0
2076             || verify_servername(c_ssl, s_ssl) < 0)
2077         goto err;
2078
2079     if (custom_ext_error) {
2080         fprintf(stderr, "Custom extension error\n");
2081         goto err;
2082     }
2083
2084 # ifndef OPENSSL_NO_NEXTPROTONEG
2085  end:
2086 # endif
2087     ret = EXIT_SUCCESS;
2088
2089  err:
2090     ERR_print_errors(bio_err);
2091
2092     BIO_free_all(acpt);
2093     BIO_free(server);
2094     BIO_free(client);
2095     BIO_free(s_ssl_bio);
2096     BIO_free(c_ssl_bio);
2097
2098     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2099         ret = (err_in_client != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2100     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2101         ret = (err_in_server != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2102
2103     return ret;
2104 }
2105 #endif
2106
2107 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
2108                  clock_t *s_time, clock_t *c_time)
2109 {
2110     long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
2111     BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
2112     BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
2113     int ret = EXIT_FAILURE;
2114     int err_in_client = 0;
2115     int err_in_server = 0;
2116
2117     size_t bufsiz = 256;        /* small buffer for testing */
2118
2119     if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
2120         goto err;
2121     if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
2122         goto err;
2123
2124     s_ssl_bio = BIO_new(BIO_f_ssl());
2125     if (!s_ssl_bio)
2126         goto err;
2127
2128     c_ssl_bio = BIO_new(BIO_f_ssl());
2129     if (!c_ssl_bio)
2130         goto err;
2131
2132     SSL_set_connect_state(c_ssl);
2133     SSL_set_bio(c_ssl, client, client);
2134     (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
2135
2136     SSL_set_accept_state(s_ssl);
2137     SSL_set_bio(s_ssl, server, server);
2138     (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
2139
2140     do {
2141         /*-
2142          * c_ssl_bio:          SSL filter BIO
2143          *
2144          * client:             pseudo-I/O for SSL library
2145          *
2146          * client_io:          client's SSL communication; usually to be
2147          *                     relayed over some I/O facility, but in this
2148          *                     test program, we're the server, too:
2149          *
2150          * server_io:          server's SSL communication
2151          *
2152          * server:             pseudo-I/O for SSL library
2153          *
2154          * s_ssl_bio:          SSL filter BIO
2155          *
2156          * The client and the server each employ a "BIO pair":
2157          * client + client_io, server + server_io.
2158          * BIO pairs are symmetric.  A BIO pair behaves similar
2159          * to a non-blocking socketpair (but both endpoints must
2160          * be handled by the same thread).
2161          * [Here we could connect client and server to the ends
2162          * of a single BIO pair, but then this code would be less
2163          * suitable as an example for BIO pairs in general.]
2164          *
2165          * Useful functions for querying the state of BIO pair endpoints:
2166          *
2167          * BIO_ctrl_pending(bio)              number of bytes we can read now
2168          * BIO_ctrl_get_read_request(bio)     number of bytes needed to fulfill
2169          *                                      other side's read attempt
2170          * BIO_ctrl_get_write_guarantee(bio)   number of bytes we can write now
2171          *
2172          * ..._read_request is never more than ..._write_guarantee;
2173          * it depends on the application which one you should use.
2174          */
2175
2176         /*
2177          * We have non-blocking behaviour throughout this test program, but
2178          * can be sure that there is *some* progress in each iteration; so we
2179          * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
2180          * we just try everything in each iteration
2181          */
2182
2183         {
2184             /* CLIENT */
2185
2186             char cbuf[1024 * 8];
2187             int i, r;
2188             clock_t c_clock = clock();
2189
2190             memset(cbuf, 0, sizeof(cbuf));
2191
2192             if (debug)
2193                 if (SSL_in_init(c_ssl))
2194                     printf("client waiting in SSL_connect - %s\n",
2195                            SSL_state_string_long(c_ssl));
2196
2197             if (cw_num > 0) {
2198                 /* Write to server. */
2199
2200                 if (cw_num > (long)sizeof(cbuf))
2201                     i = sizeof(cbuf);
2202                 else
2203                     i = (int)cw_num;
2204                 r = BIO_write(c_ssl_bio, cbuf, i);
2205                 if (r < 0) {
2206                     if (!BIO_should_retry(c_ssl_bio)) {
2207                         fprintf(stderr, "ERROR in CLIENT\n");
2208                         err_in_client = 1;
2209                         goto err;
2210                     }
2211                     /*
2212                      * BIO_should_retry(...) can just be ignored here. The
2213                      * library expects us to call BIO_write with the same
2214                      * arguments again, and that's what we will do in the
2215                      * next iteration.
2216                      */
2217                 } else if (r == 0) {
2218                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2219                     goto err;
2220                 } else {
2221                     if (debug)
2222                         printf("client wrote %d\n", r);
2223                     cw_num -= r;
2224                 }
2225             }
2226
2227             if (cr_num > 0) {
2228                 /* Read from server. */
2229
2230                 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
2231                 if (r < 0) {
2232                     if (!BIO_should_retry(c_ssl_bio)) {
2233                         fprintf(stderr, "ERROR in CLIENT\n");
2234                         err_in_client = 1;
2235                         goto err;
2236                     }
2237                     /*
2238                      * Again, "BIO_should_retry" can be ignored.
2239                      */
2240                 } else if (r == 0) {
2241                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2242                     goto err;
2243                 } else {
2244                     if (debug)
2245                         printf("client read %d\n", r);
2246                     cr_num -= r;
2247                 }
2248             }
2249
2250             /*
2251              * c_time and s_time increments will typically be very small
2252              * (depending on machine speed and clock tick intervals), but
2253              * sampling over a large number of connections should result in
2254              * fairly accurate figures.  We cannot guarantee a lot, however
2255              * -- if each connection lasts for exactly one clock tick, it
2256              * will be counted only for the client or only for the server or
2257              * even not at all.
2258              */
2259             *c_time += (clock() - c_clock);
2260         }
2261
2262         {
2263             /* SERVER */
2264
2265             char sbuf[1024 * 8];
2266             int i, r;
2267             clock_t s_clock = clock();
2268
2269             memset(sbuf, 0, sizeof(sbuf));
2270
2271             if (debug)
2272                 if (SSL_in_init(s_ssl))
2273                     printf("server waiting in SSL_accept - %s\n",
2274                            SSL_state_string_long(s_ssl));
2275
2276             if (sw_num > 0) {
2277                 /* Write to client. */
2278
2279                 if (sw_num > (long)sizeof(sbuf))
2280                     i = sizeof(sbuf);
2281                 else
2282                     i = (int)sw_num;
2283                 r = BIO_write(s_ssl_bio, sbuf, i);
2284                 if (r < 0) {
2285                     if (!BIO_should_retry(s_ssl_bio)) {
2286                         fprintf(stderr, "ERROR in SERVER\n");
2287                         err_in_server = 1;
2288                         goto err;
2289                     }
2290                     /* Ignore "BIO_should_retry". */
2291                 } else if (r == 0) {
2292                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2293                     goto err;
2294                 } else {
2295                     if (debug)
2296                         printf("server wrote %d\n", r);
2297                     sw_num -= r;
2298                 }
2299             }
2300
2301             if (sr_num > 0) {
2302                 /* Read from client. */
2303
2304                 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2305                 if (r < 0) {
2306                     if (!BIO_should_retry(s_ssl_bio)) {
2307                         fprintf(stderr, "ERROR in SERVER\n");
2308                         err_in_server = 1;
2309                         goto err;
2310                     }
2311                     /* blah, blah */
2312                 } else if (r == 0) {
2313                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2314                     goto err;
2315                 } else {
2316                     if (debug)
2317                         printf("server read %d\n", r);
2318                     sr_num -= r;
2319                 }
2320             }
2321
2322             *s_time += (clock() - s_clock);
2323         }
2324
2325         {
2326             /* "I/O" BETWEEN CLIENT AND SERVER. */
2327
2328             size_t r1, r2;
2329             BIO *io1 = server_io, *io2 = client_io;
2330             /*
2331              * we use the non-copying interface for io1 and the standard
2332              * BIO_write/BIO_read interface for io2
2333              */
2334
2335             static int prev_progress = 1;
2336             int progress = 0;
2337
2338             /* io1 to io2 */
2339             do {
2340                 size_t num;
2341                 int r;
2342
2343                 r1 = BIO_ctrl_pending(io1);
2344                 r2 = BIO_ctrl_get_write_guarantee(io2);
2345
2346                 num = r1;
2347                 if (r2 < num)
2348                     num = r2;
2349                 if (num) {
2350                     char *dataptr;
2351
2352                     if (INT_MAX < num) /* yeah, right */
2353                         num = INT_MAX;
2354
2355                     r = BIO_nread(io1, &dataptr, (int)num);
2356                     assert(r > 0);
2357                     assert(r <= (int)num);
2358                     /*
2359                      * possibly r < num (non-contiguous data)
2360                      */
2361                     num = r;
2362                     r = BIO_write(io2, dataptr, (int)num);
2363                     if (r != (int)num) { /* can't happen */
2364                         fprintf(stderr, "ERROR: BIO_write could not write "
2365                                 "BIO_ctrl_get_write_guarantee() bytes");
2366                         goto err;
2367                     }
2368                     progress = 1;
2369
2370                     if (debug)
2371                         printf((io1 == client_io) ?
2372                                "C->S relaying: %d bytes\n" :
2373                                "S->C relaying: %d bytes\n", (int)num);
2374                 }
2375             }
2376             while (r1 && r2);
2377
2378             /* io2 to io1 */
2379             {
2380                 size_t num;
2381                 int r;
2382
2383                 r1 = BIO_ctrl_pending(io2);
2384                 r2 = BIO_ctrl_get_read_request(io1);
2385                 /*
2386                  * here we could use ..._get_write_guarantee instead of
2387                  * ..._get_read_request, but by using the latter we test
2388                  * restartability of the SSL implementation more thoroughly
2389                  */
2390                 num = r1;
2391                 if (r2 < num)
2392                     num = r2;
2393                 if (num) {
2394                     char *dataptr;
2395
2396                     if (INT_MAX < num)
2397                         num = INT_MAX;
2398
2399                     if (num > 1)
2400                         --num;  /* test restartability even more thoroughly */
2401
2402                     r = BIO_nwrite0(io1, &dataptr);
2403                     assert(r > 0);
2404                     if (r < (int)num)
2405                         num = r;
2406                     r = BIO_read(io2, dataptr, (int)num);
2407                     if (r != (int)num) { /* can't happen */
2408                         fprintf(stderr, "ERROR: BIO_read could not read "
2409                                 "BIO_ctrl_pending() bytes");
2410                         goto err;
2411                     }
2412                     progress = 1;
2413                     r = BIO_nwrite(io1, &dataptr, (int)num);
2414                     if (r != (int)num) { /* can't happen */
2415                         fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
2416                                 "BIO_nwrite0() bytes");
2417                         goto err;
2418                     }
2419
2420                     if (debug)
2421                         printf((io2 == client_io) ?
2422                                "C->S relaying: %d bytes\n" :
2423                                "S->C relaying: %d bytes\n", (int)num);
2424                 }
2425             }                   /* no loop, BIO_ctrl_get_read_request now
2426                                  * returns 0 anyway */
2427
2428             if (!progress && !prev_progress)
2429                 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0) {
2430                     fprintf(stderr, "ERROR: got stuck\n");
2431                     fprintf(stderr, " ERROR.\n");
2432                     goto err;
2433                 }
2434             prev_progress = progress;
2435         }
2436     }
2437     while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2438
2439     if (verbose)
2440         print_details(c_ssl, "DONE via BIO pair: ");
2441 #ifndef OPENSSL_NO_NEXTPROTONEG
2442     if (verify_npn(c_ssl, s_ssl) < 0)
2443         goto end;
2444 #endif
2445     if (verify_serverinfo() < 0) {
2446         fprintf(stderr, "Server info verify error\n");
2447         goto err;
2448     }
2449     if (verify_alpn(c_ssl, s_ssl) < 0
2450             || verify_servername(c_ssl, s_ssl) < 0)
2451         goto err;
2452
2453     if (custom_ext_error) {
2454         fprintf(stderr, "Custom extension error\n");
2455         goto err;
2456     }
2457
2458 #ifndef OPENSSL_NO_NEXTPROTONEG
2459  end:
2460 #endif
2461     ret = EXIT_SUCCESS;
2462
2463  err:
2464     ERR_print_errors(bio_err);
2465
2466     BIO_free(server);
2467     BIO_free(server_io);
2468     BIO_free(client);
2469     BIO_free(client_io);
2470     BIO_free(s_ssl_bio);
2471     BIO_free(c_ssl_bio);
2472
2473     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2474         ret = (err_in_client != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2475     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2476         ret = (err_in_server != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2477
2478     return ret;
2479 }
2480
2481 #define W_READ  1
2482 #define W_WRITE 2
2483 #define C_DONE  1
2484 #define S_DONE  2
2485
2486 int doit(SSL *s_ssl, SSL *c_ssl, long count)
2487 {
2488     char *cbuf = NULL, *sbuf = NULL;
2489     long bufsiz;
2490     long cw_num = count, cr_num = count;
2491     long sw_num = count, sr_num = count;
2492     int ret = EXIT_FAILURE;
2493     BIO *c_to_s = NULL;
2494     BIO *s_to_c = NULL;
2495     BIO *c_bio = NULL;
2496     BIO *s_bio = NULL;
2497     int c_r, c_w, s_r, s_w;
2498     int i, j;
2499     int done = 0;
2500     int c_write, s_write;
2501     int do_server = 0, do_client = 0;
2502     int max_frag = 5 * 1024;
2503     int err_in_client = 0;
2504     int err_in_server = 0;
2505
2506     bufsiz = count > 40 * 1024 ? 40 * 1024 : count;
2507
2508     if ((cbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2509         goto err;
2510     if ((sbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2511         goto err;
2512
2513     c_to_s = BIO_new(BIO_s_mem());
2514     s_to_c = BIO_new(BIO_s_mem());
2515     if ((s_to_c == NULL) || (c_to_s == NULL)) {
2516         ERR_print_errors(bio_err);
2517         goto err;
2518     }
2519
2520     c_bio = BIO_new(BIO_f_ssl());
2521     s_bio = BIO_new(BIO_f_ssl());
2522     if ((c_bio == NULL) || (s_bio == NULL)) {
2523         ERR_print_errors(bio_err);
2524         goto err;
2525     }
2526
2527     SSL_set_connect_state(c_ssl);
2528     SSL_set_bio(c_ssl, s_to_c, c_to_s);
2529     SSL_set_max_send_fragment(c_ssl, max_frag);
2530     BIO_set_ssl(c_bio, c_ssl, BIO_NOCLOSE);
2531
2532     /*
2533      * We've just given our ref to these BIOs to c_ssl. We need another one to
2534      * give to s_ssl
2535      */
2536     if (!BIO_up_ref(c_to_s)) {
2537         /* c_to_s and s_to_c will get freed when we free c_ssl */
2538         c_to_s = NULL;
2539         s_to_c = NULL;
2540         goto err;
2541     }
2542     if (!BIO_up_ref(s_to_c)) {
2543         /* s_to_c will get freed when we free c_ssl */
2544         s_to_c = NULL;
2545         goto err;
2546     }
2547
2548     SSL_set_accept_state(s_ssl);
2549     SSL_set_bio(s_ssl, c_to_s, s_to_c);
2550
2551     /* We've used up all our refs to these now */
2552     c_to_s = NULL;
2553     s_to_c = NULL;
2554
2555     SSL_set_max_send_fragment(s_ssl, max_frag);
2556     BIO_set_ssl(s_bio, s_ssl, BIO_NOCLOSE);
2557
2558     c_r = 0;
2559     s_r = 1;
2560     c_w = 1;
2561     s_w = 0;
2562     c_write = 1, s_write = 0;
2563
2564     /* We can always do writes */
2565     for (;;) {
2566         do_server = 0;
2567         do_client = 0;
2568
2569         i = (int)BIO_pending(s_bio);
2570         if ((i && s_r) || s_w)
2571             do_server = 1;
2572
2573         i = (int)BIO_pending(c_bio);
2574         if ((i && c_r) || c_w)
2575             do_client = 1;
2576
2577         if (do_server && debug) {
2578             if (SSL_in_init(s_ssl))
2579                 printf("server waiting in SSL_accept - %s\n",
2580                        SSL_state_string_long(s_ssl));
2581         }
2582
2583         if (do_client && debug) {
2584             if (SSL_in_init(c_ssl))
2585                 printf("client waiting in SSL_connect - %s\n",
2586                        SSL_state_string_long(c_ssl));
2587         }
2588
2589         if (!do_client && !do_server) {
2590             fprintf(stdout, "ERROR IN STARTUP\n");
2591             ERR_print_errors(bio_err);
2592             goto err;
2593         }
2594         if (do_client && !(done & C_DONE)) {
2595             if (c_write) {
2596                 j = (cw_num > bufsiz) ? (int)bufsiz : (int)cw_num;
2597                 i = BIO_write(c_bio, cbuf, j);
2598                 if (i < 0) {
2599                     c_r = 0;
2600                     c_w = 0;
2601                     if (BIO_should_retry(c_bio)) {
2602                         if (BIO_should_read(c_bio))
2603                             c_r = 1;
2604                         if (BIO_should_write(c_bio))
2605                             c_w = 1;
2606                     } else {
2607                         fprintf(stderr, "ERROR in CLIENT\n");
2608                         err_in_client = 1;
2609                         ERR_print_errors(bio_err);
2610                         goto err;
2611                     }
2612                 } else if (i == 0) {
2613                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2614                     goto err;
2615                 } else {
2616                     if (debug)
2617                         printf("client wrote %d\n", i);
2618                     /* ok */
2619                     s_r = 1;
2620                     c_write = 0;
2621                     cw_num -= i;
2622                     if (max_frag > 1029)
2623                         SSL_set_max_send_fragment(c_ssl, max_frag -= 5);
2624                 }
2625             } else {
2626                 i = BIO_read(c_bio, cbuf, bufsiz);
2627                 if (i < 0) {
2628                     c_r = 0;
2629                     c_w = 0;
2630                     if (BIO_should_retry(c_bio)) {
2631                         if (BIO_should_read(c_bio))
2632                             c_r = 1;
2633                         if (BIO_should_write(c_bio))
2634                             c_w = 1;
2635                     } else {
2636                         fprintf(stderr, "ERROR in CLIENT\n");
2637                         err_in_client = 1;
2638                         ERR_print_errors(bio_err);
2639                         goto err;
2640                     }
2641                 } else if (i == 0) {
2642                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2643                     goto err;
2644                 } else {
2645                     if (debug)
2646                         printf("client read %d\n", i);
2647                     cr_num -= i;
2648                     if (sw_num > 0) {
2649                         s_write = 1;
2650                         s_w = 1;
2651                     }
2652                     if (cr_num <= 0) {
2653                         s_write = 1;
2654                         s_w = 1;
2655                         done = S_DONE | C_DONE;
2656                     }
2657                 }
2658             }
2659         }
2660
2661         if (do_server && !(done & S_DONE)) {
2662             if (!s_write) {
2663                 i = BIO_read(s_bio, sbuf, bufsiz);
2664                 if (i < 0) {
2665                     s_r = 0;
2666                     s_w = 0;
2667                     if (BIO_should_retry(s_bio)) {
2668                         if (BIO_should_read(s_bio))
2669                             s_r = 1;
2670                         if (BIO_should_write(s_bio))
2671                             s_w = 1;
2672                     } else {
2673                         fprintf(stderr, "ERROR in SERVER\n");
2674                         err_in_server = 1;
2675                         ERR_print_errors(bio_err);
2676                         goto err;
2677                     }
2678                 } else if (i == 0) {
2679                     ERR_print_errors(bio_err);
2680                     fprintf(stderr,
2681                             "SSL SERVER STARTUP FAILED in SSL_read\n");
2682                     goto err;
2683                 } else {
2684                     if (debug)
2685                         printf("server read %d\n", i);
2686                     sr_num -= i;
2687                     if (cw_num > 0) {
2688                         c_write = 1;
2689                         c_w = 1;
2690                     }
2691                     if (sr_num <= 0) {
2692                         s_write = 1;
2693                         s_w = 1;
2694                         c_write = 0;
2695                     }
2696                 }
2697             } else {
2698                 j = (sw_num > bufsiz) ? (int)bufsiz : (int)sw_num;
2699                 i = BIO_write(s_bio, sbuf, j);
2700                 if (i < 0) {
2701                     s_r = 0;
2702                     s_w = 0;
2703                     if (BIO_should_retry(s_bio)) {
2704                         if (BIO_should_read(s_bio))
2705                             s_r = 1;
2706                         if (BIO_should_write(s_bio))
2707                             s_w = 1;
2708                     } else {
2709                         fprintf(stderr, "ERROR in SERVER\n");
2710                         err_in_server = 1;
2711                         ERR_print_errors(bio_err);
2712                         goto err;
2713                     }
2714                 } else if (i == 0) {
2715                     ERR_print_errors(bio_err);
2716                     fprintf(stderr,
2717                             "SSL SERVER STARTUP FAILED in SSL_write\n");
2718                     goto err;
2719                 } else {
2720                     if (debug)
2721                         printf("server wrote %d\n", i);
2722                     sw_num -= i;
2723                     s_write = 0;
2724                     c_r = 1;
2725                     if (sw_num <= 0)
2726                         done |= S_DONE;
2727                     if (max_frag > 1029)
2728                         SSL_set_max_send_fragment(s_ssl, max_frag -= 5);
2729                 }
2730             }
2731         }
2732
2733         if ((done & S_DONE) && (done & C_DONE))
2734             break;
2735     }
2736
2737     if (verbose)
2738         print_details(c_ssl, "DONE: ");
2739 #ifndef OPENSSL_NO_NEXTPROTONEG
2740     if (verify_npn(c_ssl, s_ssl) < 0)
2741         goto err;
2742 #endif
2743     if (verify_serverinfo() < 0) {
2744         fprintf(stderr, "Server info verify error\n");
2745         goto err;
2746     }
2747     if (custom_ext_error) {
2748         fprintf(stderr, "Custom extension error\n");
2749         goto err;
2750     }
2751     ret = EXIT_SUCCESS;
2752  err:
2753     BIO_free(c_to_s);
2754     BIO_free(s_to_c);
2755     BIO_free_all(c_bio);
2756     BIO_free_all(s_bio);
2757     OPENSSL_free(cbuf);
2758     OPENSSL_free(sbuf);
2759
2760     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2761         ret = (err_in_client != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2762     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2763         ret = (err_in_server != 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2764
2765     return ret;
2766 }
2767
2768 static int verify_callback(int ok, X509_STORE_CTX *ctx)
2769 {
2770     char *s, buf[256];
2771
2772     s = X509_NAME_oneline(X509_get_subject_name(X509_STORE_CTX_get_current_cert(ctx)),
2773                           buf, sizeof(buf));
2774     if (s != NULL) {
2775         if (ok)
2776             printf("depth=%d %s\n", X509_STORE_CTX_get_error_depth(ctx), buf);
2777         else {
2778             fprintf(stderr, "depth=%d error=%d %s\n",
2779                     X509_STORE_CTX_get_error_depth(ctx),
2780                     X509_STORE_CTX_get_error(ctx), buf);
2781         }
2782     }
2783
2784     if (ok == 0) {
2785         int i = X509_STORE_CTX_get_error(ctx);
2786
2787         switch (i) {
2788         default:
2789             fprintf(stderr, "Error string: %s\n",
2790                     X509_verify_cert_error_string(i));
2791             break;
2792         case X509_V_ERR_CERT_NOT_YET_VALID:
2793         case X509_V_ERR_CERT_HAS_EXPIRED:
2794         case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2795             ok = 1;
2796             break;
2797         }
2798     }
2799
2800     return ok;
2801 }
2802
2803 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2804 {
2805     int ok = 1;
2806     struct app_verify_arg *cb_arg = arg;
2807
2808     if (cb_arg->app_verify) {
2809         char *s = NULL, buf[256];
2810         X509 *c = X509_STORE_CTX_get0_cert(ctx);
2811
2812         printf("In app_verify_callback, allowing cert. ");
2813         printf("Arg is: %s\n", cb_arg->string);
2814         printf("Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2815                 (void *)ctx, (void *)c);
2816         if (c)
2817             s = X509_NAME_oneline(X509_get_subject_name(c), buf, 256);
2818         if (s != NULL) {
2819             printf("cert depth=%d %s\n",
2820                     X509_STORE_CTX_get_error_depth(ctx), buf);
2821         }
2822         return 1;
2823     }
2824
2825     ok = X509_verify_cert(ctx);
2826
2827     return ok;
2828 }
2829
2830 #ifndef OPENSSL_NO_DH
2831 /*-
2832  * These DH parameters have been generated as follows:
2833  *    $ openssl dhparam -C -noout 512
2834  *    $ openssl dhparam -C -noout 1024
2835  *    $ openssl dhparam -C -noout -dsaparam 1024
2836  * (The third function has been renamed to avoid name conflicts.)
2837  */
2838 static DH *get_dh512()
2839 {
2840     static unsigned char dh512_p[] = {
2841         0xCB, 0xC8, 0xE1, 0x86, 0xD0, 0x1F, 0x94, 0x17, 0xA6, 0x99, 0xF0,
2842         0xC6,
2843         0x1F, 0x0D, 0xAC, 0xB6, 0x25, 0x3E, 0x06, 0x39, 0xCA, 0x72, 0x04,
2844         0xB0,
2845         0x6E, 0xDA, 0xC0, 0x61, 0xE6, 0x7A, 0x77, 0x25, 0xE8, 0x3B, 0xB9,
2846         0x5F,
2847         0x9A, 0xB6, 0xB5, 0xFE, 0x99, 0x0B, 0xA1, 0x93, 0x4E, 0x35, 0x33,
2848         0xB8,
2849         0xE1, 0xF1, 0x13, 0x4F, 0x59, 0x1A, 0xD2, 0x57, 0xC0, 0x26, 0x21,
2850         0x33,
2851         0x02, 0xC5, 0xAE, 0x23,
2852     };
2853     static unsigned char dh512_g[] = {
2854         0x02,
2855     };
2856     DH *dh;
2857     BIGNUM *p, *g;
2858
2859     if ((dh = DH_new()) == NULL)
2860         return NULL;
2861     p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
2862     g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
2863     if ((p == NULL) || (g == NULL) || !DH_set0_pqg(dh, p, NULL, g)) {
2864         DH_free(dh);
2865         BN_free(p);
2866         BN_free(g);
2867         return NULL;
2868     }
2869     return dh;
2870 }
2871
2872 static DH *get_dh1024()
2873 {
2874     static unsigned char dh1024_p[] = {
2875         0xF8, 0x81, 0x89, 0x7D, 0x14, 0x24, 0xC5, 0xD1, 0xE6, 0xF7, 0xBF,
2876         0x3A,
2877         0xE4, 0x90, 0xF4, 0xFC, 0x73, 0xFB, 0x34, 0xB5, 0xFA, 0x4C, 0x56,
2878         0xA2,
2879         0xEA, 0xA7, 0xE9, 0xC0, 0xC0, 0xCE, 0x89, 0xE1, 0xFA, 0x63, 0x3F,
2880         0xB0,
2881         0x6B, 0x32, 0x66, 0xF1, 0xD1, 0x7B, 0xB0, 0x00, 0x8F, 0xCA, 0x87,
2882         0xC2,
2883         0xAE, 0x98, 0x89, 0x26, 0x17, 0xC2, 0x05, 0xD2, 0xEC, 0x08, 0xD0,
2884         0x8C,
2885         0xFF, 0x17, 0x52, 0x8C, 0xC5, 0x07, 0x93, 0x03, 0xB1, 0xF6, 0x2F,
2886         0xB8,
2887         0x1C, 0x52, 0x47, 0x27, 0x1B, 0xDB, 0xD1, 0x8D, 0x9D, 0x69, 0x1D,
2888         0x52,
2889         0x4B, 0x32, 0x81, 0xAA, 0x7F, 0x00, 0xC8, 0xDC, 0xE6, 0xD9, 0xCC,
2890         0xC1,
2891         0x11, 0x2D, 0x37, 0x34, 0x6C, 0xEA, 0x02, 0x97, 0x4B, 0x0E, 0xBB,
2892         0xB1,
2893         0x71, 0x33, 0x09, 0x15, 0xFD, 0xDD, 0x23, 0x87, 0x07, 0x5E, 0x89,
2894         0xAB,
2895         0x6B, 0x7C, 0x5F, 0xEC, 0xA6, 0x24, 0xDC, 0x53,
2896     };
2897     static unsigned char dh1024_g[] = {
2898         0x02,
2899     };
2900     DH *dh;
2901     BIGNUM *p, *g;
2902
2903     if ((dh = DH_new()) == NULL)
2904         return NULL;
2905     p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
2906     g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
2907     if ((p == NULL) || (g == NULL) || !DH_set0_pqg(dh, p, NULL, g)) {
2908         DH_free(dh);
2909         BN_free(p);
2910         BN_free(g);
2911         return NULL;
2912     }
2913     return dh;
2914 }
2915
2916 static DH *get_dh1024dsa()
2917 {
2918     static unsigned char dh1024_p[] = {
2919         0xC8, 0x00, 0xF7, 0x08, 0x07, 0x89, 0x4D, 0x90, 0x53, 0xF3, 0xD5,
2920         0x00,
2921         0x21, 0x1B, 0xF7, 0x31, 0xA6, 0xA2, 0xDA, 0x23, 0x9A, 0xC7, 0x87,
2922         0x19,
2923         0x3B, 0x47, 0xB6, 0x8C, 0x04, 0x6F, 0xFF, 0xC6, 0x9B, 0xB8, 0x65,
2924         0xD2,
2925         0xC2, 0x5F, 0x31, 0x83, 0x4A, 0xA7, 0x5F, 0x2F, 0x88, 0x38, 0xB6,
2926         0x55,
2927         0xCF, 0xD9, 0x87, 0x6D, 0x6F, 0x9F, 0xDA, 0xAC, 0xA6, 0x48, 0xAF,
2928         0xFC,
2929         0x33, 0x84, 0x37, 0x5B, 0x82, 0x4A, 0x31, 0x5D, 0xE7, 0xBD, 0x52,
2930         0x97,
2931         0xA1, 0x77, 0xBF, 0x10, 0x9E, 0x37, 0xEA, 0x64, 0xFA, 0xCA, 0x28,
2932         0x8D,
2933         0x9D, 0x3B, 0xD2, 0x6E, 0x09, 0x5C, 0x68, 0xC7, 0x45, 0x90, 0xFD,
2934         0xBB,
2935         0x70, 0xC9, 0x3A, 0xBB, 0xDF, 0xD4, 0x21, 0x0F, 0xC4, 0x6A, 0x3C,
2936         0xF6,
2937         0x61, 0xCF, 0x3F, 0xD6, 0x13, 0xF1, 0x5F, 0xBC, 0xCF, 0xBC, 0x26,
2938         0x9E,
2939         0xBC, 0x0B, 0xBD, 0xAB, 0x5D, 0xC9, 0x54, 0x39,
2940     };
2941     static unsigned char dh1024_g[] = {
2942         0x3B, 0x40, 0x86, 0xE7, 0xF3, 0x6C, 0xDE, 0x67, 0x1C, 0xCC, 0x80,
2943         0x05,
2944         0x5A, 0xDF, 0xFE, 0xBD, 0x20, 0x27, 0x74, 0x6C, 0x24, 0xC9, 0x03,
2945         0xF3,
2946         0xE1, 0x8D, 0xC3, 0x7D, 0x98, 0x27, 0x40, 0x08, 0xB8, 0x8C, 0x6A,
2947         0xE9,
2948         0xBB, 0x1A, 0x3A, 0xD6, 0x86, 0x83, 0x5E, 0x72, 0x41, 0xCE, 0x85,
2949         0x3C,
2950         0xD2, 0xB3, 0xFC, 0x13, 0xCE, 0x37, 0x81, 0x9E, 0x4C, 0x1C, 0x7B,
2951         0x65,
2952         0xD3, 0xE6, 0xA6, 0x00, 0xF5, 0x5A, 0x95, 0x43, 0x5E, 0x81, 0xCF,
2953         0x60,
2954         0xA2, 0x23, 0xFC, 0x36, 0xA7, 0x5D, 0x7A, 0x4C, 0x06, 0x91, 0x6E,
2955         0xF6,
2956         0x57, 0xEE, 0x36, 0xCB, 0x06, 0xEA, 0xF5, 0x3D, 0x95, 0x49, 0xCB,
2957         0xA7,
2958         0xDD, 0x81, 0xDF, 0x80, 0x09, 0x4A, 0x97, 0x4D, 0xA8, 0x22, 0x72,
2959         0xA1,
2960         0x7F, 0xC4, 0x70, 0x56, 0x70, 0xE8, 0x20, 0x10, 0x18, 0x8F, 0x2E,
2961         0x60,
2962         0x07, 0xE7, 0x68, 0x1A, 0x82, 0x5D, 0x32, 0xA2,
2963     };
2964     DH *dh;
2965     BIGNUM *p, *g;
2966
2967     if ((dh = DH_new()) == NULL)
2968         return NULL;
2969     p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
2970     g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
2971     if ((p == NULL) || (g == NULL) || !DH_set0_pqg(dh, p, NULL, g)) {
2972         DH_free(dh);
2973         BN_free(p);
2974         BN_free(g);
2975         return NULL;
2976     }
2977     DH_set_length(dh, 160);
2978     return dh;
2979 }
2980 #endif
2981
2982 #ifndef OPENSSL_NO_PSK
2983 /* convert the PSK key (psk_key) in ascii to binary (psk) */
2984 static int psk_key2bn(const char *pskkey, unsigned char *psk,
2985                       unsigned int max_psk_len)
2986 {
2987     int ret;
2988     BIGNUM *bn = NULL;
2989
2990     ret = BN_hex2bn(&bn, pskkey);
2991     if (!ret) {
2992         BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
2993                    pskkey);
2994         BN_free(bn);
2995         return 0;
2996     }
2997     if (BN_num_bytes(bn) > (int)max_psk_len) {
2998         BIO_printf(bio_err,
2999                    "psk buffer of callback is too small (%d) for key (%d)\n",
3000                    max_psk_len, BN_num_bytes(bn));
3001         BN_free(bn);
3002         return 0;
3003     }
3004     ret = BN_bn2bin(bn, psk);
3005     BN_free(bn);
3006     return ret;
3007 }
3008
3009 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
3010                                         char *identity,
3011                                         unsigned int max_identity_len,
3012                                         unsigned char *psk,
3013                                         unsigned int max_psk_len)
3014 {
3015     int ret;
3016     unsigned int psk_len = 0;
3017
3018     ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3019     if (ret < 0)
3020         goto out_err;
3021     if (debug)
3022         fprintf(stderr, "client: created identity '%s' len=%d\n", identity,
3023                 ret);
3024     ret = psk_key2bn(psk_key, psk, max_psk_len);
3025     if (ret < 0)
3026         goto out_err;
3027     psk_len = ret;
3028  out_err:
3029     return psk_len;
3030 }
3031
3032 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3033                                         unsigned char *psk,
3034                                         unsigned int max_psk_len)
3035 {
3036     unsigned int psk_len = 0;
3037
3038     if (strcmp(identity, "Client_identity") != 0) {
3039         BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3040         return 0;
3041     }
3042     psk_len = psk_key2bn(psk_key, psk, max_psk_len);
3043     return psk_len;
3044 }
3045 #endif