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