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         {"dtls1", DTLS1_VERSION},
 888         {"dtls1.2", DTLS1_2_VERSION}};
 889     size_t i;
 890     size_t n = OSSL_NELEM(versions);
 891
 892     for (i = 0; i < n; i++)
 893         if (strcmp(versions[i].name, value) == 0)
 894             return versions[i].version;
 895     return -1;
 896 }
 897
 898 static SSL_SESSION *read_session(const char *filename)
 899 {
 900     SSL_SESSION *sess;
 901     BIO *f = BIO_new_file(filename, "r");
 902
 903     if (f == NULL) {
 904         BIO_printf(bio_err, "Can't open session file %s\n", filename);
 905         ERR_print_errors(bio_err);
 906         return NULL;
 907     }
 908     sess = PEM_read_bio_SSL_SESSION(f, NULL, 0, NULL);
 909     if (sess == NULL) {
 910         BIO_printf(bio_err, "Can't parse session file %s\n", filename);
 911         ERR_print_errors(bio_err);
 912     }
 913     BIO_free(f);
 914     return sess;
 915 }
 916
 917 static int write_session(const char *filename, SSL_SESSION *sess)
 918 {
 919     BIO *f = BIO_new_file(filename, "w");
 920
 921     if (sess == NULL) {
 922         BIO_printf(bio_err, "No session information\n");
 923         return 0;
 924     }
 925     if (f == NULL) {
 926         BIO_printf(bio_err, "Can't open session file %s\n", filename);
 927         ERR_print_errors(bio_err);
 928         return 0;
 929     }
 930     PEM_write_bio_SSL_SESSION(f, sess);
 931     BIO_free(f);
 932     return 1;
 933 }
 934
 935 /*
 936  * set_protocol_version - Sets protocol version minimum or maximum
 937  *
 938  * Returns 0 on failure and 1 on success
 939  */
 940 static int set_protocol_version(const char *version, SSL *ssl, int setting)
 941 {
 942     if (version != NULL) {
 943         int ver = protocol_from_string(version);
 944         if (ver < 0) {
 945             BIO_printf(bio_err, "Error parsing: %s\n", version);
 946             return 0;
 947         }
 948         return SSL_ctrl(ssl, setting, ver, NULL);
 949     }
 950     return 1;
 951 }
 952
 953 int main(int argc, char *argv[])
 954 {
 955     const char *CApath = NULL, *CAfile = NULL;
 956     int badop = 0;
 957     enum { BIO_MEM, BIO_PAIR, BIO_IPV4, BIO_IPV6 } bio_type = BIO_MEM;
 958     int force = 0;
 959     int dtls1 = 0, dtls12 = 0, dtls = 0, tls1 = 0, ssl3 = 0, ret = 1;
 960     int client_auth = 0;
 961     int server_auth = 0, i;
 962     struct app_verify_arg app_verify_arg =
 963         { APP_CALLBACK_STRING, 0 };
 964     char *p;
 965     SSL_CTX *c_ctx = NULL;
 966     const SSL_METHOD *meth = NULL;
 967     SSL *c_ssl, *s_ssl;
 968     int number = 1, reuse = 0;
 969     int should_reuse = -1;
 970     int no_ticket = 0;
 971     long bytes = 256L;
 972 #ifndef OPENSSL_NO_DH
 973     DH *dh;
 974     int dhe512 = 0, dhe1024dsa = 0;
 975 #endif
 976 #ifndef OPENSSL_NO_SRP
 977     /* client */
 978     SRP_CLIENT_ARG srp_client_arg = { NULL, NULL };
 979     /* server */
 980     SRP_SERVER_ARG srp_server_arg = { NULL, NULL };
 981 #endif
 982     int no_dhe = 0;
 983     int no_psk = 0;
 984     int print_time = 0;
 985     clock_t s_time = 0, c_time = 0;
 986 #ifndef OPENSSL_NO_COMP
 987     int n, comp = 0;
 988     COMP_METHOD *cm = NULL;
 989     STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
 990 #endif
 991 #ifdef OPENSSL_FIPS
 992     int fips_mode = 0;
 993 #endif
 994     int no_protocol;
 995     int min_version = 0, max_version = 0;
 996 #ifndef OPENSSL_NO_CT
 997     /*
 998      * Disable CT validation by default, because it will interfere with
 999      * anything using custom extension handlers to deal with SCT extensions.
1000      */
1001     int ct_validation = 0;
1002 #endif
1003     SSL_CONF_CTX *s_cctx = NULL, *c_cctx = NULL, *s_cctx2 = NULL;
1004     STACK_OF(OPENSSL_STRING) *conf_args = NULL;
1005     char *arg = NULL, *argn = NULL;
1006
1007     verbose = 0;
1008     debug = 0;
1009     cipher = 0;
1010
1011     bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
1012
1013     p = getenv("OPENSSL_DEBUG_MEMORY");
1014     if (p != NULL && strcmp(p, "on") == 0)
1015         CRYPTO_set_mem_debug(1);
1016     CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
1017
1018     RAND_seed(rnd_seed, sizeof rnd_seed);
1019
1020     bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);
1021
1022     s_cctx = SSL_CONF_CTX_new();
1023     s_cctx2 = SSL_CONF_CTX_new();
1024     c_cctx = SSL_CONF_CTX_new();
1025
1026     if (!s_cctx || !c_cctx || !s_cctx2) {
1027         ERR_print_errors(bio_err);
1028         goto end;
1029     }
1030
1031     SSL_CONF_CTX_set_flags(s_cctx,
1032                            SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_SERVER |
1033                            SSL_CONF_FLAG_CERTIFICATE |
1034                            SSL_CONF_FLAG_REQUIRE_PRIVATE);
1035     SSL_CONF_CTX_set_flags(s_cctx2,
1036                            SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_SERVER |
1037                            SSL_CONF_FLAG_CERTIFICATE |
1038                            SSL_CONF_FLAG_REQUIRE_PRIVATE);
1039     if (!SSL_CONF_CTX_set1_prefix(s_cctx, "-s_")) {
1040         ERR_print_errors(bio_err);
1041         goto end;
1042     }
1043     if (!SSL_CONF_CTX_set1_prefix(s_cctx2, "-s_")) {
1044         ERR_print_errors(bio_err);
1045         goto end;
1046     }
1047
1048     SSL_CONF_CTX_set_flags(c_cctx,
1049                            SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_CLIENT |
1050                            SSL_CONF_FLAG_CERTIFICATE |
1051                            SSL_CONF_FLAG_REQUIRE_PRIVATE);
1052     if (!SSL_CONF_CTX_set1_prefix(c_cctx, "-c_")) {
1053         ERR_print_errors(bio_err);
1054         goto end;
1055     }
1056
1057     argc--;
1058     argv++;
1059
1060     while (argc >= 1) {
1061         if (strcmp(*argv, "-F") == 0) {
1062 #ifdef OPENSSL_FIPS
1063             fips_mode = 1;
1064 #else
1065             fprintf(stderr,
1066                     "not compiled with FIPS support, so exiting without running.\n");
1067             EXIT(0);
1068 #endif
1069         } else if (strcmp(*argv, "-server_auth") == 0)
1070             server_auth = 1;
1071         else if (strcmp(*argv, "-client_auth") == 0)
1072             client_auth = 1;
1073         else if (strcmp(*argv, "-v") == 0)
1074             verbose = 1;
1075         else if (strcmp(*argv, "-d") == 0)
1076             debug = 1;
1077         else if (strcmp(*argv, "-reuse") == 0)
1078             reuse = 1;
1079         else if (strcmp(*argv, "-dhe512") == 0) {
1080 #ifndef OPENSSL_NO_DH
1081             dhe512 = 1;
1082 #else
1083             fprintf(stderr,
1084                     "ignoring -dhe512, since I'm compiled without DH\n");
1085 #endif
1086         } else if (strcmp(*argv, "-dhe1024dsa") == 0) {
1087 #ifndef OPENSSL_NO_DH
1088             dhe1024dsa = 1;
1089 #else
1090             fprintf(stderr,
1091                     "ignoring -dhe1024dsa, since I'm compiled without DH\n");
1092 #endif
1093         } else if (strcmp(*argv, "-no_dhe") == 0)
1094             no_dhe = 1;
1095         else if (strcmp(*argv, "-no_ecdhe") == 0)
1096             /* obsolete */;
1097         else if (strcmp(*argv, "-psk") == 0) {
1098             if (--argc < 1)
1099                 goto bad;
1100             psk_key = *(++argv);
1101 #ifndef OPENSSL_NO_PSK
1102             if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key)) {
1103                 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
1104                 goto bad;
1105             }
1106 #else
1107             no_psk = 1;
1108 #endif
1109         }
1110 #ifndef OPENSSL_NO_SRP
1111         else if (strcmp(*argv, "-srpuser") == 0) {
1112             if (--argc < 1)
1113                 goto bad;
1114             srp_server_arg.expected_user = srp_client_arg.srplogin =
1115                 *(++argv);
1116             min_version = TLS1_VERSION;
1117         } else if (strcmp(*argv, "-srppass") == 0) {
1118             if (--argc < 1)
1119                 goto bad;
1120             srp_server_arg.pass = srp_client_arg.srppassin = *(++argv);
1121             min_version = TLS1_VERSION;
1122         }
1123 #endif
1124         else if (strcmp(*argv, "-tls1") == 0) {
1125             tls1 = 1;
1126         } else if (strcmp(*argv, "-ssl3") == 0) {
1127             ssl3 = 1;
1128         } else if (strcmp(*argv, "-dtls1") == 0) {
1129             dtls1 = 1;
1130         } else if (strcmp(*argv, "-dtls12") == 0) {
1131             dtls12 = 1;
1132         } else if (strcmp(*argv, "-dtls") == 0) {
1133             dtls = 1;
1134         } else if (strncmp(*argv, "-num", 4) == 0) {
1135             if (--argc < 1)
1136                 goto bad;
1137             number = atoi(*(++argv));
1138             if (number == 0)
1139                 number = 1;
1140         } else if (strcmp(*argv, "-bytes") == 0) {
1141             if (--argc < 1)
1142                 goto bad;
1143             bytes = atol(*(++argv));
1144             if (bytes == 0L)
1145                 bytes = 1L;
1146             i = strlen(argv[0]);
1147             if (argv[0][i - 1] == 'k')
1148                 bytes *= 1024L;
1149             if (argv[0][i - 1] == 'm')
1150                 bytes *= 1024L * 1024L;
1151         } else if (strcmp(*argv, "-cipher") == 0) {
1152             if (--argc < 1)
1153                 goto bad;
1154             cipher = *(++argv);
1155         } else if (strcmp(*argv, "-CApath") == 0) {
1156             if (--argc < 1)
1157                 goto bad;
1158             CApath = *(++argv);
1159         } else if (strcmp(*argv, "-CAfile") == 0) {
1160             if (--argc < 1)
1161                 goto bad;
1162             CAfile = *(++argv);
1163         } else if (strcmp(*argv, "-bio_pair") == 0) {
1164             bio_type = BIO_PAIR;
1165         }
1166 #ifndef OPENSSL_NO_SOCK
1167         else if (strcmp(*argv, "-ipv4") == 0) {
1168             bio_type = BIO_IPV4;
1169         } else if (strcmp(*argv, "-ipv6") == 0) {
1170             bio_type = BIO_IPV6;
1171         }
1172 #endif
1173         else if (strcmp(*argv, "-f") == 0) {
1174             force = 1;
1175         } else if (strcmp(*argv, "-time") == 0) {
1176             print_time = 1;
1177         }
1178 #ifndef OPENSSL_NO_CT
1179         else if (strcmp(*argv, "-noct") == 0) {
1180             ct_validation = 0;
1181         }
1182         else if (strcmp(*argv, "-ct") == 0) {
1183             ct_validation = 1;
1184         }
1185 #endif
1186 #ifndef OPENSSL_NO_COMP
1187         else if (strcmp(*argv, "-zlib") == 0) {
1188             comp = COMP_ZLIB;
1189         }
1190 #endif
1191         else if (strcmp(*argv, "-app_verify") == 0) {
1192             app_verify_arg.app_verify = 1;
1193         }
1194 #ifndef OPENSSL_NO_NEXTPROTONEG
1195           else if (strcmp(*argv, "-npn_client") == 0) {
1196             npn_client = 1;
1197         } else if (strcmp(*argv, "-npn_server") == 0) {
1198             npn_server = 1;
1199         } else if (strcmp(*argv, "-npn_server_reject") == 0) {
1200             npn_server_reject = 1;
1201         }
1202 #endif
1203         else if (strcmp(*argv, "-serverinfo_sct") == 0) {
1204             serverinfo_sct = 1;
1205         } else if (strcmp(*argv, "-serverinfo_tack") == 0) {
1206             serverinfo_tack = 1;
1207         } else if (strcmp(*argv, "-serverinfo_file") == 0) {
1208             if (--argc < 1)
1209                 goto bad;
1210             serverinfo_file = *(++argv);
1211         } else if (strcmp(*argv, "-custom_ext") == 0) {
1212             custom_ext = 1;
1213         } else if (strcmp(*argv, "-alpn_client") == 0) {
1214             if (--argc < 1)
1215                 goto bad;
1216             alpn_client = *(++argv);
1217         } else if (strcmp(*argv, "-alpn_server") == 0 ||
1218                    strcmp(*argv, "-alpn_server1") == 0) {
1219             if (--argc < 1)
1220                 goto bad;
1221             alpn_server = *(++argv);
1222         } else if (strcmp(*argv, "-alpn_server2") == 0) {
1223             if (--argc < 1)
1224                 goto bad;
1225             alpn_server2 = *(++argv);
1226         } else if (strcmp(*argv, "-alpn_expected") == 0) {
1227             if (--argc < 1)
1228                 goto bad;
1229             alpn_expected = *(++argv);
1230         } else if (strcmp(*argv, "-server_min_proto") == 0) {
1231             if (--argc < 1)
1232                 goto bad;
1233             server_min_proto = *(++argv);
1234         } else if (strcmp(*argv, "-server_max_proto") == 0) {
1235             if (--argc < 1)
1236                 goto bad;
1237             server_max_proto = *(++argv);
1238         } else if (strcmp(*argv, "-client_min_proto") == 0) {
1239             if (--argc < 1)
1240                 goto bad;
1241             client_min_proto = *(++argv);
1242         } else if (strcmp(*argv, "-client_max_proto") == 0) {
1243             if (--argc < 1)
1244                 goto bad;
1245             client_max_proto = *(++argv);
1246         } else if (strcmp(*argv, "-should_negotiate") == 0) {
1247             if (--argc < 1)
1248                 goto bad;
1249             should_negotiate = *(++argv);
1250         } else if (strcmp(*argv, "-sn_client") == 0) {
1251             if (--argc < 1)
1252                 goto bad;
1253             sn_client = *(++argv);
1254         } else if (strcmp(*argv, "-sn_server1") == 0) {
1255             if (--argc < 1)
1256                 goto bad;
1257             sn_server1 = *(++argv);
1258         } else if (strcmp(*argv, "-sn_server2") == 0) {
1259             if (--argc < 1)
1260                 goto bad;
1261             sn_server2 = *(++argv);
1262         } else if (strcmp(*argv, "-sn_expect1") == 0) {
1263             sn_expect = 1;
1264         } else if (strcmp(*argv, "-sn_expect2") == 0) {
1265             sn_expect = 2;
1266         } else if (strcmp(*argv, "-server_sess_out") == 0) {
1267             if (--argc < 1)
1268                 goto bad;
1269             server_sess_out = *(++argv);
1270         } else if (strcmp(*argv, "-server_sess_in") == 0) {
1271             if (--argc < 1)
1272                 goto bad;
1273             server_sess_in = *(++argv);
1274         } else if (strcmp(*argv, "-client_sess_out") == 0) {
1275             if (--argc < 1)
1276                 goto bad;
1277             client_sess_out = *(++argv);
1278         } else if (strcmp(*argv, "-client_sess_in") == 0) {
1279             if (--argc < 1)
1280                 goto bad;
1281             client_sess_in = *(++argv);
1282         } else if (strcmp(*argv, "-should_reuse") == 0) {
1283             if (--argc < 1)
1284                 goto bad;
1285             should_reuse = !!atoi(*(++argv));
1286         } else if (strcmp(*argv, "-no_ticket") == 0) {
1287             no_ticket = 1;
1288         } else {
1289             int rv;
1290             arg = argv[0];
1291             argn = argv[1];
1292             /* Try to process command using SSL_CONF */
1293             rv = SSL_CONF_cmd_argv(c_cctx, &argc, &argv);
1294             /* If not processed try server */
1295             if (rv == 0)
1296                 rv = SSL_CONF_cmd_argv(s_cctx, &argc, &argv);
1297             /* Recognised: store it for later use */
1298             if (rv > 0) {
1299                 if (rv == 1)
1300                     argn = NULL;
1301                 if (!conf_args) {
1302                     conf_args = sk_OPENSSL_STRING_new_null();
1303                     if (!conf_args)
1304                         goto end;
1305                 }
1306                 if (!sk_OPENSSL_STRING_push(conf_args, arg))
1307                     goto end;
1308                 if (!sk_OPENSSL_STRING_push(conf_args, argn))
1309                     goto end;
1310                 continue;
1311             }
1312             if (rv == -3)
1313                 BIO_printf(bio_err, "Missing argument for %s\n", arg);
1314             else if (rv < 0)
1315                 BIO_printf(bio_err, "Error with command %s\n", arg);
1316             else if (rv == 0)
1317                 BIO_printf(bio_err, "unknown option %s\n", arg);
1318             badop = 1;
1319             break;
1320         }
1321         argc--;
1322         argv++;
1323     }
1324     if (badop) {
1325  bad:
1326         sv_usage();
1327         goto end;
1328     }
1329
1330     if (ssl3 + tls1 + dtls + dtls1 + dtls12 > 1) {
1331         fprintf(stderr, "At most one of -ssl3, -tls1, -dtls, -dtls1 or -dtls12 should "
1332                 "be requested.\n");
1333         EXIT(1);
1334     }
1335
1336 #ifdef OPENSSL_NO_SSL3
1337     if (ssl3)
1338         no_protocol = 1;
1339     else
1340 #endif
1341 #ifdef OPENSSL_NO_TLS1
1342     if (tls1)
1343         no_protocol = 1;
1344     else
1345 #endif
1346 #if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1)
1347     if (dtls1)
1348         no_protocol = 1;
1349     else
1350 #endif
1351 #if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1_2)
1352     if (dtls12)
1353         no_protocol = 1;
1354     else
1355 #endif
1356         no_protocol = 0;
1357
1358     /*
1359      * Testing was requested for a compiled-out protocol (e.g. SSLv3).
1360      * Ideally, we would error out, but the generic test wrapper can't know
1361      * when to expect failure. So we do nothing and return success.
1362      */
1363     if (no_protocol) {
1364         fprintf(stderr, "Testing was requested for a disabled protocol. "
1365                 "Skipping tests.\n");
1366         ret = 0;
1367         goto end;
1368     }
1369
1370     if (!ssl3 && !tls1 && !dtls && !dtls1 && !dtls12 && number > 1 && !reuse && !force) {
1371         fprintf(stderr, "This case cannot work.  Use -f to perform "
1372                 "the test anyway (and\n-d to see what happens), "
1373                 "or add one of -ssl3, -tls1, -dtls, -dtls1, -dtls12, -reuse\n"
1374                 "to avoid protocol mismatch.\n");
1375         EXIT(1);
1376     }
1377 #ifdef OPENSSL_FIPS
1378     if (fips_mode) {
1379         if (!FIPS_mode_set(1)) {
1380             ERR_print_errors(bio_err);
1381             EXIT(1);
1382         } else
1383             fprintf(stderr, "*** IN FIPS MODE ***\n");
1384     }
1385 #endif
1386
1387     if (print_time) {
1388         if (bio_type != BIO_PAIR) {
1389             fprintf(stderr, "Using BIO pair (-bio_pair)\n");
1390             bio_type = BIO_PAIR;
1391         }
1392         if (number < 50 && !force)
1393             fprintf(stderr,
1394                     "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
1395     }
1396
1397 /*      if (cipher == NULL) cipher=getenv("SSL_CIPHER"); */
1398
1399 #ifndef OPENSSL_NO_COMP
1400     if (comp == COMP_ZLIB)
1401         cm = COMP_zlib();
1402     if (cm != NULL) {
1403         if (COMP_get_type(cm) != NID_undef) {
1404             if (SSL_COMP_add_compression_method(comp, cm) != 0) {
1405                 fprintf(stderr, "Failed to add compression method\n");
1406                 ERR_print_errors_fp(stderr);
1407             }
1408         } else {
1409             fprintf(stderr,
1410                     "Warning: %s compression not supported\n",
1411                     comp == COMP_ZLIB ? "zlib" : "unknown");
1412             ERR_print_errors_fp(stderr);
1413         }
1414     }
1415     ssl_comp_methods = SSL_COMP_get_compression_methods();
1416     n = sk_SSL_COMP_num(ssl_comp_methods);
1417     if (n) {
1418         int j;
1419         printf("Available compression methods:");
1420         for (j = 0; j < n; j++) {
1421             SSL_COMP *c = sk_SSL_COMP_value(ssl_comp_methods, j);
1422             printf("  %s:%d", SSL_COMP_get0_name(c), SSL_COMP_get_id(c));
1423         }
1424         printf("\n");
1425     }
1426 #endif
1427
1428 #ifndef OPENSSL_NO_TLS
1429     meth = TLS_method();
1430     if (ssl3) {
1431         min_version = SSL3_VERSION;
1432         max_version = SSL3_VERSION;
1433     } else if (tls1) {
1434         min_version = TLS1_VERSION;
1435         max_version = TLS1_VERSION;
1436     }
1437 #endif
1438 #ifndef OPENSSL_NO_DTLS
1439     if (dtls || dtls1 || dtls12)
1440         meth = DTLS_method();
1441     if (dtls1) {
1442         min_version = DTLS1_VERSION;
1443         max_version = DTLS1_VERSION;
1444     } else if (dtls12) {
1445         min_version = DTLS1_2_VERSION;
1446         max_version = DTLS1_2_VERSION;
1447     }
1448 #endif
1449
1450     c_ctx = SSL_CTX_new(meth);
1451     s_ctx = SSL_CTX_new(meth);
1452     s_ctx2 = SSL_CTX_new(meth); /* no SSL_CTX_dup! */
1453     if ((c_ctx == NULL) || (s_ctx == NULL) || (s_ctx2 == NULL)) {
1454         ERR_print_errors(bio_err);
1455         goto end;
1456     }
1457     /*
1458      * Since we will use low security ciphersuites and keys for testing set
1459      * security level to zero by default. Tests can override this by adding
1460      * "@SECLEVEL=n" to the cipher string.
1461      */
1462     SSL_CTX_set_security_level(c_ctx, 0);
1463     SSL_CTX_set_security_level(s_ctx, 0);
1464     SSL_CTX_set_security_level(s_ctx2, 0);
1465
1466     if (no_ticket) {
1467         SSL_CTX_set_options(c_ctx, SSL_OP_NO_TICKET);
1468         SSL_CTX_set_options(s_ctx, SSL_OP_NO_TICKET);
1469     }
1470
1471     if (SSL_CTX_set_min_proto_version(c_ctx, min_version) == 0)
1472         goto end;
1473     if (SSL_CTX_set_max_proto_version(c_ctx, max_version) == 0)
1474         goto end;
1475     if (SSL_CTX_set_min_proto_version(s_ctx, min_version) == 0)
1476         goto end;
1477     if (SSL_CTX_set_max_proto_version(s_ctx, max_version) == 0)
1478         goto end;
1479
1480     if (cipher != NULL) {
1481         if (!SSL_CTX_set_cipher_list(c_ctx, cipher)
1482             || !SSL_CTX_set_cipher_list(s_ctx, cipher)
1483             || !SSL_CTX_set_cipher_list(s_ctx2, cipher)) {
1484             ERR_print_errors(bio_err);
1485             goto end;
1486         }
1487     }
1488
1489 #ifndef OPENSSL_NO_CT
1490     if (ct_validation &&
1491         !SSL_CTX_enable_ct(c_ctx, SSL_CT_VALIDATION_STRICT)) {
1492         ERR_print_errors(bio_err);
1493         goto end;
1494     }
1495 #endif
1496
1497     /* Process SSL_CONF arguments */
1498     SSL_CONF_CTX_set_ssl_ctx(c_cctx, c_ctx);
1499     SSL_CONF_CTX_set_ssl_ctx(s_cctx, s_ctx);
1500     SSL_CONF_CTX_set_ssl_ctx(s_cctx2, s_ctx2);
1501
1502     for (i = 0; i < sk_OPENSSL_STRING_num(conf_args); i += 2) {
1503         int rv;
1504         arg = sk_OPENSSL_STRING_value(conf_args, i);
1505         argn = sk_OPENSSL_STRING_value(conf_args, i + 1);
1506         rv = SSL_CONF_cmd(c_cctx, arg, argn);
1507         /* If not recognised use server context */
1508         if (rv == -2) {
1509             rv = SSL_CONF_cmd(s_cctx2, arg, argn);
1510             if (rv > 0)
1511                 rv = SSL_CONF_cmd(s_cctx, arg, argn);
1512         }
1513         if (rv <= 0) {
1514             BIO_printf(bio_err, "Error processing %s %s\n",
1515                        arg, argn ? argn : "");
1516             ERR_print_errors(bio_err);
1517             goto end;
1518         }
1519     }
1520
1521     if (!SSL_CONF_CTX_finish(s_cctx) || !SSL_CONF_CTX_finish(c_cctx) || !SSL_CONF_CTX_finish(s_cctx2)) {
1522         BIO_puts(bio_err, "Error finishing context\n");
1523         ERR_print_errors(bio_err);
1524         goto end;
1525     }
1526 #ifndef OPENSSL_NO_DH
1527     if (!no_dhe) {
1528         if (dhe1024dsa) {
1529             dh = get_dh1024dsa();
1530         } else if (dhe512)
1531             dh = get_dh512();
1532         else
1533             dh = get_dh1024();
1534         SSL_CTX_set_tmp_dh(s_ctx, dh);
1535         SSL_CTX_set_tmp_dh(s_ctx2, dh);
1536         DH_free(dh);
1537     }
1538 #else
1539     (void)no_dhe;
1540 #endif
1541
1542     if ((!SSL_CTX_load_verify_locations(s_ctx, CAfile, CApath)) ||
1543         (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1544         (!SSL_CTX_load_verify_locations(s_ctx2, CAfile, CApath)) ||
1545         (!SSL_CTX_set_default_verify_paths(s_ctx2)) ||
1546         (!SSL_CTX_load_verify_locations(c_ctx, CAfile, CApath)) ||
1547         (!SSL_CTX_set_default_verify_paths(c_ctx))) {
1548         /* fprintf(stderr,"SSL_load_verify_locations\n"); */
1549         ERR_print_errors(bio_err);
1550         /* goto end; */
1551     }
1552
1553 #ifndef OPENSSL_NO_CT
1554     if (!SSL_CTX_set_default_ctlog_list_file(s_ctx) ||
1555         !SSL_CTX_set_default_ctlog_list_file(s_ctx2) ||
1556         !SSL_CTX_set_default_ctlog_list_file(c_ctx)) {
1557         ERR_print_errors(bio_err);
1558     }
1559 #endif
1560
1561     if (client_auth) {
1562         printf("client authentication\n");
1563         SSL_CTX_set_verify(s_ctx,
1564                            SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1565                            verify_callback);
1566         SSL_CTX_set_verify(s_ctx2,
1567                            SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1568                            verify_callback);
1569         SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback,
1570                                          &app_verify_arg);
1571         SSL_CTX_set_cert_verify_callback(s_ctx2, app_verify_callback,
1572                                          &app_verify_arg);
1573     }
1574     if (server_auth) {
1575         printf("server authentication\n");
1576         SSL_CTX_set_verify(c_ctx, SSL_VERIFY_PEER, verify_callback);
1577         SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback,
1578                                          &app_verify_arg);
1579     }
1580
1581     {
1582         int session_id_context = 0;
1583         if (!SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context,
1584                                             sizeof session_id_context) ||
1585             !SSL_CTX_set_session_id_context(s_ctx2, (void *)&session_id_context,
1586                                             sizeof session_id_context)) {
1587             ERR_print_errors(bio_err);
1588             goto end;
1589         }
1590     }
1591
1592     /* Use PSK only if PSK key is given */
1593     if (psk_key != NULL) {
1594         /*
1595          * no_psk is used to avoid putting psk command to openssl tool
1596          */
1597         if (no_psk) {
1598             /*
1599              * if PSK is not compiled in and psk key is given, do nothing and
1600              * exit successfully
1601              */
1602             ret = 0;
1603             goto end;
1604         }
1605 #ifndef OPENSSL_NO_PSK
1606         SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1607         SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1608         SSL_CTX_set_psk_server_callback(s_ctx2, psk_server_callback);
1609         if (debug)
1610             BIO_printf(bio_err, "setting PSK identity hint to s_ctx\n");
1611         if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint") ||
1612             !SSL_CTX_use_psk_identity_hint(s_ctx2, "ctx server identity_hint")) {
1613             BIO_printf(bio_err, "error setting PSK identity hint to s_ctx\n");
1614             ERR_print_errors(bio_err);
1615             goto end;
1616         }
1617 #endif
1618     }
1619 #ifndef OPENSSL_NO_SRP
1620     if (srp_client_arg.srplogin) {
1621         if (!SSL_CTX_set_srp_username(c_ctx, srp_client_arg.srplogin)) {
1622             BIO_printf(bio_err, "Unable to set SRP username\n");
1623             goto end;
1624         }
1625         SSL_CTX_set_srp_cb_arg(c_ctx, &srp_client_arg);
1626         SSL_CTX_set_srp_client_pwd_callback(c_ctx,
1627                                             ssl_give_srp_client_pwd_cb);
1628         /*
1629          * SSL_CTX_set_srp_strength(c_ctx, srp_client_arg.strength);
1630          */
1631     }
1632
1633     if (srp_server_arg.expected_user != NULL) {
1634         SSL_CTX_set_verify(s_ctx, SSL_VERIFY_NONE, verify_callback);
1635         SSL_CTX_set_verify(s_ctx2, SSL_VERIFY_NONE, verify_callback);
1636         SSL_CTX_set_srp_cb_arg(s_ctx, &srp_server_arg);
1637         SSL_CTX_set_srp_cb_arg(s_ctx2, &srp_server_arg);
1638         SSL_CTX_set_srp_username_callback(s_ctx, ssl_srp_server_param_cb);
1639         SSL_CTX_set_srp_username_callback(s_ctx2, ssl_srp_server_param_cb);
1640     }
1641 #endif
1642
1643 #ifndef OPENSSL_NO_NEXTPROTONEG
1644     if (npn_client) {
1645         SSL_CTX_set_next_proto_select_cb(c_ctx, cb_client_npn, NULL);
1646     }
1647     if (npn_server) {
1648         if (npn_server_reject) {
1649             BIO_printf(bio_err,
1650                        "Can't have both -npn_server and -npn_server_reject\n");
1651             goto end;
1652         }
1653         SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_npn, NULL);
1654         SSL_CTX_set_next_protos_advertised_cb(s_ctx2, cb_server_npn, NULL);
1655     }
1656     if (npn_server_reject) {
1657         SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_rejects_npn,
1658                                               NULL);
1659         SSL_CTX_set_next_protos_advertised_cb(s_ctx2, cb_server_rejects_npn,
1660                                               NULL);
1661     }
1662 #endif
1663
1664     if (serverinfo_sct) {
1665         if (!SSL_CTX_add_client_custom_ext(c_ctx,
1666                 TLSEXT_TYPE_signed_certificate_timestamp,
1667                 NULL, NULL, NULL,
1668                 serverinfo_cli_parse_cb, NULL)) {
1669             BIO_printf(bio_err, "Error adding SCT extension\n");
1670             goto end;
1671         }
1672     }
1673     if (serverinfo_tack) {
1674         if (!SSL_CTX_add_client_custom_ext(c_ctx, TACK_EXT_TYPE,
1675                                       NULL, NULL, NULL,
1676                                       serverinfo_cli_parse_cb, NULL)) {
1677             BIO_printf(bio_err, "Error adding TACK extension\n");
1678             goto end;
1679         }
1680     }
1681     if (serverinfo_file)
1682         if (!SSL_CTX_use_serverinfo_file(s_ctx, serverinfo_file) ||
1683             !SSL_CTX_use_serverinfo_file(s_ctx2, serverinfo_file)) {
1684             BIO_printf(bio_err, "missing serverinfo file\n");
1685             goto end;
1686         }
1687
1688     if (custom_ext) {
1689         if (!SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_0,
1690                                       custom_ext_0_cli_add_cb,
1691                                       NULL, NULL,
1692                                       custom_ext_0_cli_parse_cb, NULL)
1693             || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_1,
1694                                       custom_ext_1_cli_add_cb,
1695                                       NULL, NULL,
1696                                       custom_ext_1_cli_parse_cb, NULL)
1697             || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_2,
1698                                       custom_ext_2_cli_add_cb,
1699                                       NULL, NULL,
1700                                       custom_ext_2_cli_parse_cb, NULL)
1701             || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_3,
1702                                       custom_ext_3_cli_add_cb,
1703                                       NULL, NULL,
1704                                       custom_ext_3_cli_parse_cb, NULL)
1705             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_0,
1706                                       custom_ext_0_srv_add_cb,
1707                                       NULL, NULL,
1708                                       custom_ext_0_srv_parse_cb, NULL)
1709             || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_0,
1710                                       custom_ext_0_srv_add_cb,
1711                                       NULL, NULL,
1712                                       custom_ext_0_srv_parse_cb, NULL)
1713             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_1,
1714                                       custom_ext_1_srv_add_cb,
1715                                       NULL, NULL,
1716                                       custom_ext_1_srv_parse_cb, NULL)
1717             || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_1,
1718                                       custom_ext_1_srv_add_cb,
1719                                       NULL, NULL,
1720                                       custom_ext_1_srv_parse_cb, NULL)
1721             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_2,
1722                                       custom_ext_2_srv_add_cb,
1723                                       NULL, NULL,
1724                                       custom_ext_2_srv_parse_cb, NULL)
1725             || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_2,
1726                                       custom_ext_2_srv_add_cb,
1727                                       NULL, NULL,
1728                                       custom_ext_2_srv_parse_cb, NULL)
1729             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_3,
1730                                       custom_ext_3_srv_add_cb,
1731                                       NULL, NULL,
1732                                       custom_ext_3_srv_parse_cb, NULL)
1733             || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_3,
1734                                       custom_ext_3_srv_add_cb,
1735                                       NULL, NULL,
1736                                       custom_ext_3_srv_parse_cb, NULL)) {
1737             BIO_printf(bio_err, "Error setting custom extensions\n");
1738             goto end;
1739         }
1740     }
1741
1742     if (alpn_server)
1743         SSL_CTX_set_alpn_select_cb(s_ctx, cb_server_alpn, alpn_server);
1744     if (alpn_server2)
1745         SSL_CTX_set_alpn_select_cb(s_ctx2, cb_server_alpn, alpn_server2);
1746
1747     if (alpn_client) {
1748         size_t alpn_len;
1749         unsigned char *alpn = next_protos_parse(&alpn_len, alpn_client);
1750
1751         if (alpn == NULL) {
1752             BIO_printf(bio_err, "Error parsing -alpn_client argument\n");
1753             goto end;
1754         }
1755         /* Returns 0 on success!! */
1756         if (SSL_CTX_set_alpn_protos(c_ctx, alpn, alpn_len)) {
1757             BIO_printf(bio_err, "Error setting ALPN\n");
1758             OPENSSL_free(alpn);
1759             goto end;
1760         }
1761         OPENSSL_free(alpn);
1762     }
1763
1764     if (server_sess_in != NULL) {
1765         server_sess = read_session(server_sess_in);
1766         if (server_sess == NULL)
1767             goto end;
1768     }
1769     if (client_sess_in != NULL) {
1770         client_sess = read_session(client_sess_in);
1771         if (client_sess == NULL)
1772             goto end;
1773     }
1774
1775     if (server_sess_out != NULL || server_sess_in != NULL) {
1776         char *keys;
1777         long size;
1778
1779         /* Use a fixed key so that we can decrypt the ticket. */
1780         size = SSL_CTX_set_tlsext_ticket_keys(s_ctx, NULL, 0);
1781         keys = OPENSSL_zalloc(size);
1782         SSL_CTX_set_tlsext_ticket_keys(s_ctx, keys, size);
1783         OPENSSL_free(keys);
1784     }
1785
1786     if (sn_server1 != NULL || sn_server2 != NULL)
1787         SSL_CTX_set_tlsext_servername_callback(s_ctx, servername_cb);
1788
1789     c_ssl = SSL_new(c_ctx);
1790     s_ssl = SSL_new(s_ctx);
1791
1792     if (sn_client)
1793         SSL_set_tlsext_host_name(c_ssl, sn_client);
1794
1795     if (!set_protocol_version(server_min_proto, s_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1796         goto end;
1797     if (!set_protocol_version(server_max_proto, s_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1798         goto end;
1799     if (!set_protocol_version(client_min_proto, c_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1800         goto end;
1801     if (!set_protocol_version(client_max_proto, c_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1802         goto end;
1803
1804     if (server_sess) {
1805         if (SSL_CTX_add_session(s_ctx, server_sess) == 0) {
1806             BIO_printf(bio_err, "Can't add server session\n");
1807             ERR_print_errors(bio_err);
1808             goto end;
1809         }
1810     }
1811
1812     BIO_printf(bio_stdout, "Doing handshakes=%d bytes=%ld\n", number, bytes);
1813     for (i = 0; i < number; i++) {
1814         if (!reuse) {
1815             if (!SSL_set_session(c_ssl, NULL)) {
1816                 BIO_printf(bio_err, "Failed to set session\n");
1817                 goto end;
1818             }
1819         }
1820         if (client_sess_in != NULL) {
1821             if (SSL_set_session(c_ssl, client_sess) == 0) {
1822                 BIO_printf(bio_err, "Can't set client session\n");
1823                 ERR_print_errors(bio_err);
1824                 goto end;
1825             }
1826         }
1827         switch (bio_type) {
1828         case BIO_MEM:
1829             ret = doit(s_ssl, c_ssl, bytes);
1830             break;
1831         case BIO_PAIR:
1832             ret = doit_biopair(s_ssl, c_ssl, bytes, &s_time, &c_time);
1833             break;
1834 #ifndef OPENSSL_NO_SOCK
1835         case BIO_IPV4:
1836             ret = doit_localhost(s_ssl, c_ssl, BIO_FAMILY_IPV4,
1837                                  bytes, &s_time, &c_time);
1838             break;
1839         case BIO_IPV6:
1840             ret = doit_localhost(s_ssl, c_ssl, BIO_FAMILY_IPV6,
1841                                  bytes, &s_time, &c_time);
1842             break;
1843 #else
1844         case BIO_IPV4:
1845         case BIO_IPV6:
1846             ret = 1;
1847             goto err;
1848 #endif
1849         }
1850         if (ret)  break;
1851     }
1852
1853     if (should_negotiate && ret == 0 &&
1854         strcmp(should_negotiate, "fail-server") != 0 &&
1855         strcmp(should_negotiate, "fail-client") != 0) {
1856         int version = protocol_from_string(should_negotiate);
1857         if (version < 0) {
1858             BIO_printf(bio_err, "Error parsing: %s\n", should_negotiate);
1859             ret = 1;
1860             goto err;
1861         }
1862         if (SSL_version(c_ssl) != version) {
1863             BIO_printf(bio_err, "Unxpected version negotiated. "
1864                 "Expected: %s, got %s\n", should_negotiate, SSL_get_version(c_ssl));
1865             ret = 1;
1866             goto err;
1867         }
1868     }
1869
1870     if (should_reuse != -1) {
1871         if (SSL_session_reused(s_ssl) != should_reuse ||
1872             SSL_session_reused(c_ssl) != should_reuse) {
1873             BIO_printf(bio_err, "Unexpected session reuse state. "
1874                 "Expected: %d, server: %d, client: %d\n", should_reuse,
1875                 SSL_session_reused(s_ssl), SSL_session_reused(c_ssl));
1876             ret = 1;
1877             goto err;
1878         }
1879     }
1880
1881     if (server_sess_out != NULL) {
1882         if (write_session(server_sess_out, SSL_get_session(s_ssl)) == 0) {
1883             ret = 1;
1884             goto err;
1885         }
1886     }
1887     if (client_sess_out != NULL) {
1888         if (write_session(client_sess_out, SSL_get_session(c_ssl)) == 0) {
1889             ret = 1;
1890             goto err;
1891         }
1892     }
1893
1894     if (!verbose) {
1895         print_details(c_ssl, "");
1896     }
1897     if (print_time) {
1898 #ifdef CLOCKS_PER_SEC
1899         /*
1900          * "To determine the time in seconds, the value returned by the clock
1901          * function should be divided by the value of the macro
1902          * CLOCKS_PER_SEC." -- ISO/IEC 9899
1903          */
1904         BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1905                    "Approximate total client time: %6.2f s\n",
1906                    (double)s_time / CLOCKS_PER_SEC,
1907                    (double)c_time / CLOCKS_PER_SEC);
1908 #else
1909         BIO_printf(bio_stdout,
1910                    "Approximate total server time: %6.2f units\n"
1911                    "Approximate total client time: %6.2f units\n",
1912                    (double)s_time, (double)c_time);
1913 #endif
1914     }
1915
1916  err:
1917     SSL_free(s_ssl);
1918     SSL_free(c_ssl);
1919
1920  end:
1921     SSL_CTX_free(s_ctx);
1922     SSL_CTX_free(s_ctx2);
1923     SSL_CTX_free(c_ctx);
1924     SSL_CONF_CTX_free(s_cctx);
1925     SSL_CONF_CTX_free(s_cctx2);
1926     SSL_CONF_CTX_free(c_cctx);
1927     sk_OPENSSL_STRING_free(conf_args);
1928
1929     BIO_free(bio_stdout);
1930
1931     SSL_SESSION_free(server_sess);
1932     SSL_SESSION_free(client_sess);
1933
1934 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
1935     if (CRYPTO_mem_leaks(bio_err) <= 0)
1936         ret = 1;
1937 #endif
1938     BIO_free(bio_err);
1939     EXIT(ret);
1940 }
1941
1942 #ifndef OPENSSL_NO_SOCK
1943 int doit_localhost(SSL *s_ssl, SSL *c_ssl, int family, long count,
1944                    clock_t *s_time, clock_t *c_time)
1945 {
1946     long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1947     BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1948     BIO *acpt = NULL, *server = NULL, *client = NULL;
1949     char addr_str[40];
1950     int ret = 1;
1951     int err_in_client = 0;
1952     int err_in_server = 0;
1953
1954     acpt = BIO_new_accept("0");
1955     if (acpt == NULL)
1956         goto err;
1957     BIO_set_accept_ip_family(acpt, family);
1958     BIO_set_bind_mode(acpt, BIO_SOCK_NONBLOCK | BIO_SOCK_REUSEADDR);
1959     if (BIO_do_accept(acpt) <= 0)
1960         goto err;
1961
1962     BIO_snprintf(addr_str, sizeof(addr_str), ":%s", BIO_get_accept_port(acpt));
1963
1964     client = BIO_new_connect(addr_str);
1965     BIO_set_conn_ip_family(client, family);
1966     if (!client)
1967         goto err;
1968
1969     if (BIO_set_nbio(client, 1) <= 0)
1970         goto err;
1971     if (BIO_set_nbio(acpt, 1) <= 0)
1972         goto err;
1973
1974     {
1975         int st_connect = 0, st_accept = 0;
1976
1977         while(!st_connect || !st_accept) {
1978             if (!st_connect) {
1979                 if (BIO_do_connect(client) <= 0) {
1980                     if (!BIO_should_retry(client))
1981                         goto err;
1982                 } else {
1983                     st_connect = 1;
1984                 }
1985             }
1986             if (!st_accept) {
1987                 if (BIO_do_accept(acpt) <= 0) {
1988                     if (!BIO_should_retry(acpt))
1989                         goto err;
1990                 } else {
1991                     st_accept = 1;
1992                 }
1993             }
1994         }
1995     }
1996     /* We're not interested in accepting further connects */
1997     server = BIO_pop(acpt);
1998     BIO_free_all(acpt);
1999     acpt = NULL;
2000
2001     s_ssl_bio = BIO_new(BIO_f_ssl());
2002     if (!s_ssl_bio)
2003         goto err;
2004
2005     c_ssl_bio = BIO_new(BIO_f_ssl());
2006     if (!c_ssl_bio)
2007         goto err;
2008
2009     SSL_set_connect_state(c_ssl);
2010     SSL_set_bio(c_ssl, client, client);
2011     (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
2012
2013     SSL_set_accept_state(s_ssl);
2014     SSL_set_bio(s_ssl, server, server);
2015     (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
2016
2017     do {
2018         /*-
2019          * c_ssl_bio:          SSL filter BIO
2020          *
2021          * client:             I/O for SSL library
2022          *
2023          *
2024          * server:             I/O for SSL library
2025          *
2026          * s_ssl_bio:          SSL filter BIO
2027          */
2028
2029         /*
2030          * We have non-blocking behaviour throughout this test program, but
2031          * can be sure that there is *some* progress in each iteration; so we
2032          * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
2033          * we just try everything in each iteration
2034          */
2035
2036         {
2037             /* CLIENT */
2038
2039             char cbuf[1024 * 8];
2040             int i, r;
2041             clock_t c_clock = clock();
2042
2043             memset(cbuf, 0, sizeof(cbuf));
2044
2045             if (debug)
2046                 if (SSL_in_init(c_ssl))
2047                     printf("client waiting in SSL_connect - %s\n",
2048                            SSL_state_string_long(c_ssl));
2049
2050             if (cw_num > 0) {
2051                 /* Write to server. */
2052
2053                 if (cw_num > (long)sizeof cbuf)
2054                     i = sizeof cbuf;
2055                 else
2056                     i = (int)cw_num;
2057                 r = BIO_write(c_ssl_bio, cbuf, i);
2058                 if (r < 0) {
2059                     if (!BIO_should_retry(c_ssl_bio)) {
2060                         fprintf(stderr, "ERROR in CLIENT\n");
2061                         err_in_client = 1;
2062                         goto err;
2063                     }
2064                     /*
2065                      * BIO_should_retry(...) can just be ignored here. The
2066                      * library expects us to call BIO_write with the same
2067                      * arguments again, and that's what we will do in the
2068                      * next iteration.
2069                      */
2070                 } else if (r == 0) {
2071                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2072                     goto err;
2073                 } else {
2074                     if (debug)
2075                         printf("client wrote %d\n", r);
2076                     cw_num -= r;
2077                 }
2078             }
2079
2080             if (cr_num > 0) {
2081                 /* Read from server. */
2082
2083                 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
2084                 if (r < 0) {
2085                     if (!BIO_should_retry(c_ssl_bio)) {
2086                         fprintf(stderr, "ERROR in CLIENT\n");
2087                         err_in_client = 1;
2088                         goto err;
2089                     }
2090                     /*
2091                      * Again, "BIO_should_retry" can be ignored.
2092                      */
2093                 } else if (r == 0) {
2094                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2095                     goto err;
2096                 } else {
2097                     if (debug)
2098                         printf("client read %d\n", r);
2099                     cr_num -= r;
2100                 }
2101             }
2102
2103             /*
2104              * c_time and s_time increments will typically be very small
2105              * (depending on machine speed and clock tick intervals), but
2106              * sampling over a large number of connections should result in
2107              * fairly accurate figures.  We cannot guarantee a lot, however
2108              * -- if each connection lasts for exactly one clock tick, it
2109              * will be counted only for the client or only for the server or
2110              * even not at all.
2111              */
2112             *c_time += (clock() - c_clock);
2113         }
2114
2115         {
2116             /* SERVER */
2117
2118             char sbuf[1024 * 8];
2119             int i, r;
2120             clock_t s_clock = clock();
2121
2122             memset(sbuf, 0, sizeof(sbuf));
2123
2124             if (debug)
2125                 if (SSL_in_init(s_ssl))
2126                     printf("server waiting in SSL_accept - %s\n",
2127                            SSL_state_string_long(s_ssl));
2128
2129             if (sw_num > 0) {
2130                 /* Write to client. */
2131
2132                 if (sw_num > (long)sizeof sbuf)
2133                     i = sizeof sbuf;
2134                 else
2135                     i = (int)sw_num;
2136                 r = BIO_write(s_ssl_bio, sbuf, i);
2137                 if (r < 0) {
2138                     if (!BIO_should_retry(s_ssl_bio)) {
2139                         fprintf(stderr, "ERROR in SERVER\n");
2140                         err_in_server = 1;
2141                         goto err;
2142                     }
2143                     /* Ignore "BIO_should_retry". */
2144                 } else if (r == 0) {
2145                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2146                     goto err;
2147                 } else {
2148                     if (debug)
2149                         printf("server wrote %d\n", r);
2150                     sw_num -= r;
2151                 }
2152             }
2153
2154             if (sr_num > 0) {
2155                 /* Read from client. */
2156
2157                 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2158                 if (r < 0) {
2159                     if (!BIO_should_retry(s_ssl_bio)) {
2160                         fprintf(stderr, "ERROR in SERVER\n");
2161                         err_in_server = 1;
2162                         goto err;
2163                     }
2164                     /* blah, blah */
2165                 } else if (r == 0) {
2166                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2167                     goto err;
2168                 } else {
2169                     if (debug)
2170                         printf("server read %d\n", r);
2171                     sr_num -= r;
2172                 }
2173             }
2174
2175             *s_time += (clock() - s_clock);
2176         }
2177     }
2178     while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2179
2180     if (verbose)
2181         print_details(c_ssl, "DONE via TCP connect: ");
2182 # ifndef OPENSSL_NO_NEXTPROTONEG
2183     if (verify_npn(c_ssl, s_ssl) < 0) {
2184         ret = 1;
2185         goto end;
2186     }
2187 # endif
2188     if (verify_serverinfo() < 0) {
2189         fprintf(stderr, "Server info verify error\n");
2190         ret = 1;
2191         goto err;
2192     }
2193     if (verify_alpn(c_ssl, s_ssl) < 0) {
2194         ret = 1;
2195         goto err;
2196     }
2197     if (verify_servername(c_ssl, s_ssl) < 0) {
2198         ret = 1;
2199         goto err;
2200     }
2201
2202     if (custom_ext_error) {
2203         fprintf(stderr, "Custom extension error\n");
2204         ret = 1;
2205         goto err;
2206     }
2207
2208 # ifndef OPENSSL_NO_NEXTPROTONEG
2209  end:
2210 # endif
2211     ret = 0;
2212
2213  err:
2214     ERR_print_errors(bio_err);
2215
2216     BIO_free_all(acpt);
2217     BIO_free(server);
2218     BIO_free(client);
2219     BIO_free(s_ssl_bio);
2220     BIO_free(c_ssl_bio);
2221
2222     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2223         ret = (err_in_client != 0) ? 0 : 1;
2224     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2225         ret = (err_in_server != 0) ? 0 : 1;
2226
2227     return ret;
2228 }
2229 #endif
2230
2231 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
2232                  clock_t *s_time, clock_t *c_time)
2233 {
2234     long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
2235     BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
2236     BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
2237     int ret = 1;
2238     int err_in_client = 0;
2239     int err_in_server = 0;
2240
2241     size_t bufsiz = 256;        /* small buffer for testing */
2242
2243     if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
2244         goto err;
2245     if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
2246         goto err;
2247
2248     s_ssl_bio = BIO_new(BIO_f_ssl());
2249     if (!s_ssl_bio)
2250         goto err;
2251
2252     c_ssl_bio = BIO_new(BIO_f_ssl());
2253     if (!c_ssl_bio)
2254         goto err;
2255
2256     SSL_set_connect_state(c_ssl);
2257     SSL_set_bio(c_ssl, client, client);
2258     (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
2259
2260     SSL_set_accept_state(s_ssl);
2261     SSL_set_bio(s_ssl, server, server);
2262     (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
2263
2264     do {
2265         /*-
2266          * c_ssl_bio:          SSL filter BIO
2267          *
2268          * client:             pseudo-I/O for SSL library
2269          *
2270          * client_io:          client's SSL communication; usually to be
2271          *                     relayed over some I/O facility, but in this
2272          *                     test program, we're the server, too:
2273          *
2274          * server_io:          server's SSL communication
2275          *
2276          * server:             pseudo-I/O for SSL library
2277          *
2278          * s_ssl_bio:          SSL filter BIO
2279          *
2280          * The client and the server each employ a "BIO pair":
2281          * client + client_io, server + server_io.
2282          * BIO pairs are symmetric.  A BIO pair behaves similar
2283          * to a non-blocking socketpair (but both endpoints must
2284          * be handled by the same thread).
2285          * [Here we could connect client and server to the ends
2286          * of a single BIO pair, but then this code would be less
2287          * suitable as an example for BIO pairs in general.]
2288          *
2289          * Useful functions for querying the state of BIO pair endpoints:
2290          *
2291          * BIO_ctrl_pending(bio)              number of bytes we can read now
2292          * BIO_ctrl_get_read_request(bio)     number of bytes needed to fulfil
2293          *                                      other side's read attempt
2294          * BIO_ctrl_get_write_guarantee(bio)   number of bytes we can write now
2295          *
2296          * ..._read_request is never more than ..._write_guarantee;
2297          * it depends on the application which one you should use.
2298          */
2299
2300         /*
2301          * We have non-blocking behaviour throughout this test program, but
2302          * can be sure that there is *some* progress in each iteration; so we
2303          * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
2304          * we just try everything in each iteration
2305          */
2306
2307         {
2308             /* CLIENT */
2309
2310             char cbuf[1024 * 8];
2311             int i, r;
2312             clock_t c_clock = clock();
2313
2314             memset(cbuf, 0, sizeof(cbuf));
2315
2316             if (debug)
2317                 if (SSL_in_init(c_ssl))
2318                     printf("client waiting in SSL_connect - %s\n",
2319                            SSL_state_string_long(c_ssl));
2320
2321             if (cw_num > 0) {
2322                 /* Write to server. */
2323
2324                 if (cw_num > (long)sizeof cbuf)
2325                     i = sizeof cbuf;
2326                 else
2327                     i = (int)cw_num;
2328                 r = BIO_write(c_ssl_bio, cbuf, i);
2329                 if (r < 0) {
2330                     if (!BIO_should_retry(c_ssl_bio)) {
2331                         fprintf(stderr, "ERROR in CLIENT\n");
2332                         err_in_client = 1;
2333                         goto err;
2334                     }
2335                     /*
2336                      * BIO_should_retry(...) can just be ignored here. The
2337                      * library expects us to call BIO_write with the same
2338                      * arguments again, and that's what we will do in the
2339                      * next iteration.
2340                      */
2341                 } else if (r == 0) {
2342                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2343                     goto err;
2344                 } else {
2345                     if (debug)
2346                         printf("client wrote %d\n", r);
2347                     cw_num -= r;
2348                 }
2349             }
2350
2351             if (cr_num > 0) {
2352                 /* Read from server. */
2353
2354                 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
2355                 if (r < 0) {
2356                     if (!BIO_should_retry(c_ssl_bio)) {
2357                         fprintf(stderr, "ERROR in CLIENT\n");
2358                         err_in_client = 1;
2359                         goto err;
2360                     }
2361                     /*
2362                      * Again, "BIO_should_retry" can be ignored.
2363                      */
2364                 } else if (r == 0) {
2365                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2366                     goto err;
2367                 } else {
2368                     if (debug)
2369                         printf("client read %d\n", r);
2370                     cr_num -= r;
2371                 }
2372             }
2373
2374             /*
2375              * c_time and s_time increments will typically be very small
2376              * (depending on machine speed and clock tick intervals), but
2377              * sampling over a large number of connections should result in
2378              * fairly accurate figures.  We cannot guarantee a lot, however
2379              * -- if each connection lasts for exactly one clock tick, it
2380              * will be counted only for the client or only for the server or
2381              * even not at all.
2382              */
2383             *c_time += (clock() - c_clock);
2384         }
2385
2386         {
2387             /* SERVER */
2388
2389             char sbuf[1024 * 8];
2390             int i, r;
2391             clock_t s_clock = clock();
2392
2393             memset(sbuf, 0, sizeof(sbuf));
2394
2395             if (debug)
2396                 if (SSL_in_init(s_ssl))
2397                     printf("server waiting in SSL_accept - %s\n",
2398                            SSL_state_string_long(s_ssl));
2399
2400             if (sw_num > 0) {
2401                 /* Write to client. */
2402
2403                 if (sw_num > (long)sizeof sbuf)
2404                     i = sizeof sbuf;
2405                 else
2406                     i = (int)sw_num;
2407                 r = BIO_write(s_ssl_bio, sbuf, i);
2408                 if (r < 0) {
2409                     if (!BIO_should_retry(s_ssl_bio)) {
2410                         fprintf(stderr, "ERROR in SERVER\n");
2411                         err_in_server = 1;
2412                         goto err;
2413                     }
2414                     /* Ignore "BIO_should_retry". */
2415                 } else if (r == 0) {
2416                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2417                     goto err;
2418                 } else {
2419                     if (debug)
2420                         printf("server wrote %d\n", r);
2421                     sw_num -= r;
2422                 }
2423             }
2424
2425             if (sr_num > 0) {
2426                 /* Read from client. */
2427
2428                 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2429                 if (r < 0) {
2430                     if (!BIO_should_retry(s_ssl_bio)) {
2431                         fprintf(stderr, "ERROR in SERVER\n");
2432                         err_in_server = 1;
2433                         goto err;
2434                     }
2435                     /* blah, blah */
2436                 } else if (r == 0) {
2437                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2438                     goto err;
2439                 } else {
2440                     if (debug)
2441                         printf("server read %d\n", r);
2442                     sr_num -= r;
2443                 }
2444             }
2445
2446             *s_time += (clock() - s_clock);
2447         }
2448
2449         {
2450             /* "I/O" BETWEEN CLIENT AND SERVER. */
2451
2452             size_t r1, r2;
2453             BIO *io1 = server_io, *io2 = client_io;
2454             /*
2455              * we use the non-copying interface for io1 and the standard
2456              * BIO_write/BIO_read interface for io2
2457              */
2458
2459             static int prev_progress = 1;
2460             int progress = 0;
2461
2462             /* io1 to io2 */
2463             do {
2464                 size_t num;
2465                 int r;
2466
2467                 r1 = BIO_ctrl_pending(io1);
2468                 r2 = BIO_ctrl_get_write_guarantee(io2);
2469
2470                 num = r1;
2471                 if (r2 < num)
2472                     num = r2;
2473                 if (num) {
2474                     char *dataptr;
2475
2476                     if (INT_MAX < num) /* yeah, right */
2477                         num = INT_MAX;
2478
2479                     r = BIO_nread(io1, &dataptr, (int)num);
2480                     assert(r > 0);
2481                     assert(r <= (int)num);
2482                     /*
2483                      * possibly r < num (non-contiguous data)
2484                      */
2485                     num = r;
2486                     r = BIO_write(io2, dataptr, (int)num);
2487                     if (r != (int)num) { /* can't happen */
2488                         fprintf(stderr, "ERROR: BIO_write could not write "
2489                                 "BIO_ctrl_get_write_guarantee() bytes");
2490                         goto err;
2491                     }
2492                     progress = 1;
2493
2494                     if (debug)
2495                         printf((io1 == client_io) ?
2496                                "C->S relaying: %d bytes\n" :
2497                                "S->C relaying: %d bytes\n", (int)num);
2498                 }
2499             }
2500             while (r1 && r2);
2501
2502             /* io2 to io1 */
2503             {
2504                 size_t num;
2505                 int r;
2506
2507                 r1 = BIO_ctrl_pending(io2);
2508                 r2 = BIO_ctrl_get_read_request(io1);
2509                 /*
2510                  * here we could use ..._get_write_guarantee instead of
2511                  * ..._get_read_request, but by using the latter we test
2512                  * restartability of the SSL implementation more thoroughly
2513                  */
2514                 num = r1;
2515                 if (r2 < num)
2516                     num = r2;
2517                 if (num) {
2518                     char *dataptr;
2519
2520                     if (INT_MAX < num)
2521                         num = INT_MAX;
2522
2523                     if (num > 1)
2524                         --num;  /* test restartability even more thoroughly */
2525
2526                     r = BIO_nwrite0(io1, &dataptr);
2527                     assert(r > 0);
2528                     if (r < (int)num)
2529                         num = r;
2530                     r = BIO_read(io2, dataptr, (int)num);
2531                     if (r != (int)num) { /* can't happen */
2532                         fprintf(stderr, "ERROR: BIO_read could not read "
2533                                 "BIO_ctrl_pending() bytes");
2534                         goto err;
2535                     }
2536                     progress = 1;
2537                     r = BIO_nwrite(io1, &dataptr, (int)num);
2538                     if (r != (int)num) { /* can't happen */
2539                         fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
2540                                 "BIO_nwrite0() bytes");
2541                         goto err;
2542                     }
2543
2544                     if (debug)
2545                         printf((io2 == client_io) ?
2546                                "C->S relaying: %d bytes\n" :
2547                                "S->C relaying: %d bytes\n", (int)num);
2548                 }
2549             }                   /* no loop, BIO_ctrl_get_read_request now
2550                                  * returns 0 anyway */
2551
2552             if (!progress && !prev_progress)
2553                 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0) {
2554                     fprintf(stderr, "ERROR: got stuck\n");
2555                     fprintf(stderr, " ERROR.\n");
2556                     goto err;
2557                 }
2558             prev_progress = progress;
2559         }
2560     }
2561     while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2562
2563     if (verbose)
2564         print_details(c_ssl, "DONE via BIO pair: ");
2565 #ifndef OPENSSL_NO_NEXTPROTONEG
2566     if (verify_npn(c_ssl, s_ssl) < 0) {
2567         ret = 1;
2568         goto end;
2569     }
2570 #endif
2571     if (verify_serverinfo() < 0) {
2572         fprintf(stderr, "Server info verify error\n");
2573         ret = 1;
2574         goto err;
2575     }
2576     if (verify_alpn(c_ssl, s_ssl) < 0) {
2577         ret = 1;
2578         goto err;
2579     }
2580     if (verify_servername(c_ssl, s_ssl) < 0) {
2581         ret = 1;
2582         goto err;
2583     }
2584
2585     if (custom_ext_error) {
2586         fprintf(stderr, "Custom extension error\n");
2587         ret = 1;
2588         goto err;
2589     }
2590
2591 #ifndef OPENSSL_NO_NEXTPROTONEG
2592  end:
2593 #endif
2594     ret = 0;
2595
2596  err:
2597     ERR_print_errors(bio_err);
2598
2599     BIO_free(server);
2600     BIO_free(server_io);
2601     BIO_free(client);
2602     BIO_free(client_io);
2603     BIO_free(s_ssl_bio);
2604     BIO_free(c_ssl_bio);
2605
2606     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2607         ret = (err_in_client != 0) ? 0 : 1;
2608     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2609         ret = (err_in_server != 0) ? 0 : 1;
2610
2611     return ret;
2612 }
2613
2614 #define W_READ  1
2615 #define W_WRITE 2
2616 #define C_DONE  1
2617 #define S_DONE  2
2618
2619 int doit(SSL *s_ssl, SSL *c_ssl, long count)
2620 {
2621     char *cbuf = NULL, *sbuf = NULL;
2622     long bufsiz;
2623     long cw_num = count, cr_num = count;
2624     long sw_num = count, sr_num = count;
2625     int ret = 1;
2626     BIO *c_to_s = NULL;
2627     BIO *s_to_c = NULL;
2628     BIO *c_bio = NULL;
2629     BIO *s_bio = NULL;
2630     int c_r, c_w, s_r, s_w;
2631     int i, j;
2632     int done = 0;
2633     int c_write, s_write;
2634     int do_server = 0, do_client = 0;
2635     int max_frag = 5 * 1024;
2636     int err_in_client = 0;
2637     int err_in_server = 0;
2638
2639     bufsiz = count > 40 * 1024 ? 40 * 1024 : count;
2640
2641     if ((cbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2642         goto err;
2643     if ((sbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2644         goto err;
2645
2646     c_to_s = BIO_new(BIO_s_mem());
2647     s_to_c = BIO_new(BIO_s_mem());
2648     if ((s_to_c == NULL) || (c_to_s == NULL)) {
2649         ERR_print_errors(bio_err);
2650         goto err;
2651     }
2652
2653     c_bio = BIO_new(BIO_f_ssl());
2654     s_bio = BIO_new(BIO_f_ssl());
2655     if ((c_bio == NULL) || (s_bio == NULL)) {
2656         ERR_print_errors(bio_err);
2657         goto err;
2658     }
2659
2660     SSL_set_connect_state(c_ssl);
2661     SSL_set_bio(c_ssl, s_to_c, c_to_s);
2662     SSL_set_max_send_fragment(c_ssl, max_frag);
2663     BIO_set_ssl(c_bio, c_ssl, BIO_NOCLOSE);
2664
2665     /*
2666      * We've just given our ref to these BIOs to c_ssl. We need another one to
2667      * give to s_ssl
2668      */
2669     if (!BIO_up_ref(c_to_s)) {
2670         /* c_to_s and s_to_c will get freed when we free c_ssl */
2671         c_to_s = NULL;
2672         s_to_c = NULL;
2673         goto err;
2674     }
2675     if (!BIO_up_ref(s_to_c)) {
2676         /* s_to_c will get freed when we free c_ssl */
2677         s_to_c = NULL;
2678         goto err;
2679     }
2680
2681     SSL_set_accept_state(s_ssl);
2682     SSL_set_bio(s_ssl, c_to_s, s_to_c);
2683
2684     /* We've used up all our refs to these now */
2685     c_to_s = NULL;
2686     s_to_c = NULL;
2687
2688     SSL_set_max_send_fragment(s_ssl, max_frag);
2689     BIO_set_ssl(s_bio, s_ssl, BIO_NOCLOSE);
2690
2691     c_r = 0;
2692     s_r = 1;
2693     c_w = 1;
2694     s_w = 0;
2695     c_write = 1, s_write = 0;
2696
2697     /* We can always do writes */
2698     for (;;) {
2699         do_server = 0;
2700         do_client = 0;
2701
2702         i = (int)BIO_pending(s_bio);
2703         if ((i && s_r) || s_w)
2704             do_server = 1;
2705
2706         i = (int)BIO_pending(c_bio);
2707         if ((i && c_r) || c_w)
2708             do_client = 1;
2709
2710         if (do_server && debug) {
2711             if (SSL_in_init(s_ssl))
2712                 printf("server waiting in SSL_accept - %s\n",
2713                        SSL_state_string_long(s_ssl));
2714 /*-
2715             else if (s_write)
2716                 printf("server:SSL_write()\n");
2717             else
2718                 printf("server:SSL_read()\n"); */
2719         }
2720
2721         if (do_client && debug) {
2722             if (SSL_in_init(c_ssl))
2723                 printf("client waiting in SSL_connect - %s\n",
2724                        SSL_state_string_long(c_ssl));
2725 /*-
2726             else if (c_write)
2727                 printf("client:SSL_write()\n");
2728             else
2729                 printf("client:SSL_read()\n"); */
2730         }
2731
2732         if (!do_client && !do_server) {
2733             fprintf(stdout, "ERROR IN STARTUP\n");
2734             ERR_print_errors(bio_err);
2735             goto err;
2736         }
2737         if (do_client && !(done & C_DONE)) {
2738             if (c_write) {
2739                 j = (cw_num > bufsiz) ? (int)bufsiz : (int)cw_num;
2740                 i = BIO_write(c_bio, cbuf, j);
2741                 if (i < 0) {
2742                     c_r = 0;
2743                     c_w = 0;
2744                     if (BIO_should_retry(c_bio)) {
2745                         if (BIO_should_read(c_bio))
2746                             c_r = 1;
2747                         if (BIO_should_write(c_bio))
2748                             c_w = 1;
2749                     } else {
2750                         fprintf(stderr, "ERROR in CLIENT\n");
2751                         err_in_client = 1;
2752                         ERR_print_errors(bio_err);
2753                         goto err;
2754                     }
2755                 } else if (i == 0) {
2756                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2757                     goto err;
2758                 } else {
2759                     if (debug)
2760                         printf("client wrote %d\n", i);
2761                     /* ok */
2762                     s_r = 1;
2763                     c_write = 0;
2764                     cw_num -= i;
2765                     if (max_frag > 1029)
2766                         SSL_set_max_send_fragment(c_ssl, max_frag -= 5);
2767                 }
2768             } else {
2769                 i = BIO_read(c_bio, cbuf, bufsiz);
2770                 if (i < 0) {
2771                     c_r = 0;
2772                     c_w = 0;
2773                     if (BIO_should_retry(c_bio)) {
2774                         if (BIO_should_read(c_bio))
2775                             c_r = 1;
2776                         if (BIO_should_write(c_bio))
2777                             c_w = 1;
2778                     } else {
2779                         fprintf(stderr, "ERROR in CLIENT\n");
2780                         err_in_client = 1;
2781                         ERR_print_errors(bio_err);
2782                         goto err;
2783                     }
2784                 } else if (i == 0) {
2785                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2786                     goto err;
2787                 } else {
2788                     if (debug)
2789                         printf("client read %d\n", i);
2790                     cr_num -= i;
2791                     if (sw_num > 0) {
2792                         s_write = 1;
2793                         s_w = 1;
2794                     }
2795                     if (cr_num <= 0) {
2796                         s_write = 1;
2797                         s_w = 1;
2798                         done = S_DONE | C_DONE;
2799                     }
2800                 }
2801             }
2802         }
2803
2804         if (do_server && !(done & S_DONE)) {
2805             if (!s_write) {
2806                 i = BIO_read(s_bio, sbuf, bufsiz);
2807                 if (i < 0) {
2808                     s_r = 0;
2809                     s_w = 0;
2810                     if (BIO_should_retry(s_bio)) {
2811                         if (BIO_should_read(s_bio))
2812                             s_r = 1;
2813                         if (BIO_should_write(s_bio))
2814                             s_w = 1;
2815                     } else {
2816                         fprintf(stderr, "ERROR in SERVER\n");
2817                         err_in_server = 1;
2818                         ERR_print_errors(bio_err);
2819                         goto err;
2820                     }
2821                 } else if (i == 0) {
2822                     ERR_print_errors(bio_err);
2823                     fprintf(stderr,
2824                             "SSL SERVER STARTUP FAILED in SSL_read\n");
2825                     goto err;
2826                 } else {
2827                     if (debug)
2828                         printf("server read %d\n", i);
2829                     sr_num -= i;
2830                     if (cw_num > 0) {
2831                         c_write = 1;
2832                         c_w = 1;
2833                     }
2834                     if (sr_num <= 0) {
2835                         s_write = 1;
2836                         s_w = 1;
2837                         c_write = 0;
2838                     }
2839                 }
2840             } else {
2841                 j = (sw_num > bufsiz) ? (int)bufsiz : (int)sw_num;
2842                 i = BIO_write(s_bio, sbuf, j);
2843                 if (i < 0) {
2844                     s_r = 0;
2845                     s_w = 0;
2846                     if (BIO_should_retry(s_bio)) {
2847                         if (BIO_should_read(s_bio))
2848                             s_r = 1;
2849                         if (BIO_should_write(s_bio))
2850                             s_w = 1;
2851                     } else {
2852                         fprintf(stderr, "ERROR in SERVER\n");
2853                         err_in_server = 1;
2854                         ERR_print_errors(bio_err);
2855                         goto err;
2856                     }
2857                 } else if (i == 0) {
2858                     ERR_print_errors(bio_err);
2859                     fprintf(stderr,
2860                             "SSL SERVER STARTUP FAILED in SSL_write\n");
2861                     goto err;
2862                 } else {
2863                     if (debug)
2864                         printf("server wrote %d\n", i);
2865                     sw_num -= i;
2866                     s_write = 0;
2867                     c_r = 1;
2868                     if (sw_num <= 0)
2869                         done |= S_DONE;
2870                     if (max_frag > 1029)
2871                         SSL_set_max_send_fragment(s_ssl, max_frag -= 5);
2872                 }
2873             }
2874         }
2875
2876         if ((done & S_DONE) && (done & C_DONE))
2877             break;
2878     }
2879
2880     if (verbose)
2881         print_details(c_ssl, "DONE: ");
2882 #ifndef OPENSSL_NO_NEXTPROTONEG
2883     if (verify_npn(c_ssl, s_ssl) < 0) {
2884         ret = 1;
2885         goto err;
2886     }
2887 #endif
2888     if (verify_serverinfo() < 0) {
2889         fprintf(stderr, "Server info verify error\n");
2890         ret = 1;
2891         goto err;
2892     }
2893     if (custom_ext_error) {
2894         fprintf(stderr, "Custom extension error\n");
2895         ret = 1;
2896         goto err;
2897     }
2898     ret = 0;
2899  err:
2900     BIO_free(c_to_s);
2901     BIO_free(s_to_c);
2902     BIO_free_all(c_bio);
2903     BIO_free_all(s_bio);
2904     OPENSSL_free(cbuf);
2905     OPENSSL_free(sbuf);
2906
2907     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2908         ret = (err_in_client != 0) ? 0 : 1;
2909     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2910         ret = (err_in_server != 0) ? 0 : 1;
2911
2912     return (ret);
2913 }
2914
2915 static int verify_callback(int ok, X509_STORE_CTX *ctx)
2916 {
2917     char *s, buf[256];
2918
2919     s = X509_NAME_oneline(X509_get_subject_name(X509_STORE_CTX_get_current_cert(ctx)),
2920                           buf, sizeof buf);
2921     if (s != NULL) {
2922         if (ok)
2923             printf("depth=%d %s\n", X509_STORE_CTX_get_error_depth(ctx), buf);
2924         else {
2925             fprintf(stderr, "depth=%d error=%d %s\n",
2926                     X509_STORE_CTX_get_error_depth(ctx),
2927                     X509_STORE_CTX_get_error(ctx), buf);
2928         }
2929     }
2930
2931     if (ok == 0) {
2932         int i = X509_STORE_CTX_get_error(ctx);
2933
2934         switch (i) {
2935         default:
2936             fprintf(stderr, "Error string: %s\n",
2937                     X509_verify_cert_error_string(i));
2938             break;
2939         case X509_V_ERR_CERT_NOT_YET_VALID:
2940         case X509_V_ERR_CERT_HAS_EXPIRED:
2941         case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2942             ok = 1;
2943             break;
2944         }
2945     }
2946
2947     return (ok);
2948 }
2949
2950 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2951 {
2952     int ok = 1;
2953     struct app_verify_arg *cb_arg = arg;
2954
2955     if (cb_arg->app_verify) {
2956         char *s = NULL, buf[256];
2957         X509 *c = X509_STORE_CTX_get0_cert(ctx);
2958
2959         printf("In app_verify_callback, allowing cert. ");
2960         printf("Arg is: %s\n", cb_arg->string);
2961         printf("Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2962                 (void *)ctx, (void *)c);
2963         if (c)
2964             s = X509_NAME_oneline(X509_get_subject_name(c), buf, 256);
2965         if (s != NULL) {
2966             printf("cert depth=%d %s\n",
2967                     X509_STORE_CTX_get_error_depth(ctx), buf);
2968         }
2969         return (1);
2970     }
2971
2972     ok = X509_verify_cert(ctx);
2973
2974     return (ok);
2975 }
2976
2977 #ifndef OPENSSL_NO_DH
2978 /*-
2979  * These DH parameters have been generated as follows:
2980  *    $ openssl dhparam -C -noout 512
2981  *    $ openssl dhparam -C -noout 1024
2982  *    $ openssl dhparam -C -noout -dsaparam 1024
2983  * (The third function has been renamed to avoid name conflicts.)
2984  */
2985 static DH *get_dh512()
2986 {
2987     static unsigned char dh512_p[] = {
2988         0xCB, 0xC8, 0xE1, 0x86, 0xD0, 0x1F, 0x94, 0x17, 0xA6, 0x99, 0xF0,
2989         0xC6,
2990         0x1F, 0x0D, 0xAC, 0xB6, 0x25, 0x3E, 0x06, 0x39, 0xCA, 0x72, 0x04,
2991         0xB0,
2992         0x6E, 0xDA, 0xC0, 0x61, 0xE6, 0x7A, 0x77, 0x25, 0xE8, 0x3B, 0xB9,
2993         0x5F,
2994         0x9A, 0xB6, 0xB5, 0xFE, 0x99, 0x0B, 0xA1, 0x93, 0x4E, 0x35, 0x33,
2995         0xB8,
2996         0xE1, 0xF1, 0x13, 0x4F, 0x59, 0x1A, 0xD2, 0x57, 0xC0, 0x26, 0x21,
2997         0x33,
2998         0x02, 0xC5, 0xAE, 0x23,
2999     };
3000     static unsigned char dh512_g[] = {
3001         0x02,
3002     };
3003     DH *dh;
3004     BIGNUM *p, *g;
3005
3006     if ((dh = DH_new()) == NULL)
3007         return (NULL);
3008     p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
3009     g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
3010     if ((p == NULL) || (g == NULL) || !DH_set0_pqg(dh, p, NULL, g)) {
3011         DH_free(dh);
3012         BN_free(p);
3013         BN_free(g);
3014         return (NULL);
3015     }
3016     return (dh);
3017 }
3018
3019 static DH *get_dh1024()
3020 {
3021     static unsigned char dh1024_p[] = {
3022         0xF8, 0x81, 0x89, 0x7D, 0x14, 0x24, 0xC5, 0xD1, 0xE6, 0xF7, 0xBF,
3023         0x3A,
3024         0xE4, 0x90, 0xF4, 0xFC, 0x73, 0xFB, 0x34, 0xB5, 0xFA, 0x4C, 0x56,
3025         0xA2,
3026         0xEA, 0xA7, 0xE9, 0xC0, 0xC0, 0xCE, 0x89, 0xE1, 0xFA, 0x63, 0x3F,
3027         0xB0,
3028         0x6B, 0x32, 0x66, 0xF1, 0xD1, 0x7B, 0xB0, 0x00, 0x8F, 0xCA, 0x87,
3029         0xC2,
3030         0xAE, 0x98, 0x89, 0x26, 0x17, 0xC2, 0x05, 0xD2, 0xEC, 0x08, 0xD0,
3031         0x8C,
3032         0xFF, 0x17, 0x52, 0x8C, 0xC5, 0x07, 0x93, 0x03, 0xB1, 0xF6, 0x2F,
3033         0xB8,
3034         0x1C, 0x52, 0x47, 0x27, 0x1B, 0xDB, 0xD1, 0x8D, 0x9D, 0x69, 0x1D,
3035         0x52,
3036         0x4B, 0x32, 0x81, 0xAA, 0x7F, 0x00, 0xC8, 0xDC, 0xE6, 0xD9, 0xCC,
3037         0xC1,
3038         0x11, 0x2D, 0x37, 0x34, 0x6C, 0xEA, 0x02, 0x97, 0x4B, 0x0E, 0xBB,
3039         0xB1,
3040         0x71, 0x33, 0x09, 0x15, 0xFD, 0xDD, 0x23, 0x87, 0x07, 0x5E, 0x89,
3041         0xAB,
3042         0x6B, 0x7C, 0x5F, 0xEC, 0xA6, 0x24, 0xDC, 0x53,
3043     };
3044     static unsigned char dh1024_g[] = {
3045         0x02,
3046     };
3047     DH *dh;
3048     BIGNUM *p, *g;
3049
3050     if ((dh = DH_new()) == NULL)
3051         return (NULL);
3052     p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
3053     g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
3054     if ((p == NULL) || (g == NULL) || !DH_set0_pqg(dh, p, NULL, g)) {
3055         DH_free(dh);
3056         BN_free(p);
3057         BN_free(g);
3058         return (NULL);
3059     }
3060     return (dh);
3061 }
3062
3063 static DH *get_dh1024dsa()
3064 {
3065     static unsigned char dh1024_p[] = {
3066         0xC8, 0x00, 0xF7, 0x08, 0x07, 0x89, 0x4D, 0x90, 0x53, 0xF3, 0xD5,
3067         0x00,
3068         0x21, 0x1B, 0xF7, 0x31, 0xA6, 0xA2, 0xDA, 0x23, 0x9A, 0xC7, 0x87,
3069         0x19,
3070         0x3B, 0x47, 0xB6, 0x8C, 0x04, 0x6F, 0xFF, 0xC6, 0x9B, 0xB8, 0x65,
3071         0xD2,
3072         0xC2, 0x5F, 0x31, 0x83, 0x4A, 0xA7, 0x5F, 0x2F, 0x88, 0x38, 0xB6,
3073         0x55,
3074         0xCF, 0xD9, 0x87, 0x6D, 0x6F, 0x9F, 0xDA, 0xAC, 0xA6, 0x48, 0xAF,
3075         0xFC,
3076         0x33, 0x84, 0x37, 0x5B, 0x82, 0x4A, 0x31, 0x5D, 0xE7, 0xBD, 0x52,
3077         0x97,
3078         0xA1, 0x77, 0xBF, 0x10, 0x9E, 0x37, 0xEA, 0x64, 0xFA, 0xCA, 0x28,
3079         0x8D,
3080         0x9D, 0x3B, 0xD2, 0x6E, 0x09, 0x5C, 0x68, 0xC7, 0x45, 0x90, 0xFD,
3081         0xBB,
3082         0x70, 0xC9, 0x3A, 0xBB, 0xDF, 0xD4, 0x21, 0x0F, 0xC4, 0x6A, 0x3C,
3083         0xF6,
3084         0x61, 0xCF, 0x3F, 0xD6, 0x13, 0xF1, 0x5F, 0xBC, 0xCF, 0xBC, 0x26,
3085         0x9E,
3086         0xBC, 0x0B, 0xBD, 0xAB, 0x5D, 0xC9, 0x54, 0x39,
3087     };
3088     static unsigned char dh1024_g[] = {
3089         0x3B, 0x40, 0x86, 0xE7, 0xF3, 0x6C, 0xDE, 0x67, 0x1C, 0xCC, 0x80,
3090         0x05,
3091         0x5A, 0xDF, 0xFE, 0xBD, 0x20, 0x27, 0x74, 0x6C, 0x24, 0xC9, 0x03,
3092         0xF3,
3093         0xE1, 0x8D, 0xC3, 0x7D, 0x98, 0x27, 0x40, 0x08, 0xB8, 0x8C, 0x6A,
3094         0xE9,
3095         0xBB, 0x1A, 0x3A, 0xD6, 0x86, 0x83, 0x5E, 0x72, 0x41, 0xCE, 0x85,
3096         0x3C,
3097         0xD2, 0xB3, 0xFC, 0x13, 0xCE, 0x37, 0x81, 0x9E, 0x4C, 0x1C, 0x7B,
3098         0x65,
3099         0xD3, 0xE6, 0xA6, 0x00, 0xF5, 0x5A, 0x95, 0x43, 0x5E, 0x81, 0xCF,
3100         0x60,
3101         0xA2, 0x23, 0xFC, 0x36, 0xA7, 0x5D, 0x7A, 0x4C, 0x06, 0x91, 0x6E,
3102         0xF6,
3103         0x57, 0xEE, 0x36, 0xCB, 0x06, 0xEA, 0xF5, 0x3D, 0x95, 0x49, 0xCB,
3104         0xA7,
3105         0xDD, 0x81, 0xDF, 0x80, 0x09, 0x4A, 0x97, 0x4D, 0xA8, 0x22, 0x72,
3106         0xA1,
3107         0x7F, 0xC4, 0x70, 0x56, 0x70, 0xE8, 0x20, 0x10, 0x18, 0x8F, 0x2E,
3108         0x60,
3109         0x07, 0xE7, 0x68, 0x1A, 0x82, 0x5D, 0x32, 0xA2,
3110     };
3111     DH *dh;
3112     BIGNUM *p, *g;
3113
3114     if ((dh = DH_new()) == NULL)
3115         return (NULL);
3116     p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
3117     g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
3118     if ((p == NULL) || (g == NULL) || !DH_set0_pqg(dh, p, NULL, g)) {
3119         DH_free(dh);
3120         BN_free(p);
3121         BN_free(g);
3122         return (NULL);
3123     }
3124     DH_set_length(dh, 160);
3125     return (dh);
3126 }
3127 #endif
3128
3129 #ifndef OPENSSL_NO_PSK
3130 /* convert the PSK key (psk_key) in ascii to binary (psk) */
3131 static int psk_key2bn(const char *pskkey, unsigned char *psk,
3132                       unsigned int max_psk_len)
3133 {
3134     int ret;
3135     BIGNUM *bn = NULL;
3136
3137     ret = BN_hex2bn(&bn, pskkey);
3138     if (!ret) {
3139         BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
3140                    pskkey);
3141         BN_free(bn);
3142         return 0;
3143     }
3144     if (BN_num_bytes(bn) > (int)max_psk_len) {
3145         BIO_printf(bio_err,
3146                    "psk buffer of callback is too small (%d) for key (%d)\n",
3147                    max_psk_len, BN_num_bytes(bn));
3148         BN_free(bn);
3149         return 0;
3150     }
3151     ret = BN_bn2bin(bn, psk);
3152     BN_free(bn);
3153     return ret;
3154 }
3155
3156 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
3157                                         char *identity,
3158                                         unsigned int max_identity_len,
3159                                         unsigned char *psk,
3160                                         unsigned int max_psk_len)
3161 {
3162     int ret;
3163     unsigned int psk_len = 0;
3164
3165     ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3166     if (ret < 0)
3167         goto out_err;
3168     if (debug)
3169         fprintf(stderr, "client: created identity '%s' len=%d\n", identity,
3170                 ret);
3171     ret = psk_key2bn(psk_key, psk, max_psk_len);
3172     if (ret < 0)
3173         goto out_err;
3174     psk_len = ret;
3175  out_err:
3176     return psk_len;
3177 }
3178
3179 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3180                                         unsigned char *psk,
3181                                         unsigned int max_psk_len)
3182 {
3183     unsigned int psk_len = 0;
3184
3185     if (strcmp(identity, "Client_identity") != 0) {
3186         BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3187         return 0;
3188     }
3189     psk_len = psk_key2bn(psk_key, psk, max_psk_len);
3190     return psk_len;
3191 }
3192 #endif