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