test/ssltest_old.c

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