test/ssltest_old.c

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