test/ssltest_old.c

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