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