test/ssltest_old.c

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