test/ssltest_old.c

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