test/ssltest_old.c

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