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