test/ssltest_old.c

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