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