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