test/ssltest_old.c

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