test/ssltest_old.c

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