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