test/ssltest_old.c

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