test/ssltest_old.c

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