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 #ifndef OPENSSL_NO_CT
1061     /*
1062      * Disable CT validation by default, because it will interfere with
1063      * anything using custom extension handlers to deal with SCT extensions.
1064      */
1065     ct_validation_cb ct_validation = NULL;
1066 #endif
1067     SSL_CONF_CTX *s_cctx = NULL, *c_cctx = NULL, *s_cctx2 = NULL;
1068     STACK_OF(OPENSSL_STRING) *conf_args = NULL;
1069     char *arg = NULL, *argn = NULL;
1070
1071     verbose = 0;
1072     debug = 0;
1073     cipher = 0;
1074
1075     bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
1076
1077     p = getenv("OPENSSL_DEBUG_MEMORY");
1078     if (p != NULL && strcmp(p, "on") == 0)
1079         CRYPTO_set_mem_debug(1);
1080     CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
1081
1082     RAND_seed(rnd_seed, sizeof rnd_seed);
1083
1084     bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);
1085
1086     s_cctx = SSL_CONF_CTX_new();
1087     s_cctx2 = SSL_CONF_CTX_new();
1088     c_cctx = SSL_CONF_CTX_new();
1089
1090     if (!s_cctx || !c_cctx || !s_cctx2) {
1091         ERR_print_errors(bio_err);
1092         goto end;
1093     }
1094
1095     SSL_CONF_CTX_set_flags(s_cctx,
1096                            SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_SERVER |
1097                            SSL_CONF_FLAG_CERTIFICATE |
1098                            SSL_CONF_FLAG_REQUIRE_PRIVATE);
1099     SSL_CONF_CTX_set_flags(s_cctx2,
1100                            SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_SERVER |
1101                            SSL_CONF_FLAG_CERTIFICATE |
1102                            SSL_CONF_FLAG_REQUIRE_PRIVATE);
1103     if (!SSL_CONF_CTX_set1_prefix(s_cctx, "-s_")) {
1104         ERR_print_errors(bio_err);
1105         goto end;
1106     }
1107     if (!SSL_CONF_CTX_set1_prefix(s_cctx2, "-s_")) {
1108         ERR_print_errors(bio_err);
1109         goto end;
1110     }
1111
1112     SSL_CONF_CTX_set_flags(c_cctx,
1113                            SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_CLIENT |
1114                            SSL_CONF_FLAG_CERTIFICATE |
1115                            SSL_CONF_FLAG_REQUIRE_PRIVATE);
1116     if (!SSL_CONF_CTX_set1_prefix(c_cctx, "-c_")) {
1117         ERR_print_errors(bio_err);
1118         goto end;
1119     }
1120
1121     argc--;
1122     argv++;
1123
1124     while (argc >= 1) {
1125         if (strcmp(*argv, "-F") == 0) {
1126 #ifdef OPENSSL_FIPS
1127             fips_mode = 1;
1128 #else
1129             fprintf(stderr,
1130                     "not compiled with FIPS support, so exiting without running.\n");
1131             EXIT(0);
1132 #endif
1133         } else if (strcmp(*argv, "-server_auth") == 0)
1134             server_auth = 1;
1135         else if (strcmp(*argv, "-client_auth") == 0)
1136             client_auth = 1;
1137         else if (strcmp(*argv, "-proxy_auth") == 0) {
1138             if (--argc < 1)
1139                 goto bad;
1140             app_verify_arg.proxy_auth = *(++argv);
1141         } else if (strcmp(*argv, "-proxy_cond") == 0) {
1142             if (--argc < 1)
1143                 goto bad;
1144             app_verify_arg.proxy_cond = *(++argv);
1145         } else if (strcmp(*argv, "-v") == 0)
1146             verbose = 1;
1147         else if (strcmp(*argv, "-d") == 0)
1148             debug = 1;
1149         else if (strcmp(*argv, "-reuse") == 0)
1150             reuse = 1;
1151         else if (strcmp(*argv, "-dhe512") == 0) {
1152 #ifndef OPENSSL_NO_DH
1153             dhe512 = 1;
1154 #else
1155             fprintf(stderr,
1156                     "ignoring -dhe512, since I'm compiled without DH\n");
1157 #endif
1158         } else if (strcmp(*argv, "-dhe1024dsa") == 0) {
1159 #ifndef OPENSSL_NO_DH
1160             dhe1024dsa = 1;
1161 #else
1162             fprintf(stderr,
1163                     "ignoring -dhe1024dsa, since I'm compiled without DH\n");
1164 #endif
1165         } else if (strcmp(*argv, "-no_dhe") == 0)
1166             no_dhe = 1;
1167         else if (strcmp(*argv, "-no_ecdhe") == 0)
1168             /* obsolete */;
1169         else if (strcmp(*argv, "-psk") == 0) {
1170             if (--argc < 1)
1171                 goto bad;
1172             psk_key = *(++argv);
1173 #ifndef OPENSSL_NO_PSK
1174             if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key)) {
1175                 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
1176                 goto bad;
1177             }
1178 #else
1179             no_psk = 1;
1180 #endif
1181         }
1182 #ifndef OPENSSL_NO_SRP
1183         else if (strcmp(*argv, "-srpuser") == 0) {
1184             if (--argc < 1)
1185                 goto bad;
1186             srp_server_arg.expected_user = srp_client_arg.srplogin =
1187                 *(++argv);
1188             min_version = TLS1_VERSION;
1189         } else if (strcmp(*argv, "-srppass") == 0) {
1190             if (--argc < 1)
1191                 goto bad;
1192             srp_server_arg.pass = srp_client_arg.srppassin = *(++argv);
1193             min_version = TLS1_VERSION;
1194         }
1195 #endif
1196         else if (strcmp(*argv, "-tls1") == 0) {
1197             tls1 = 1;
1198         } else if (strcmp(*argv, "-ssl3") == 0) {
1199             ssl3 = 1;
1200         } else if (strcmp(*argv, "-dtls1") == 0) {
1201             dtls1 = 1;
1202         } else if (strcmp(*argv, "-dtls12") == 0) {
1203             dtls12 = 1;
1204         } else if (strcmp(*argv, "-dtls") == 0) {
1205             dtls = 1;
1206         } else if (strncmp(*argv, "-num", 4) == 0) {
1207             if (--argc < 1)
1208                 goto bad;
1209             number = atoi(*(++argv));
1210             if (number == 0)
1211                 number = 1;
1212         } else if (strcmp(*argv, "-bytes") == 0) {
1213             if (--argc < 1)
1214                 goto bad;
1215             bytes = atol(*(++argv));
1216             if (bytes == 0L)
1217                 bytes = 1L;
1218             i = strlen(argv[0]);
1219             if (argv[0][i - 1] == 'k')
1220                 bytes *= 1024L;
1221             if (argv[0][i - 1] == 'm')
1222                 bytes *= 1024L * 1024L;
1223         } else if (strcmp(*argv, "-cipher") == 0) {
1224             if (--argc < 1)
1225                 goto bad;
1226             cipher = *(++argv);
1227         } else if (strcmp(*argv, "-CApath") == 0) {
1228             if (--argc < 1)
1229                 goto bad;
1230             CApath = *(++argv);
1231         } else if (strcmp(*argv, "-CAfile") == 0) {
1232             if (--argc < 1)
1233                 goto bad;
1234             CAfile = *(++argv);
1235         } else if (strcmp(*argv, "-bio_pair") == 0) {
1236             bio_type = BIO_PAIR;
1237         }
1238 #ifndef OPENSSL_NO_SOCK
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         }
1244 #endif
1245         else if (strcmp(*argv, "-f") == 0) {
1246             force = 1;
1247         } else if (strcmp(*argv, "-time") == 0) {
1248             print_time = 1;
1249         }
1250 #ifndef OPENSSL_NO_CT
1251         else if (strcmp(*argv, "-noct") == 0) {
1252             ct_validation = NULL;
1253         }
1254         else if (strcmp(*argv, "-requestct") == 0) {
1255             ct_validation = CT_verify_no_bad_scts;
1256         }
1257         else if (strcmp(*argv, "-requirect") == 0) {
1258             ct_validation = CT_verify_at_least_one_good_sct;
1259         }
1260 #endif
1261 #ifndef OPENSSL_NO_COMP
1262         else if (strcmp(*argv, "-zlib") == 0) {
1263             comp = COMP_ZLIB;
1264         }
1265 #endif
1266         else if (strcmp(*argv, "-app_verify") == 0) {
1267             app_verify_arg.app_verify = 1;
1268         } else if (strcmp(*argv, "-proxy") == 0) {
1269             app_verify_arg.allow_proxy_certs = 1;
1270         } else if (strcmp(*argv, "-test_cipherlist") == 0) {
1271             test_cipherlist = 1;
1272         }
1273 #ifndef OPENSSL_NO_NEXTPROTONEG
1274         else if (strcmp(*argv, "-npn_client") == 0) {
1275             npn_client = 1;
1276         } else if (strcmp(*argv, "-npn_server") == 0) {
1277             npn_server = 1;
1278         } else if (strcmp(*argv, "-npn_server_reject") == 0) {
1279             npn_server_reject = 1;
1280         }
1281 #endif
1282         else if (strcmp(*argv, "-serverinfo_sct") == 0) {
1283             serverinfo_sct = 1;
1284         } else if (strcmp(*argv, "-serverinfo_tack") == 0) {
1285             serverinfo_tack = 1;
1286         } else if (strcmp(*argv, "-serverinfo_file") == 0) {
1287             if (--argc < 1)
1288                 goto bad;
1289             serverinfo_file = *(++argv);
1290         } else if (strcmp(*argv, "-custom_ext") == 0) {
1291             custom_ext = 1;
1292         } else if (strcmp(*argv, "-alpn_client") == 0) {
1293             if (--argc < 1)
1294                 goto bad;
1295             alpn_client = *(++argv);
1296         } else if (strcmp(*argv, "-alpn_server") == 0 ||
1297                    strcmp(*argv, "-alpn_server1") == 0) {
1298             if (--argc < 1)
1299                 goto bad;
1300             alpn_server = *(++argv);
1301         } else if (strcmp(*argv, "-alpn_server2") == 0) {
1302             if (--argc < 1)
1303                 goto bad;
1304             alpn_server2 = *(++argv);
1305         } else if (strcmp(*argv, "-alpn_expected") == 0) {
1306             if (--argc < 1)
1307                 goto bad;
1308             alpn_expected = *(++argv);
1309         } else if (strcmp(*argv, "-server_min_proto") == 0) {
1310             if (--argc < 1)
1311                 goto bad;
1312             server_min_proto = *(++argv);
1313         } else if (strcmp(*argv, "-server_max_proto") == 0) {
1314             if (--argc < 1)
1315                 goto bad;
1316             server_max_proto = *(++argv);
1317         } else if (strcmp(*argv, "-client_min_proto") == 0) {
1318             if (--argc < 1)
1319                 goto bad;
1320             client_min_proto = *(++argv);
1321         } else if (strcmp(*argv, "-client_max_proto") == 0) {
1322             if (--argc < 1)
1323                 goto bad;
1324             client_max_proto = *(++argv);
1325         } else if (strcmp(*argv, "-should_negotiate") == 0) {
1326             if (--argc < 1)
1327                 goto bad;
1328             should_negotiate = *(++argv);
1329         } else if (strcmp(*argv, "-sn_client") == 0) {
1330             if (--argc < 1)
1331                 goto bad;
1332             sn_client = *(++argv);
1333         } else if (strcmp(*argv, "-sn_server1") == 0) {
1334             if (--argc < 1)
1335                 goto bad;
1336             sn_server1 = *(++argv);
1337         } else if (strcmp(*argv, "-sn_server2") == 0) {
1338             if (--argc < 1)
1339                 goto bad;
1340             sn_server2 = *(++argv);
1341         } else if (strcmp(*argv, "-sn_expect1") == 0) {
1342             sn_expect = 1;
1343         } else if (strcmp(*argv, "-sn_expect2") == 0) {
1344             sn_expect = 2;
1345         } else {
1346             int rv;
1347             arg = argv[0];
1348             argn = argv[1];
1349             /* Try to process command using SSL_CONF */
1350             rv = SSL_CONF_cmd_argv(c_cctx, &argc, &argv);
1351             /* If not processed try server */
1352             if (rv == 0)
1353                 rv = SSL_CONF_cmd_argv(s_cctx, &argc, &argv);
1354             /* Recognised: store it for later use */
1355             if (rv > 0) {
1356                 if (rv == 1)
1357                     argn = NULL;
1358                 if (!conf_args) {
1359                     conf_args = sk_OPENSSL_STRING_new_null();
1360                     if (!conf_args)
1361                         goto end;
1362                 }
1363                 if (!sk_OPENSSL_STRING_push(conf_args, arg))
1364                     goto end;
1365                 if (!sk_OPENSSL_STRING_push(conf_args, argn))
1366                     goto end;
1367                 continue;
1368             }
1369             if (rv == -3)
1370                 BIO_printf(bio_err, "Missing argument for %s\n", arg);
1371             else if (rv < 0)
1372                 BIO_printf(bio_err, "Error with command %s\n", arg);
1373             else if (rv == 0)
1374                 BIO_printf(bio_err, "unknown option %s\n", arg);
1375             badop = 1;
1376             break;
1377         }
1378         argc--;
1379         argv++;
1380     }
1381     if (badop) {
1382  bad:
1383         sv_usage();
1384         goto end;
1385     }
1386
1387     /*
1388      * test_cipherlist prevails over protocol switch: we test the cipherlist
1389      * for all enabled protocols.
1390      */
1391     if (test_cipherlist == 1) {
1392         /*
1393          * ensure that the cipher list are correctly sorted and exit
1394          */
1395         fprintf(stdout, "Testing cipherlist order only. Ignoring all "
1396                 "other options.\n");
1397         if (do_test_cipherlist() == 0)
1398             EXIT(1);
1399         ret = 0;
1400         goto end;
1401     }
1402
1403     if (ssl3 + tls1 + dtls + dtls1 + dtls12 > 1) {
1404         fprintf(stderr, "At most one of -ssl3, -tls1, -dtls, -dtls1 or -dtls12 should "
1405                 "be requested.\n");
1406         EXIT(1);
1407     }
1408
1409 #ifdef OPENSSL_NO_SSL3
1410     if (ssl3)
1411         no_protocol = 1;
1412     else
1413 #endif
1414 #ifdef OPENSSL_NO_TLS1
1415     if (tls1)
1416         no_protocol = 1;
1417     else
1418 #endif
1419 #if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1)
1420     if (dtls1)
1421         no_protocol = 1;
1422     else
1423 #endif
1424 #if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1_2)
1425     if (dtls12)
1426         no_protocol = 1;
1427     else
1428 #endif
1429         no_protocol = 0;
1430
1431     /*
1432      * Testing was requested for a compiled-out protocol (e.g. SSLv3).
1433      * Ideally, we would error out, but the generic test wrapper can't know
1434      * when to expect failure. So we do nothing and return success.
1435      */
1436     if (no_protocol) {
1437         fprintf(stderr, "Testing was requested for a disabled protocol. "
1438                 "Skipping tests.\n");
1439         ret = 0;
1440         goto end;
1441     }
1442
1443     if (!ssl3 && !tls1 && !dtls && !dtls1 && !dtls12 && number > 1 && !reuse && !force) {
1444         fprintf(stderr, "This case cannot work.  Use -f to perform "
1445                 "the test anyway (and\n-d to see what happens), "
1446                 "or add one of -ssl3, -tls1, -dtls, -dtls1, -dtls12, -reuse\n"
1447                 "to avoid protocol mismatch.\n");
1448         EXIT(1);
1449     }
1450 #ifdef OPENSSL_FIPS
1451     if (fips_mode) {
1452         if (!FIPS_mode_set(1)) {
1453             ERR_print_errors(bio_err);
1454             EXIT(1);
1455         } else
1456             fprintf(stderr, "*** IN FIPS MODE ***\n");
1457     }
1458 #endif
1459
1460     if (print_time) {
1461         if (bio_type != BIO_PAIR) {
1462             fprintf(stderr, "Using BIO pair (-bio_pair)\n");
1463             bio_type = BIO_PAIR;
1464         }
1465         if (number < 50 && !force)
1466             fprintf(stderr,
1467                     "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
1468     }
1469
1470 /*      if (cipher == NULL) cipher=getenv("SSL_CIPHER"); */
1471
1472 #ifndef OPENSSL_NO_COMP
1473     if (comp == COMP_ZLIB)
1474         cm = COMP_zlib();
1475     if (cm != NULL) {
1476         if (COMP_get_type(cm) != NID_undef) {
1477             if (SSL_COMP_add_compression_method(comp, cm) != 0) {
1478                 fprintf(stderr, "Failed to add compression method\n");
1479                 ERR_print_errors_fp(stderr);
1480             }
1481         } else {
1482             fprintf(stderr,
1483                     "Warning: %s compression not supported\n",
1484                     comp == COMP_ZLIB ? "zlib" : "unknown");
1485             ERR_print_errors_fp(stderr);
1486         }
1487     }
1488     ssl_comp_methods = SSL_COMP_get_compression_methods();
1489     n = sk_SSL_COMP_num(ssl_comp_methods);
1490     if (n) {
1491         int j;
1492         printf("Available compression methods:");
1493         for (j = 0; j < n; j++) {
1494             SSL_COMP *c = sk_SSL_COMP_value(ssl_comp_methods, j);
1495             printf("  %s:%d", c->name, c->id);
1496         }
1497         printf("\n");
1498     }
1499 #endif
1500
1501 #ifndef OPENSSL_NO_TLS
1502     meth = TLS_method();
1503     if (ssl3) {
1504         min_version = SSL3_VERSION;
1505         max_version = SSL3_VERSION;
1506     } else if (tls1) {
1507         min_version = TLS1_VERSION;
1508         max_version = TLS1_VERSION;
1509     }
1510 #endif
1511 #ifndef OPENSSL_NO_DTLS
1512     if (dtls || dtls1 || dtls12)
1513         meth = DTLS_method();
1514     if (dtls1) {
1515         min_version = DTLS1_VERSION;
1516         max_version = DTLS1_VERSION;
1517     } else if (dtls12) {
1518         min_version = DTLS1_2_VERSION;
1519         max_version = DTLS1_2_VERSION;
1520     }
1521 #endif
1522
1523     c_ctx = SSL_CTX_new(meth);
1524     s_ctx = SSL_CTX_new(meth);
1525     s_ctx2 = SSL_CTX_new(meth); /* no SSL_CTX_dup! */
1526     if ((c_ctx == NULL) || (s_ctx == NULL) || (s_ctx2 == NULL)) {
1527         ERR_print_errors(bio_err);
1528         goto end;
1529     }
1530     /*
1531      * Since we will use low security ciphersuites and keys for testing set
1532      * security level to zero by default. Tests can override this by adding
1533      * "@SECLEVEL=n" to the cipher string.
1534      */
1535     SSL_CTX_set_security_level(c_ctx, 0);
1536     SSL_CTX_set_security_level(s_ctx, 0);
1537     SSL_CTX_set_security_level(s_ctx2, 0);
1538
1539     if (SSL_CTX_set_min_proto_version(c_ctx, min_version) == 0)
1540         goto end;
1541     if (SSL_CTX_set_max_proto_version(c_ctx, max_version) == 0)
1542         goto end;
1543     if (SSL_CTX_set_min_proto_version(s_ctx, min_version) == 0)
1544         goto end;
1545     if (SSL_CTX_set_max_proto_version(s_ctx, max_version) == 0)
1546         goto end;
1547
1548     if (cipher != NULL) {
1549         if (!SSL_CTX_set_cipher_list(c_ctx, cipher)
1550             || !SSL_CTX_set_cipher_list(s_ctx, cipher)
1551             || !SSL_CTX_set_cipher_list(s_ctx2, cipher)) {
1552             ERR_print_errors(bio_err);
1553             goto end;
1554         }
1555     }
1556
1557 #ifndef OPENSSL_NO_CT
1558     if (!SSL_CTX_set_ct_validation_callback(c_ctx, ct_validation, NULL)) {
1559         ERR_print_errors(bio_err);
1560         goto end;
1561     }
1562 #endif
1563
1564     /* Process SSL_CONF arguments */
1565     SSL_CONF_CTX_set_ssl_ctx(c_cctx, c_ctx);
1566     SSL_CONF_CTX_set_ssl_ctx(s_cctx, s_ctx);
1567     SSL_CONF_CTX_set_ssl_ctx(s_cctx2, s_ctx2);
1568
1569     for (i = 0; i < sk_OPENSSL_STRING_num(conf_args); i += 2) {
1570         int rv;
1571         arg = sk_OPENSSL_STRING_value(conf_args, i);
1572         argn = sk_OPENSSL_STRING_value(conf_args, i + 1);
1573         rv = SSL_CONF_cmd(c_cctx, arg, argn);
1574         /* If not recognised use server context */
1575         if (rv == -2) {
1576             rv = SSL_CONF_cmd(s_cctx2, arg, argn);
1577             if (rv > 0)
1578                 rv = SSL_CONF_cmd(s_cctx, arg, argn);
1579         }
1580         if (rv <= 0) {
1581             BIO_printf(bio_err, "Error processing %s %s\n",
1582                        arg, argn ? argn : "");
1583             ERR_print_errors(bio_err);
1584             goto end;
1585         }
1586     }
1587
1588     if (!SSL_CONF_CTX_finish(s_cctx) || !SSL_CONF_CTX_finish(c_cctx) || !SSL_CONF_CTX_finish(s_cctx2)) {
1589         BIO_puts(bio_err, "Error finishing context\n");
1590         ERR_print_errors(bio_err);
1591         goto end;
1592     }
1593 #ifndef OPENSSL_NO_DH
1594     if (!no_dhe) {
1595         if (dhe1024dsa) {
1596             dh = get_dh1024dsa();
1597         } else if (dhe512)
1598             dh = get_dh512();
1599         else
1600             dh = get_dh1024();
1601         SSL_CTX_set_tmp_dh(s_ctx, dh);
1602         SSL_CTX_set_tmp_dh(s_ctx2, dh);
1603         DH_free(dh);
1604     }
1605 #else
1606     (void)no_dhe;
1607 #endif
1608
1609     if ((!SSL_CTX_load_verify_locations(s_ctx, CAfile, CApath)) ||
1610         (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1611         (!SSL_CTX_load_verify_locations(s_ctx2, CAfile, CApath)) ||
1612         (!SSL_CTX_set_default_verify_paths(s_ctx2)) ||
1613         (!SSL_CTX_load_verify_locations(c_ctx, CAfile, CApath)) ||
1614         (!SSL_CTX_set_default_verify_paths(c_ctx))) {
1615         /* fprintf(stderr,"SSL_load_verify_locations\n"); */
1616         ERR_print_errors(bio_err);
1617         /* goto end; */
1618     }
1619
1620 #ifndef OPENSSL_NO_CT
1621     if (!SSL_CTX_set_default_ctlog_list_file(s_ctx) ||
1622         !SSL_CTX_set_default_ctlog_list_file(s_ctx2) ||
1623         !SSL_CTX_set_default_ctlog_list_file(c_ctx)) {
1624         ERR_print_errors(bio_err);
1625     }
1626 #endif
1627
1628     if (client_auth) {
1629         printf("client authentication\n");
1630         SSL_CTX_set_verify(s_ctx,
1631                            SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1632                            verify_callback);
1633         SSL_CTX_set_verify(s_ctx2,
1634                            SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1635                            verify_callback);
1636         SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback,
1637                                          &app_verify_arg);
1638         SSL_CTX_set_cert_verify_callback(s_ctx2, app_verify_callback,
1639                                          &app_verify_arg);
1640     }
1641     if (server_auth) {
1642         printf("server authentication\n");
1643         SSL_CTX_set_verify(c_ctx, SSL_VERIFY_PEER, verify_callback);
1644         SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback,
1645                                          &app_verify_arg);
1646     }
1647
1648     {
1649         int session_id_context = 0;
1650         if (!SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context,
1651                                             sizeof session_id_context) ||
1652             !SSL_CTX_set_session_id_context(s_ctx2, (void *)&session_id_context,
1653                                             sizeof session_id_context)) {
1654             ERR_print_errors(bio_err);
1655             goto end;
1656         }
1657     }
1658
1659     /* Use PSK only if PSK key is given */
1660     if (psk_key != NULL) {
1661         /*
1662          * no_psk is used to avoid putting psk command to openssl tool
1663          */
1664         if (no_psk) {
1665             /*
1666              * if PSK is not compiled in and psk key is given, do nothing and
1667              * exit successfully
1668              */
1669             ret = 0;
1670             goto end;
1671         }
1672 #ifndef OPENSSL_NO_PSK
1673         SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1674         SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1675         SSL_CTX_set_psk_server_callback(s_ctx2, psk_server_callback);
1676         if (debug)
1677             BIO_printf(bio_err, "setting PSK identity hint to s_ctx\n");
1678         if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint") ||
1679             !SSL_CTX_use_psk_identity_hint(s_ctx2, "ctx server identity_hint")) {
1680             BIO_printf(bio_err, "error setting PSK identity hint to s_ctx\n");
1681             ERR_print_errors(bio_err);
1682             goto end;
1683         }
1684 #endif
1685     }
1686 #ifndef OPENSSL_NO_SRP
1687     if (srp_client_arg.srplogin) {
1688         if (!SSL_CTX_set_srp_username(c_ctx, srp_client_arg.srplogin)) {
1689             BIO_printf(bio_err, "Unable to set SRP username\n");
1690             goto end;
1691         }
1692         SSL_CTX_set_srp_cb_arg(c_ctx, &srp_client_arg);
1693         SSL_CTX_set_srp_client_pwd_callback(c_ctx,
1694                                             ssl_give_srp_client_pwd_cb);
1695         /*
1696          * SSL_CTX_set_srp_strength(c_ctx, srp_client_arg.strength);
1697          */
1698     }
1699
1700     if (srp_server_arg.expected_user != NULL) {
1701         SSL_CTX_set_verify(s_ctx, SSL_VERIFY_NONE, verify_callback);
1702         SSL_CTX_set_verify(s_ctx2, SSL_VERIFY_NONE, verify_callback);
1703         SSL_CTX_set_srp_cb_arg(s_ctx, &srp_server_arg);
1704         SSL_CTX_set_srp_cb_arg(s_ctx2, &srp_server_arg);
1705         SSL_CTX_set_srp_username_callback(s_ctx, ssl_srp_server_param_cb);
1706         SSL_CTX_set_srp_username_callback(s_ctx2, ssl_srp_server_param_cb);
1707     }
1708 #endif
1709
1710 #ifndef OPENSSL_NO_NEXTPROTONEG
1711     if (npn_client) {
1712         SSL_CTX_set_next_proto_select_cb(c_ctx, cb_client_npn, NULL);
1713     }
1714     if (npn_server) {
1715         if (npn_server_reject) {
1716             BIO_printf(bio_err,
1717                        "Can't have both -npn_server and -npn_server_reject\n");
1718             goto end;
1719         }
1720         SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_npn, NULL);
1721         SSL_CTX_set_next_protos_advertised_cb(s_ctx2, cb_server_npn, NULL);
1722     }
1723     if (npn_server_reject) {
1724         SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_rejects_npn,
1725                                               NULL);
1726         SSL_CTX_set_next_protos_advertised_cb(s_ctx2, cb_server_rejects_npn,
1727                                               NULL);
1728     }
1729 #endif
1730
1731     if (serverinfo_sct) {
1732         if (!SSL_CTX_add_client_custom_ext(c_ctx,
1733                 TLSEXT_TYPE_signed_certificate_timestamp,
1734                 NULL, NULL, NULL,
1735                 serverinfo_cli_parse_cb, NULL)) {
1736             BIO_printf(bio_err, "Error adding SCT extension\n");
1737             goto end;
1738         }
1739     }
1740     if (serverinfo_tack) {
1741         if (!SSL_CTX_add_client_custom_ext(c_ctx, TACK_EXT_TYPE,
1742                                       NULL, NULL, NULL,
1743                                       serverinfo_cli_parse_cb, NULL)) {
1744             BIO_printf(bio_err, "Error adding TACK extension\n");
1745             goto end;
1746         }
1747     }
1748     if (serverinfo_file)
1749         if (!SSL_CTX_use_serverinfo_file(s_ctx, serverinfo_file) ||
1750             !SSL_CTX_use_serverinfo_file(s_ctx2, serverinfo_file)) {
1751             BIO_printf(bio_err, "missing serverinfo file\n");
1752             goto end;
1753         }
1754
1755     if (custom_ext) {
1756         if (!SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_0,
1757                                       custom_ext_0_cli_add_cb,
1758                                       NULL, NULL,
1759                                       custom_ext_0_cli_parse_cb, NULL)
1760             || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_1,
1761                                       custom_ext_1_cli_add_cb,
1762                                       NULL, NULL,
1763                                       custom_ext_1_cli_parse_cb, NULL)
1764             || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_2,
1765                                       custom_ext_2_cli_add_cb,
1766                                       NULL, NULL,
1767                                       custom_ext_2_cli_parse_cb, NULL)
1768             || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_3,
1769                                       custom_ext_3_cli_add_cb,
1770                                       NULL, NULL,
1771                                       custom_ext_3_cli_parse_cb, NULL)
1772             || !SSL_CTX_add_server_custom_ext(s_ctx, 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_ctx2, CUSTOM_EXT_TYPE_0,
1777                                       custom_ext_0_srv_add_cb,
1778                                       NULL, NULL,
1779                                       custom_ext_0_srv_parse_cb, NULL)
1780             || !SSL_CTX_add_server_custom_ext(s_ctx, 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_ctx2, CUSTOM_EXT_TYPE_1,
1785                                       custom_ext_1_srv_add_cb,
1786                                       NULL, NULL,
1787                                       custom_ext_1_srv_parse_cb, NULL)
1788             || !SSL_CTX_add_server_custom_ext(s_ctx, 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_ctx2, CUSTOM_EXT_TYPE_2,
1793                                       custom_ext_2_srv_add_cb,
1794                                       NULL, NULL,
1795                                       custom_ext_2_srv_parse_cb, NULL)
1796             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_3,
1797                                       custom_ext_3_srv_add_cb,
1798                                       NULL, NULL,
1799                                       custom_ext_3_srv_parse_cb, NULL)
1800             || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_3,
1801                                       custom_ext_3_srv_add_cb,
1802                                       NULL, NULL,
1803                                       custom_ext_3_srv_parse_cb, NULL)) {
1804             BIO_printf(bio_err, "Error setting custom extensions\n");
1805             goto end;
1806         }
1807     }
1808
1809     if (alpn_server)
1810         SSL_CTX_set_alpn_select_cb(s_ctx, cb_server_alpn, alpn_server);
1811     if (alpn_server2)
1812         SSL_CTX_set_alpn_select_cb(s_ctx2, cb_server_alpn, alpn_server2);
1813
1814     if (alpn_client) {
1815         size_t alpn_len;
1816         unsigned char *alpn = next_protos_parse(&alpn_len, alpn_client);
1817
1818         if (alpn == NULL) {
1819             BIO_printf(bio_err, "Error parsing -alpn_client argument\n");
1820             goto end;
1821         }
1822         /* Returns 0 on success!! */
1823         if (SSL_CTX_set_alpn_protos(c_ctx, alpn, alpn_len)) {
1824             BIO_printf(bio_err, "Error setting ALPN\n");
1825             OPENSSL_free(alpn);
1826             goto end;
1827         }
1828         OPENSSL_free(alpn);
1829     }
1830
1831     if (sn_server1 != NULL || sn_server2 != NULL)
1832         SSL_CTX_set_tlsext_servername_callback(s_ctx, servername_cb);
1833
1834     c_ssl = SSL_new(c_ctx);
1835     s_ssl = SSL_new(s_ctx);
1836
1837     if (sn_client)
1838         SSL_set_tlsext_host_name(c_ssl, sn_client);
1839
1840     if (!set_protocol_version(server_min_proto, s_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1841         goto end;
1842     if (!set_protocol_version(server_max_proto, s_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1843         goto end;
1844     if (!set_protocol_version(client_min_proto, c_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1845         goto end;
1846     if (!set_protocol_version(client_max_proto, c_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1847         goto end;
1848
1849     BIO_printf(bio_stdout, "Doing handshakes=%d bytes=%ld\n", number, bytes);
1850     for (i = 0; i < number; i++) {
1851         if (!reuse) {
1852             if (!SSL_set_session(c_ssl, NULL)) {
1853                 BIO_printf(bio_err, "Failed to set session\n");
1854                 goto end;
1855             }
1856         }
1857         switch (bio_type) {
1858         case BIO_MEM:
1859             ret = doit(s_ssl, c_ssl, bytes);
1860             break;
1861         case BIO_PAIR:
1862             ret = doit_biopair(s_ssl, c_ssl, bytes, &s_time, &c_time);
1863             break;
1864 #ifndef OPENSSL_NO_SOCK
1865         case BIO_IPV4:
1866             ret = doit_localhost(s_ssl, c_ssl, BIO_FAMILY_IPV4,
1867                                  bytes, &s_time, &c_time);
1868             break;
1869         case BIO_IPV6:
1870             ret = doit_localhost(s_ssl, c_ssl, BIO_FAMILY_IPV6,
1871                                  bytes, &s_time, &c_time);
1872             break;
1873 #else
1874         case BIO_IPV4:
1875         case BIO_IPV6:
1876             ret = 1;
1877             goto err;
1878 #endif
1879         }
1880         if (ret)  break;
1881     }
1882
1883     if (should_negotiate && ret == 0 &&
1884         strcmp(should_negotiate, "fail-server") != 0 &&
1885         strcmp(should_negotiate, "fail-client") != 0) {
1886         int version = protocol_from_string(should_negotiate);
1887         if (version < 0) {
1888             BIO_printf(bio_err, "Error parsing: %s\n", should_negotiate);
1889             ret = 1;
1890             goto err;
1891         }
1892         if (SSL_version(c_ssl) != version) {
1893             BIO_printf(bio_err, "Unxpected version negotiated. "
1894                 "Expected: %s, got %s\n", should_negotiate, SSL_get_version(c_ssl));
1895             ret = 1;
1896             goto err;
1897         }
1898     }
1899
1900     if (!verbose) {
1901         print_details(c_ssl, "");
1902     }
1903     if (print_time) {
1904 #ifdef CLOCKS_PER_SEC
1905         /*
1906          * "To determine the time in seconds, the value returned by the clock
1907          * function should be divided by the value of the macro
1908          * CLOCKS_PER_SEC." -- ISO/IEC 9899
1909          */
1910         BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1911                    "Approximate total client time: %6.2f s\n",
1912                    (double)s_time / CLOCKS_PER_SEC,
1913                    (double)c_time / CLOCKS_PER_SEC);
1914 #else
1915         BIO_printf(bio_stdout,
1916                    "Approximate total server time: %6.2f units\n"
1917                    "Approximate total client time: %6.2f units\n",
1918                    (double)s_time, (double)c_time);
1919 #endif
1920     }
1921
1922  err:
1923     SSL_free(s_ssl);
1924     SSL_free(c_ssl);
1925
1926  end:
1927     SSL_CTX_free(s_ctx);
1928     SSL_CTX_free(s_ctx2);
1929     SSL_CTX_free(c_ctx);
1930     SSL_CONF_CTX_free(s_cctx);
1931     SSL_CONF_CTX_free(s_cctx2);
1932     SSL_CONF_CTX_free(c_cctx);
1933     sk_OPENSSL_STRING_free(conf_args);
1934
1935     BIO_free(bio_stdout);
1936
1937 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
1938     if (CRYPTO_mem_leaks(bio_err) <= 0)
1939         ret = 1;
1940 #endif
1941     BIO_free(bio_err);
1942     EXIT(ret);
1943 }
1944
1945 #ifndef OPENSSL_NO_SOCK
1946 int doit_localhost(SSL *s_ssl, SSL *c_ssl, int family, long count,
1947                    clock_t *s_time, clock_t *c_time)
1948 {
1949     long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1950     BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1951     BIO *acpt = NULL, *server = NULL, *client = NULL;
1952     char addr_str[40];
1953     int ret = 1;
1954     int err_in_client = 0;
1955     int err_in_server = 0;
1956
1957     acpt = BIO_new_accept("0");
1958     if (acpt == NULL)
1959         goto err;
1960     BIO_set_accept_ip_family(acpt, family);
1961     BIO_set_bind_mode(acpt, BIO_SOCK_NONBLOCK | BIO_SOCK_REUSEADDR);
1962     if (BIO_do_accept(acpt) <= 0)
1963         goto err;
1964
1965     BIO_snprintf(addr_str, sizeof(addr_str), ":%s", BIO_get_accept_port(acpt));
1966
1967     client = BIO_new_connect(addr_str);
1968     BIO_set_conn_ip_family(client, family);
1969     if (!client)
1970         goto err;
1971
1972     if (BIO_set_nbio(client, 1) <= 0)
1973         goto err;
1974     if (BIO_set_nbio(acpt, 1) <= 0)
1975         goto err;
1976
1977     {
1978         int st_connect = 0, st_accept = 0;
1979
1980         while(!st_connect || !st_accept) {
1981             if (!st_connect) {
1982                 if (BIO_do_connect(client) <= 0) {
1983                     if (!BIO_should_retry(client))
1984                         goto err;
1985                 } else {
1986                     st_connect = 1;
1987                 }
1988             }
1989             if (!st_accept) {
1990                 if (BIO_do_accept(acpt) <= 0) {
1991                     if (!BIO_should_retry(acpt))
1992                         goto err;
1993                 } else {
1994                     st_accept = 1;
1995                 }
1996             }
1997         }
1998     }
1999     /* We're not interested in accepting further connects */
2000     server = BIO_pop(acpt);
2001     BIO_free_all(acpt);
2002     acpt = NULL;
2003
2004     s_ssl_bio = BIO_new(BIO_f_ssl());
2005     if (!s_ssl_bio)
2006         goto err;
2007
2008     c_ssl_bio = BIO_new(BIO_f_ssl());
2009     if (!c_ssl_bio)
2010         goto err;
2011
2012     SSL_set_connect_state(c_ssl);
2013     SSL_set_bio(c_ssl, client, client);
2014     (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
2015
2016     SSL_set_accept_state(s_ssl);
2017     SSL_set_bio(s_ssl, server, server);
2018     (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
2019
2020     do {
2021         /*-
2022          * c_ssl_bio:          SSL filter BIO
2023          *
2024          * client:             I/O for SSL library
2025          *
2026          *
2027          * server:             I/O for SSL library
2028          *
2029          * s_ssl_bio:          SSL filter BIO
2030          */
2031
2032         /*
2033          * We have non-blocking behaviour throughout this test program, but
2034          * can be sure that there is *some* progress in each iteration; so we
2035          * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
2036          * we just try everything in each iteration
2037          */
2038
2039         {
2040             /* CLIENT */
2041
2042             char cbuf[1024 * 8];
2043             int i, r;
2044             clock_t c_clock = clock();
2045
2046             memset(cbuf, 0, sizeof(cbuf));
2047
2048             if (debug)
2049                 if (SSL_in_init(c_ssl))
2050                     printf("client waiting in SSL_connect - %s\n",
2051                            SSL_state_string_long(c_ssl));
2052
2053             if (cw_num > 0) {
2054                 /* Write to server. */
2055
2056                 if (cw_num > (long)sizeof cbuf)
2057                     i = sizeof cbuf;
2058                 else
2059                     i = (int)cw_num;
2060                 r = BIO_write(c_ssl_bio, cbuf, i);
2061                 if (r < 0) {
2062                     if (!BIO_should_retry(c_ssl_bio)) {
2063                         fprintf(stderr, "ERROR in CLIENT\n");
2064                         err_in_client = 1;
2065                         goto err;
2066                     }
2067                     /*
2068                      * BIO_should_retry(...) can just be ignored here. The
2069                      * library expects us to call BIO_write with the same
2070                      * arguments again, and that's what we will do in the
2071                      * next iteration.
2072                      */
2073                 } else if (r == 0) {
2074                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2075                     goto err;
2076                 } else {
2077                     if (debug)
2078                         printf("client wrote %d\n", r);
2079                     cw_num -= r;
2080                 }
2081             }
2082
2083             if (cr_num > 0) {
2084                 /* Read from server. */
2085
2086                 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
2087                 if (r < 0) {
2088                     if (!BIO_should_retry(c_ssl_bio)) {
2089                         fprintf(stderr, "ERROR in CLIENT\n");
2090                         err_in_client = 1;
2091                         goto err;
2092                     }
2093                     /*
2094                      * Again, "BIO_should_retry" can be ignored.
2095                      */
2096                 } else if (r == 0) {
2097                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2098                     goto err;
2099                 } else {
2100                     if (debug)
2101                         printf("client read %d\n", r);
2102                     cr_num -= r;
2103                 }
2104             }
2105
2106             /*
2107              * c_time and s_time increments will typically be very small
2108              * (depending on machine speed and clock tick intervals), but
2109              * sampling over a large number of connections should result in
2110              * fairly accurate figures.  We cannot guarantee a lot, however
2111              * -- if each connection lasts for exactly one clock tick, it
2112              * will be counted only for the client or only for the server or
2113              * even not at all.
2114              */
2115             *c_time += (clock() - c_clock);
2116         }
2117
2118         {
2119             /* SERVER */
2120
2121             char sbuf[1024 * 8];
2122             int i, r;
2123             clock_t s_clock = clock();
2124
2125             memset(sbuf, 0, sizeof(sbuf));
2126
2127             if (debug)
2128                 if (SSL_in_init(s_ssl))
2129                     printf("server waiting in SSL_accept - %s\n",
2130                            SSL_state_string_long(s_ssl));
2131
2132             if (sw_num > 0) {
2133                 /* Write to client. */
2134
2135                 if (sw_num > (long)sizeof sbuf)
2136                     i = sizeof sbuf;
2137                 else
2138                     i = (int)sw_num;
2139                 r = BIO_write(s_ssl_bio, sbuf, i);
2140                 if (r < 0) {
2141                     if (!BIO_should_retry(s_ssl_bio)) {
2142                         fprintf(stderr, "ERROR in SERVER\n");
2143                         err_in_server = 1;
2144                         goto err;
2145                     }
2146                     /* Ignore "BIO_should_retry". */
2147                 } else if (r == 0) {
2148                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2149                     goto err;
2150                 } else {
2151                     if (debug)
2152                         printf("server wrote %d\n", r);
2153                     sw_num -= r;
2154                 }
2155             }
2156
2157             if (sr_num > 0) {
2158                 /* Read from client. */
2159
2160                 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2161                 if (r < 0) {
2162                     if (!BIO_should_retry(s_ssl_bio)) {
2163                         fprintf(stderr, "ERROR in SERVER\n");
2164                         err_in_server = 1;
2165                         goto err;
2166                     }
2167                     /* blah, blah */
2168                 } else if (r == 0) {
2169                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2170                     goto err;
2171                 } else {
2172                     if (debug)
2173                         printf("server read %d\n", r);
2174                     sr_num -= r;
2175                 }
2176             }
2177
2178             *s_time += (clock() - s_clock);
2179         }
2180     }
2181     while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2182
2183     if (verbose)
2184         print_details(c_ssl, "DONE via TCP connect: ");
2185 # ifndef OPENSSL_NO_NEXTPROTONEG
2186     if (verify_npn(c_ssl, s_ssl) < 0) {
2187         ret = 1;
2188         goto end;
2189     }
2190 # endif
2191     if (verify_serverinfo() < 0) {
2192         fprintf(stderr, "Server info verify error\n");
2193         ret = 1;
2194         goto err;
2195     }
2196     if (verify_alpn(c_ssl, s_ssl) < 0) {
2197         ret = 1;
2198         goto err;
2199     }
2200     if (verify_servername(c_ssl, s_ssl) < 0) {
2201         ret = 1;
2202         goto err;
2203     }
2204
2205     if (custom_ext_error) {
2206         fprintf(stderr, "Custom extension error\n");
2207         ret = 1;
2208         goto err;
2209     }
2210
2211  end:
2212     ret = 0;
2213
2214  err:
2215     ERR_print_errors(bio_err);
2216
2217     BIO_free_all(acpt);
2218     BIO_free(server);
2219     BIO_free(client);
2220     BIO_free(s_ssl_bio);
2221     BIO_free(c_ssl_bio);
2222
2223     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2224         ret = (err_in_client != 0) ? 0 : 1;
2225     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2226         ret = (err_in_server != 0) ? 0 : 1;
2227
2228     return ret;
2229 }
2230 #endif
2231
2232 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
2233                  clock_t *s_time, clock_t *c_time)
2234 {
2235     long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
2236     BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
2237     BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
2238     int ret = 1;
2239     int err_in_client = 0;
2240     int err_in_server = 0;
2241
2242     size_t bufsiz = 256;        /* small buffer for testing */
2243
2244     if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
2245         goto err;
2246     if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
2247         goto err;
2248
2249     s_ssl_bio = BIO_new(BIO_f_ssl());
2250     if (!s_ssl_bio)
2251         goto err;
2252
2253     c_ssl_bio = BIO_new(BIO_f_ssl());
2254     if (!c_ssl_bio)
2255         goto err;
2256
2257     SSL_set_connect_state(c_ssl);
2258     SSL_set_bio(c_ssl, client, client);
2259     (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
2260
2261     SSL_set_accept_state(s_ssl);
2262     SSL_set_bio(s_ssl, server, server);
2263     (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
2264
2265     do {
2266         /*-
2267          * c_ssl_bio:          SSL filter BIO
2268          *
2269          * client:             pseudo-I/O for SSL library
2270          *
2271          * client_io:          client's SSL communication; usually to be
2272          *                     relayed over some I/O facility, but in this
2273          *                     test program, we're the server, too:
2274          *
2275          * server_io:          server's SSL communication
2276          *
2277          * server:             pseudo-I/O for SSL library
2278          *
2279          * s_ssl_bio:          SSL filter BIO
2280          *
2281          * The client and the server each employ a "BIO pair":
2282          * client + client_io, server + server_io.
2283          * BIO pairs are symmetric.  A BIO pair behaves similar
2284          * to a non-blocking socketpair (but both endpoints must
2285          * be handled by the same thread).
2286          * [Here we could connect client and server to the ends
2287          * of a single BIO pair, but then this code would be less
2288          * suitable as an example for BIO pairs in general.]
2289          *
2290          * Useful functions for querying the state of BIO pair endpoints:
2291          *
2292          * BIO_ctrl_pending(bio)              number of bytes we can read now
2293          * BIO_ctrl_get_read_request(bio)     number of bytes needed to fulfil
2294          *                                      other side's read attempt
2295          * BIO_ctrl_get_write_guarantee(bio)   number of bytes we can write now
2296          *
2297          * ..._read_request is never more than ..._write_guarantee;
2298          * it depends on the application which one you should use.
2299          */
2300
2301         /*
2302          * We have non-blocking behaviour throughout this test program, but
2303          * can be sure that there is *some* progress in each iteration; so we
2304          * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
2305          * we just try everything in each iteration
2306          */
2307
2308         {
2309             /* CLIENT */
2310
2311             char cbuf[1024 * 8];
2312             int i, r;
2313             clock_t c_clock = clock();
2314
2315             memset(cbuf, 0, sizeof(cbuf));
2316
2317             if (debug)
2318                 if (SSL_in_init(c_ssl))
2319                     printf("client waiting in SSL_connect - %s\n",
2320                            SSL_state_string_long(c_ssl));
2321
2322             if (cw_num > 0) {
2323                 /* Write to server. */
2324
2325                 if (cw_num > (long)sizeof cbuf)
2326                     i = sizeof cbuf;
2327                 else
2328                     i = (int)cw_num;
2329                 r = BIO_write(c_ssl_bio, cbuf, i);
2330                 if (r < 0) {
2331                     if (!BIO_should_retry(c_ssl_bio)) {
2332                         fprintf(stderr, "ERROR in CLIENT\n");
2333                         err_in_client = 1;
2334                         goto err;
2335                     }
2336                     /*
2337                      * BIO_should_retry(...) can just be ignored here. The
2338                      * library expects us to call BIO_write with the same
2339                      * arguments again, and that's what we will do in the
2340                      * next iteration.
2341                      */
2342                 } else if (r == 0) {
2343                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2344                     goto err;
2345                 } else {
2346                     if (debug)
2347                         printf("client wrote %d\n", r);
2348                     cw_num -= r;
2349                 }
2350             }
2351
2352             if (cr_num > 0) {
2353                 /* Read from server. */
2354
2355                 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
2356                 if (r < 0) {
2357                     if (!BIO_should_retry(c_ssl_bio)) {
2358                         fprintf(stderr, "ERROR in CLIENT\n");
2359                         err_in_client = 1;
2360                         goto err;
2361                     }
2362                     /*
2363                      * Again, "BIO_should_retry" can be ignored.
2364                      */
2365                 } else if (r == 0) {
2366                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2367                     goto err;
2368                 } else {
2369                     if (debug)
2370                         printf("client read %d\n", r);
2371                     cr_num -= r;
2372                 }
2373             }
2374
2375             /*
2376              * c_time and s_time increments will typically be very small
2377              * (depending on machine speed and clock tick intervals), but
2378              * sampling over a large number of connections should result in
2379              * fairly accurate figures.  We cannot guarantee a lot, however
2380              * -- if each connection lasts for exactly one clock tick, it
2381              * will be counted only for the client or only for the server or
2382              * even not at all.
2383              */
2384             *c_time += (clock() - c_clock);
2385         }
2386
2387         {
2388             /* SERVER */
2389
2390             char sbuf[1024 * 8];
2391             int i, r;
2392             clock_t s_clock = clock();
2393
2394             memset(sbuf, 0, sizeof(sbuf));
2395
2396             if (debug)
2397                 if (SSL_in_init(s_ssl))
2398                     printf("server waiting in SSL_accept - %s\n",
2399                            SSL_state_string_long(s_ssl));
2400
2401             if (sw_num > 0) {
2402                 /* Write to client. */
2403
2404                 if (sw_num > (long)sizeof sbuf)
2405                     i = sizeof sbuf;
2406                 else
2407                     i = (int)sw_num;
2408                 r = BIO_write(s_ssl_bio, sbuf, i);
2409                 if (r < 0) {
2410                     if (!BIO_should_retry(s_ssl_bio)) {
2411                         fprintf(stderr, "ERROR in SERVER\n");
2412                         err_in_server = 1;
2413                         goto err;
2414                     }
2415                     /* Ignore "BIO_should_retry". */
2416                 } else if (r == 0) {
2417                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2418                     goto err;
2419                 } else {
2420                     if (debug)
2421                         printf("server wrote %d\n", r);
2422                     sw_num -= r;
2423                 }
2424             }
2425
2426             if (sr_num > 0) {
2427                 /* Read from client. */
2428
2429                 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2430                 if (r < 0) {
2431                     if (!BIO_should_retry(s_ssl_bio)) {
2432                         fprintf(stderr, "ERROR in SERVER\n");
2433                         err_in_server = 1;
2434                         goto err;
2435                     }
2436                     /* blah, blah */
2437                 } else if (r == 0) {
2438                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2439                     goto err;
2440                 } else {
2441                     if (debug)
2442                         printf("server read %d\n", r);
2443                     sr_num -= r;
2444                 }
2445             }
2446
2447             *s_time += (clock() - s_clock);
2448         }
2449
2450         {
2451             /* "I/O" BETWEEN CLIENT AND SERVER. */
2452
2453             size_t r1, r2;
2454             BIO *io1 = server_io, *io2 = client_io;
2455             /*
2456              * we use the non-copying interface for io1 and the standard
2457              * BIO_write/BIO_read interface for io2
2458              */
2459
2460             static int prev_progress = 1;
2461             int progress = 0;
2462
2463             /* io1 to io2 */
2464             do {
2465                 size_t num;
2466                 int r;
2467
2468                 r1 = BIO_ctrl_pending(io1);
2469                 r2 = BIO_ctrl_get_write_guarantee(io2);
2470
2471                 num = r1;
2472                 if (r2 < num)
2473                     num = r2;
2474                 if (num) {
2475                     char *dataptr;
2476
2477                     if (INT_MAX < num) /* yeah, right */
2478                         num = INT_MAX;
2479
2480                     r = BIO_nread(io1, &dataptr, (int)num);
2481                     assert(r > 0);
2482                     assert(r <= (int)num);
2483                     /*
2484                      * possibly r < num (non-contiguous data)
2485                      */
2486                     num = r;
2487                     r = BIO_write(io2, dataptr, (int)num);
2488                     if (r != (int)num) { /* can't happen */
2489                         fprintf(stderr, "ERROR: BIO_write could not write "
2490                                 "BIO_ctrl_get_write_guarantee() bytes");
2491                         goto err;
2492                     }
2493                     progress = 1;
2494
2495                     if (debug)
2496                         printf((io1 == client_io) ?
2497                                "C->S relaying: %d bytes\n" :
2498                                "S->C relaying: %d bytes\n", (int)num);
2499                 }
2500             }
2501             while (r1 && r2);
2502
2503             /* io2 to io1 */
2504             {
2505                 size_t num;
2506                 int r;
2507
2508                 r1 = BIO_ctrl_pending(io2);
2509                 r2 = BIO_ctrl_get_read_request(io1);
2510                 /*
2511                  * here we could use ..._get_write_guarantee instead of
2512                  * ..._get_read_request, but by using the latter we test
2513                  * restartability of the SSL implementation more thoroughly
2514                  */
2515                 num = r1;
2516                 if (r2 < num)
2517                     num = r2;
2518                 if (num) {
2519                     char *dataptr;
2520
2521                     if (INT_MAX < num)
2522                         num = INT_MAX;
2523
2524                     if (num > 1)
2525                         --num;  /* test restartability even more thoroughly */
2526
2527                     r = BIO_nwrite0(io1, &dataptr);
2528                     assert(r > 0);
2529                     if (r < (int)num)
2530                         num = r;
2531                     r = BIO_read(io2, dataptr, (int)num);
2532                     if (r != (int)num) { /* can't happen */
2533                         fprintf(stderr, "ERROR: BIO_read could not read "
2534                                 "BIO_ctrl_pending() bytes");
2535                         goto err;
2536                     }
2537                     progress = 1;
2538                     r = BIO_nwrite(io1, &dataptr, (int)num);
2539                     if (r != (int)num) { /* can't happen */
2540                         fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
2541                                 "BIO_nwrite0() bytes");
2542                         goto err;
2543                     }
2544
2545                     if (debug)
2546                         printf((io2 == client_io) ?
2547                                "C->S relaying: %d bytes\n" :
2548                                "S->C relaying: %d bytes\n", (int)num);
2549                 }
2550             }                   /* no loop, BIO_ctrl_get_read_request now
2551                                  * returns 0 anyway */
2552
2553             if (!progress && !prev_progress)
2554                 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0) {
2555                     fprintf(stderr, "ERROR: got stuck\n");
2556                     fprintf(stderr, " ERROR.\n");
2557                     goto err;
2558                 }
2559             prev_progress = progress;
2560         }
2561     }
2562     while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2563
2564     if (verbose)
2565         print_details(c_ssl, "DONE via BIO pair: ");
2566 #ifndef OPENSSL_NO_NEXTPROTONEG
2567     if (verify_npn(c_ssl, s_ssl) < 0) {
2568         ret = 1;
2569         goto end;
2570     }
2571 #endif
2572     if (verify_serverinfo() < 0) {
2573         fprintf(stderr, "Server info verify error\n");
2574         ret = 1;
2575         goto err;
2576     }
2577     if (verify_alpn(c_ssl, s_ssl) < 0) {
2578         ret = 1;
2579         goto err;
2580     }
2581     if (verify_servername(c_ssl, s_ssl) < 0) {
2582         ret = 1;
2583         goto err;
2584     }
2585
2586     if (custom_ext_error) {
2587         fprintf(stderr, "Custom extension error\n");
2588         ret = 1;
2589         goto err;
2590     }
2591
2592  end:
2593     ret = 0;
2594
2595  err:
2596     ERR_print_errors(bio_err);
2597
2598     BIO_free(server);
2599     BIO_free(server_io);
2600     BIO_free(client);
2601     BIO_free(client_io);
2602     BIO_free(s_ssl_bio);
2603     BIO_free(c_ssl_bio);
2604
2605     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2606         ret = (err_in_client != 0) ? 0 : 1;
2607     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2608         ret = (err_in_server != 0) ? 0 : 1;
2609
2610     return ret;
2611 }
2612
2613 #define W_READ  1
2614 #define W_WRITE 2
2615 #define C_DONE  1
2616 #define S_DONE  2
2617
2618 int doit(SSL *s_ssl, SSL *c_ssl, long count)
2619 {
2620     char *cbuf = NULL, *sbuf = NULL;
2621     long bufsiz;
2622     long cw_num = count, cr_num = count;
2623     long sw_num = count, sr_num = count;
2624     int ret = 1;
2625     BIO *c_to_s = NULL;
2626     BIO *s_to_c = NULL;
2627     BIO *c_bio = NULL;
2628     BIO *s_bio = NULL;
2629     int c_r, c_w, s_r, s_w;
2630     int i, j;
2631     int done = 0;
2632     int c_write, s_write;
2633     int do_server = 0, do_client = 0;
2634     int max_frag = 5 * 1024;
2635     int err_in_client = 0;
2636     int err_in_server = 0;
2637
2638     bufsiz = count > 40 * 1024 ? 40 * 1024 : count;
2639
2640     if ((cbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2641         goto err;
2642     if ((sbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2643         goto err;
2644
2645     c_to_s = BIO_new(BIO_s_mem());
2646     s_to_c = BIO_new(BIO_s_mem());
2647     if ((s_to_c == NULL) || (c_to_s == NULL)) {
2648         ERR_print_errors(bio_err);
2649         goto err;
2650     }
2651
2652     c_bio = BIO_new(BIO_f_ssl());
2653     s_bio = BIO_new(BIO_f_ssl());
2654     if ((c_bio == NULL) || (s_bio == NULL)) {
2655         ERR_print_errors(bio_err);
2656         goto err;
2657     }
2658
2659     SSL_set_connect_state(c_ssl);
2660     SSL_set_bio(c_ssl, s_to_c, c_to_s);
2661     SSL_set_max_send_fragment(c_ssl, max_frag);
2662     BIO_set_ssl(c_bio, c_ssl, BIO_NOCLOSE);
2663
2664     SSL_set_accept_state(s_ssl);
2665     SSL_set_bio(s_ssl, c_to_s, s_to_c);
2666     SSL_set_max_send_fragment(s_ssl, max_frag);
2667     BIO_set_ssl(s_bio, s_ssl, BIO_NOCLOSE);
2668
2669     c_r = 0;
2670     s_r = 1;
2671     c_w = 1;
2672     s_w = 0;
2673     c_write = 1, s_write = 0;
2674
2675     /* We can always do writes */
2676     for (;;) {
2677         do_server = 0;
2678         do_client = 0;
2679
2680         i = (int)BIO_pending(s_bio);
2681         if ((i && s_r) || s_w)
2682             do_server = 1;
2683
2684         i = (int)BIO_pending(c_bio);
2685         if ((i && c_r) || c_w)
2686             do_client = 1;
2687
2688         if (do_server && debug) {
2689             if (SSL_in_init(s_ssl))
2690                 printf("server waiting in SSL_accept - %s\n",
2691                        SSL_state_string_long(s_ssl));
2692 /*-
2693             else if (s_write)
2694                 printf("server:SSL_write()\n");
2695             else
2696                 printf("server:SSL_read()\n"); */
2697         }
2698
2699         if (do_client && debug) {
2700             if (SSL_in_init(c_ssl))
2701                 printf("client waiting in SSL_connect - %s\n",
2702                        SSL_state_string_long(c_ssl));
2703 /*-
2704             else if (c_write)
2705                 printf("client:SSL_write()\n");
2706             else
2707                 printf("client:SSL_read()\n"); */
2708         }
2709
2710         if (!do_client && !do_server) {
2711             fprintf(stdout, "ERROR IN STARTUP\n");
2712             ERR_print_errors(bio_err);
2713             goto err;
2714         }
2715         if (do_client && !(done & C_DONE)) {
2716             if (c_write) {
2717                 j = (cw_num > bufsiz) ? (int)bufsiz : (int)cw_num;
2718                 i = BIO_write(c_bio, cbuf, j);
2719                 if (i < 0) {
2720                     c_r = 0;
2721                     c_w = 0;
2722                     if (BIO_should_retry(c_bio)) {
2723                         if (BIO_should_read(c_bio))
2724                             c_r = 1;
2725                         if (BIO_should_write(c_bio))
2726                             c_w = 1;
2727                     } else {
2728                         fprintf(stderr, "ERROR in CLIENT\n");
2729                         err_in_client = 1;
2730                         ERR_print_errors(bio_err);
2731                         goto err;
2732                     }
2733                 } else if (i == 0) {
2734                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2735                     goto err;
2736                 } else {
2737                     if (debug)
2738                         printf("client wrote %d\n", i);
2739                     /* ok */
2740                     s_r = 1;
2741                     c_write = 0;
2742                     cw_num -= i;
2743                     if (max_frag > 1029)
2744                         SSL_set_max_send_fragment(c_ssl, max_frag -= 5);
2745                 }
2746             } else {
2747                 i = BIO_read(c_bio, cbuf, bufsiz);
2748                 if (i < 0) {
2749                     c_r = 0;
2750                     c_w = 0;
2751                     if (BIO_should_retry(c_bio)) {
2752                         if (BIO_should_read(c_bio))
2753                             c_r = 1;
2754                         if (BIO_should_write(c_bio))
2755                             c_w = 1;
2756                     } else {
2757                         fprintf(stderr, "ERROR in CLIENT\n");
2758                         err_in_client = 1;
2759                         ERR_print_errors(bio_err);
2760                         goto err;
2761                     }
2762                 } else if (i == 0) {
2763                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2764                     goto err;
2765                 } else {
2766                     if (debug)
2767                         printf("client read %d\n", i);
2768                     cr_num -= i;
2769                     if (sw_num > 0) {
2770                         s_write = 1;
2771                         s_w = 1;
2772                     }
2773                     if (cr_num <= 0) {
2774                         s_write = 1;
2775                         s_w = 1;
2776                         done = S_DONE | C_DONE;
2777                     }
2778                 }
2779             }
2780         }
2781
2782         if (do_server && !(done & S_DONE)) {
2783             if (!s_write) {
2784                 i = BIO_read(s_bio, sbuf, bufsiz);
2785                 if (i < 0) {
2786                     s_r = 0;
2787                     s_w = 0;
2788                     if (BIO_should_retry(s_bio)) {
2789                         if (BIO_should_read(s_bio))
2790                             s_r = 1;
2791                         if (BIO_should_write(s_bio))
2792                             s_w = 1;
2793                     } else {
2794                         fprintf(stderr, "ERROR in SERVER\n");
2795                         err_in_server = 1;
2796                         ERR_print_errors(bio_err);
2797                         goto err;
2798                     }
2799                 } else if (i == 0) {
2800                     ERR_print_errors(bio_err);
2801                     fprintf(stderr,
2802                             "SSL SERVER STARTUP FAILED in SSL_read\n");
2803                     goto err;
2804                 } else {
2805                     if (debug)
2806                         printf("server read %d\n", i);
2807                     sr_num -= i;
2808                     if (cw_num > 0) {
2809                         c_write = 1;
2810                         c_w = 1;
2811                     }
2812                     if (sr_num <= 0) {
2813                         s_write = 1;
2814                         s_w = 1;
2815                         c_write = 0;
2816                     }
2817                 }
2818             } else {
2819                 j = (sw_num > bufsiz) ? (int)bufsiz : (int)sw_num;
2820                 i = BIO_write(s_bio, sbuf, j);
2821                 if (i < 0) {
2822                     s_r = 0;
2823                     s_w = 0;
2824                     if (BIO_should_retry(s_bio)) {
2825                         if (BIO_should_read(s_bio))
2826                             s_r = 1;
2827                         if (BIO_should_write(s_bio))
2828                             s_w = 1;
2829                     } else {
2830                         fprintf(stderr, "ERROR in SERVER\n");
2831                         err_in_server = 1;
2832                         ERR_print_errors(bio_err);
2833                         goto err;
2834                     }
2835                 } else if (i == 0) {
2836                     ERR_print_errors(bio_err);
2837                     fprintf(stderr,
2838                             "SSL SERVER STARTUP FAILED in SSL_write\n");
2839                     goto err;
2840                 } else {
2841                     if (debug)
2842                         printf("server wrote %d\n", i);
2843                     sw_num -= i;
2844                     s_write = 0;
2845                     c_r = 1;
2846                     if (sw_num <= 0)
2847                         done |= S_DONE;
2848                     if (max_frag > 1029)
2849                         SSL_set_max_send_fragment(s_ssl, max_frag -= 5);
2850                 }
2851             }
2852         }
2853
2854         if ((done & S_DONE) && (done & C_DONE))
2855             break;
2856     }
2857
2858     if (verbose)
2859         print_details(c_ssl, "DONE: ");
2860 #ifndef OPENSSL_NO_NEXTPROTONEG
2861     if (verify_npn(c_ssl, s_ssl) < 0) {
2862         ret = 1;
2863         goto err;
2864     }
2865 #endif
2866     if (verify_serverinfo() < 0) {
2867         fprintf(stderr, "Server info verify error\n");
2868         ret = 1;
2869         goto err;
2870     }
2871     if (custom_ext_error) {
2872         fprintf(stderr, "Custom extension error\n");
2873         ret = 1;
2874         goto err;
2875     }
2876     ret = 0;
2877  err:
2878     /*
2879      * We have to set the BIO's to NULL otherwise they will be
2880      * OPENSSL_free()ed twice.  Once when th s_ssl is SSL_free()ed and again
2881      * when c_ssl is SSL_free()ed. This is a hack required because s_ssl and
2882      * c_ssl are sharing the same BIO structure and SSL_set_bio() and
2883      * SSL_free() automatically BIO_free non NULL entries. You should not
2884      * normally do this or be required to do this
2885      */
2886     if (s_ssl != NULL) {
2887         s_ssl->rbio = NULL;
2888         s_ssl->wbio = NULL;
2889     }
2890     if (c_ssl != NULL) {
2891         c_ssl->rbio = NULL;
2892         c_ssl->wbio = NULL;
2893     }
2894
2895     BIO_free(c_to_s);
2896     BIO_free(s_to_c);
2897     BIO_free_all(c_bio);
2898     BIO_free_all(s_bio);
2899     OPENSSL_free(cbuf);
2900     OPENSSL_free(sbuf);
2901
2902     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2903         ret = (err_in_client != 0) ? 0 : 1;
2904     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2905         ret = (err_in_server != 0) ? 0 : 1;
2906
2907     return (ret);
2908 }
2909
2910 static CRYPTO_ONCE proxy_auth_ex_data_once = CRYPTO_ONCE_STATIC_INIT;
2911 static volatile int proxy_auth_ex_data_idx = -1;
2912
2913 static void do_get_proxy_auth_ex_data_idx(void)
2914 {
2915     proxy_auth_ex_data_idx = X509_STORE_CTX_get_ex_new_index(0,
2916                                                 "SSLtest for verify callback",
2917                                                 NULL, NULL, NULL);
2918 }
2919
2920 static int get_proxy_auth_ex_data_idx(void)
2921 {
2922     CRYPTO_THREAD_run_once(&proxy_auth_ex_data_once,
2923                            do_get_proxy_auth_ex_data_idx);
2924     return proxy_auth_ex_data_idx;
2925 }
2926
2927 static int verify_callback(int ok, X509_STORE_CTX *ctx)
2928 {
2929     char *s, buf[256];
2930
2931     s = X509_NAME_oneline(X509_get_subject_name(ctx->current_cert), buf,
2932                           sizeof buf);
2933     if (s != NULL) {
2934         if (ok)
2935             printf("depth=%d %s\n", ctx->error_depth, buf);
2936         else {
2937             fprintf(stderr, "depth=%d error=%d %s\n",
2938                     ctx->error_depth, ctx->error, buf);
2939         }
2940     }
2941
2942     if (ok == 0) {
2943         switch (ctx->error) {
2944         default:
2945             fprintf(stderr, "Error string: %s\n",
2946                     X509_verify_cert_error_string(ctx->error));
2947             break;
2948         case X509_V_ERR_CERT_NOT_YET_VALID:
2949         case X509_V_ERR_CERT_HAS_EXPIRED:
2950         case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2951             ok = 1;
2952         }
2953     }
2954
2955     if (ok == 1) {
2956         X509 *xs = ctx->current_cert;
2957         if (X509_get_extension_flags(xs) & EXFLAG_PROXY) {
2958             unsigned int *letters = X509_STORE_CTX_get_ex_data(ctx,
2959                                                                get_proxy_auth_ex_data_idx
2960                                                                ());
2961
2962             if (letters) {
2963                 int found_any = 0;
2964                 int i;
2965                 PROXY_CERT_INFO_EXTENSION *pci =
2966                     X509_get_ext_d2i(xs, NID_proxyCertInfo,
2967                                      NULL, NULL);
2968
2969                 switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage)) {
2970                 case NID_Independent:
2971                     /*
2972                      * Completely meaningless in this program, as there's no
2973                      * way to grant explicit rights to a specific PrC.
2974                      * Basically, using id-ppl-Independent is the perfect way
2975                      * to grant no rights at all.
2976                      */
2977                     fprintf(stderr, "  Independent proxy certificate");
2978                     for (i = 0; i < 26; i++)
2979                         letters[i] = 0;
2980                     break;
2981                 case NID_id_ppl_inheritAll:
2982                     /*
2983                      * This is basically a NOP, we simply let the current
2984                      * rights stand as they are.
2985                      */
2986                     fprintf(stderr, "  Proxy certificate inherits all");
2987                     break;
2988                 default:
2989                     s = (char *)
2990                         pci->proxyPolicy->policy->data;
2991                     i = pci->proxyPolicy->policy->length;
2992
2993                     /*
2994                      * The algorithm works as follows: it is assumed that
2995                      * previous iterations or the initial granted rights has
2996                      * already set some elements of `letters'.  What we need
2997                      * to do is to clear those that weren't granted by the
2998                      * current PrC as well.  The easiest way to do this is to
2999                      * add 1 to all the elements whose letters are given with
3000                      * the current policy. That way, all elements that are
3001                      * set by the current policy and were already set by
3002                      * earlier policies and through the original grant of
3003                      * rights will get the value 2 or higher. The last thing
3004                      * to do is to sweep through `letters' and keep the
3005                      * elements having the value 2 as set, and clear all the
3006                      * others.
3007                      */
3008
3009                     printf("  Certificate proxy rights = %*.*s", i,
3010                             i, s);
3011                     while (i-- > 0) {
3012                         int c = *s++;
3013                         if (isascii(c) && isalpha(c)) {
3014                             if (islower(c))
3015                                 c = toupper(c);
3016                             letters[c - 'A']++;
3017                         }
3018                     }
3019                     for (i = 0; i < 26; i++)
3020                         if (letters[i] < 2)
3021                             letters[i] = 0;
3022                         else
3023                             letters[i] = 1;
3024                 }
3025
3026                 found_any = 0;
3027                 printf(", resulting proxy rights = ");
3028                 for (i = 0; i < 26; i++)
3029                     if (letters[i]) {
3030                         printf("%c", i + 'A');
3031                         found_any = 1;
3032                     }
3033                 if (!found_any)
3034                     printf("none");
3035                 printf("\n");
3036
3037                 PROXY_CERT_INFO_EXTENSION_free(pci);
3038             }
3039         }
3040     }
3041
3042     return (ok);
3043 }
3044
3045 static void process_proxy_debug(int indent, const char *format, ...)
3046 {
3047     /* That's 80 > */
3048     static const char indentation[] =
3049         ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
3050         ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
3051     char my_format[256];
3052     va_list args;
3053
3054     BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
3055                  indent, indent, indentation, format);
3056
3057     va_start(args, format);
3058     vfprintf(stderr, my_format, args);
3059     va_end(args);
3060 }
3061
3062 /*-
3063  * Priority levels:
3064  *  0   [!]var, ()
3065  *  1   & ^
3066  *  2   |
3067  */
3068 static int process_proxy_cond_adders(unsigned int letters[26],
3069                                      const char *cond, const char **cond_end,
3070                                      int *pos, int indent);
3071 static int process_proxy_cond_val(unsigned int letters[26], const char *cond,
3072                                   const char **cond_end, int *pos, int indent)
3073 {
3074     int c;
3075     int ok = 1;
3076     int negate = 0;
3077
3078     while (isspace((int)*cond)) {
3079         cond++;
3080         (*pos)++;
3081     }
3082     c = *cond;
3083
3084     if (debug)
3085         process_proxy_debug(indent,
3086                             "Start process_proxy_cond_val at position %d: %s\n",
3087                             *pos, cond);
3088
3089     while (c == '!') {
3090         negate = !negate;
3091         cond++;
3092         (*pos)++;
3093         while (isspace((int)*cond)) {
3094             cond++;
3095             (*pos)++;
3096         }
3097         c = *cond;
3098     }
3099
3100     if (c == '(') {
3101         cond++;
3102         (*pos)++;
3103         ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
3104                                        indent + 1);
3105         cond = *cond_end;
3106         if (ok < 0)
3107             goto end;
3108         while (isspace((int)*cond)) {
3109             cond++;
3110             (*pos)++;
3111         }
3112         c = *cond;
3113         if (c != ')') {
3114             fprintf(stderr,
3115                     "Weird condition character in position %d: "
3116                     "%c\n", *pos, c);
3117             ok = -1;
3118             goto end;
3119         }
3120         cond++;
3121         (*pos)++;
3122     } else if (isascii(c) && isalpha(c)) {
3123         if (islower(c))
3124             c = toupper(c);
3125         ok = letters[c - 'A'];
3126         cond++;
3127         (*pos)++;
3128     } else {
3129         fprintf(stderr,
3130                 "Weird condition character in position %d: " "%c\n", *pos, c);
3131         ok = -1;
3132         goto end;
3133     }
3134  end:
3135     *cond_end = cond;
3136     if (ok >= 0 && negate)
3137         ok = !ok;
3138
3139     if (debug)
3140         process_proxy_debug(indent,
3141                             "End process_proxy_cond_val at position %d: %s, returning %d\n",
3142                             *pos, cond, ok);
3143
3144     return ok;
3145 }
3146
3147 static int process_proxy_cond_multipliers(unsigned int letters[26],
3148                                           const char *cond,
3149                                           const char **cond_end, int *pos,
3150                                           int indent)
3151 {
3152     int ok;
3153     char c;
3154
3155     if (debug)
3156         process_proxy_debug(indent,
3157                             "Start process_proxy_cond_multipliers at position %d: %s\n",
3158                             *pos, cond);
3159
3160     ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
3161     cond = *cond_end;
3162     if (ok < 0)
3163         goto end;
3164
3165     while (ok >= 0) {
3166         while (isspace((int)*cond)) {
3167             cond++;
3168             (*pos)++;
3169         }
3170         c = *cond;
3171
3172         switch (c) {
3173         case '&':
3174         case '^':
3175             {
3176                 int save_ok = ok;
3177
3178                 cond++;
3179                 (*pos)++;
3180                 ok = process_proxy_cond_val(letters,
3181                                             cond, cond_end, pos, indent + 1);
3182                 cond = *cond_end;
3183                 if (ok < 0)
3184                     break;
3185
3186                 switch (c) {
3187                 case '&':
3188                     ok &= save_ok;
3189                     break;
3190                 case '^':
3191                     ok ^= save_ok;
3192                     break;
3193                 default:
3194                     fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
3195                             " STOPPING\n");
3196                     EXIT(1);
3197                 }
3198             }
3199             break;
3200         default:
3201             goto end;
3202         }
3203     }
3204  end:
3205     if (debug)
3206         process_proxy_debug(indent,
3207                             "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
3208                             *pos, cond, ok);
3209
3210     *cond_end = cond;
3211     return ok;
3212 }
3213
3214 static int process_proxy_cond_adders(unsigned int letters[26],
3215                                      const char *cond, const char **cond_end,
3216                                      int *pos, int indent)
3217 {
3218     int ok;
3219     char c;
3220
3221     if (debug)
3222         process_proxy_debug(indent,
3223                             "Start process_proxy_cond_adders at position %d: %s\n",
3224                             *pos, cond);
3225
3226     ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
3227                                         indent + 1);
3228     cond = *cond_end;
3229     if (ok < 0)
3230         goto end;
3231
3232     while (ok >= 0) {
3233         while (isspace((int)*cond)) {
3234             cond++;
3235             (*pos)++;
3236         }
3237         c = *cond;
3238
3239         switch (c) {
3240         case '|':
3241             {
3242                 int save_ok = ok;
3243
3244                 cond++;
3245                 (*pos)++;
3246                 ok = process_proxy_cond_multipliers(letters,
3247                                                     cond, cond_end, pos,
3248                                                     indent + 1);
3249                 cond = *cond_end;
3250                 if (ok < 0)
3251                     break;
3252
3253                 switch (c) {
3254                 case '|':
3255                     ok |= save_ok;
3256                     break;
3257                 default:
3258                     fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
3259                             " STOPPING\n");
3260                     EXIT(1);
3261                 }
3262             }
3263             break;
3264         default:
3265             goto end;
3266         }
3267     }
3268  end:
3269     if (debug)
3270         process_proxy_debug(indent,
3271                             "End process_proxy_cond_adders at position %d: %s, returning %d\n",
3272                             *pos, cond, ok);
3273
3274     *cond_end = cond;
3275     return ok;
3276 }
3277
3278 static int process_proxy_cond(unsigned int letters[26],
3279                               const char *cond, const char **cond_end)
3280 {
3281     int pos = 1;
3282     return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
3283 }
3284
3285 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg)
3286 {
3287     int ok = 1;
3288     struct app_verify_arg *cb_arg = arg;
3289     unsigned int letters[26];   /* only used with proxy_auth */
3290
3291     if (cb_arg->app_verify) {
3292         char *s = NULL, buf[256];
3293
3294         printf("In app_verify_callback, allowing cert. ");
3295         printf("Arg is: %s\n", cb_arg->string);
3296         printf("Finished printing do we have a context? 0x%p a cert? 0x%p\n",
3297                 (void *)ctx, (void *)ctx->cert);
3298         if (ctx->cert)
3299             s = X509_NAME_oneline(X509_get_subject_name(ctx->cert), buf, 256);
3300         if (s != NULL) {
3301             printf("cert depth=%d %s\n", ctx->error_depth, buf);
3302         }
3303         return (1);
3304     }
3305     if (cb_arg->proxy_auth) {
3306         int found_any = 0, i;
3307         char *sp;
3308
3309         for (i = 0; i < 26; i++)
3310             letters[i] = 0;
3311         for (sp = cb_arg->proxy_auth; *sp; sp++) {
3312             int c = *sp;
3313             if (isascii(c) && isalpha(c)) {
3314                 if (islower(c))
3315                     c = toupper(c);
3316                 letters[c - 'A'] = 1;
3317             }
3318         }
3319
3320         printf("  Initial proxy rights = ");
3321         for (i = 0; i < 26; i++)
3322             if (letters[i]) {
3323                 printf("%c", i + 'A');
3324                 found_any = 1;
3325             }
3326         if (!found_any)
3327             printf("none");
3328         printf("\n");
3329
3330         X509_STORE_CTX_set_ex_data(ctx,
3331                                    get_proxy_auth_ex_data_idx(), letters);
3332     }
3333     if (cb_arg->allow_proxy_certs) {
3334         X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
3335     }
3336     ok = X509_verify_cert(ctx);
3337
3338     if (cb_arg->proxy_auth) {
3339         if (ok > 0) {
3340             const char *cond_end = NULL;
3341
3342             ok = process_proxy_cond(letters, cb_arg->proxy_cond, &cond_end);
3343
3344             if (ok < 0)
3345                 EXIT(3);
3346             if (*cond_end) {
3347                 fprintf(stderr,
3348                         "Stopped processing condition before it's end.\n");
3349                 ok = 0;
3350             }
3351             if (!ok)
3352                 fprintf(stderr,
3353                         "Proxy rights check with condition '%s' invalid\n",
3354                         cb_arg->proxy_cond);
3355             else
3356                 printf("Proxy rights check with condition '%s' ok\n",
3357                         cb_arg->proxy_cond);
3358         }
3359     }
3360     return (ok);
3361 }
3362
3363 #ifndef OPENSSL_NO_DH
3364 /*-
3365  * These DH parameters have been generated as follows:
3366  *    $ openssl dhparam -C -noout 512
3367  *    $ openssl dhparam -C -noout 1024
3368  *    $ openssl dhparam -C -noout -dsaparam 1024
3369  * (The third function has been renamed to avoid name conflicts.)
3370  */
3371 static DH *get_dh512()
3372 {
3373     static unsigned char dh512_p[] = {
3374         0xCB, 0xC8, 0xE1, 0x86, 0xD0, 0x1F, 0x94, 0x17, 0xA6, 0x99, 0xF0,
3375         0xC6,
3376         0x1F, 0x0D, 0xAC, 0xB6, 0x25, 0x3E, 0x06, 0x39, 0xCA, 0x72, 0x04,
3377         0xB0,
3378         0x6E, 0xDA, 0xC0, 0x61, 0xE6, 0x7A, 0x77, 0x25, 0xE8, 0x3B, 0xB9,
3379         0x5F,
3380         0x9A, 0xB6, 0xB5, 0xFE, 0x99, 0x0B, 0xA1, 0x93, 0x4E, 0x35, 0x33,
3381         0xB8,
3382         0xE1, 0xF1, 0x13, 0x4F, 0x59, 0x1A, 0xD2, 0x57, 0xC0, 0x26, 0x21,
3383         0x33,
3384         0x02, 0xC5, 0xAE, 0x23,
3385     };
3386     static unsigned char dh512_g[] = {
3387         0x02,
3388     };
3389     DH *dh;
3390
3391     if ((dh = DH_new()) == NULL)
3392         return (NULL);
3393     dh->p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
3394     dh->g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
3395     if ((dh->p == NULL) || (dh->g == NULL)) {
3396         DH_free(dh);
3397         return (NULL);
3398     }
3399     return (dh);
3400 }
3401
3402 static DH *get_dh1024()
3403 {
3404     static unsigned char dh1024_p[] = {
3405         0xF8, 0x81, 0x89, 0x7D, 0x14, 0x24, 0xC5, 0xD1, 0xE6, 0xF7, 0xBF,
3406         0x3A,
3407         0xE4, 0x90, 0xF4, 0xFC, 0x73, 0xFB, 0x34, 0xB5, 0xFA, 0x4C, 0x56,
3408         0xA2,
3409         0xEA, 0xA7, 0xE9, 0xC0, 0xC0, 0xCE, 0x89, 0xE1, 0xFA, 0x63, 0x3F,
3410         0xB0,
3411         0x6B, 0x32, 0x66, 0xF1, 0xD1, 0x7B, 0xB0, 0x00, 0x8F, 0xCA, 0x87,
3412         0xC2,
3413         0xAE, 0x98, 0x89, 0x26, 0x17, 0xC2, 0x05, 0xD2, 0xEC, 0x08, 0xD0,
3414         0x8C,
3415         0xFF, 0x17, 0x52, 0x8C, 0xC5, 0x07, 0x93, 0x03, 0xB1, 0xF6, 0x2F,
3416         0xB8,
3417         0x1C, 0x52, 0x47, 0x27, 0x1B, 0xDB, 0xD1, 0x8D, 0x9D, 0x69, 0x1D,
3418         0x52,
3419         0x4B, 0x32, 0x81, 0xAA, 0x7F, 0x00, 0xC8, 0xDC, 0xE6, 0xD9, 0xCC,
3420         0xC1,
3421         0x11, 0x2D, 0x37, 0x34, 0x6C, 0xEA, 0x02, 0x97, 0x4B, 0x0E, 0xBB,
3422         0xB1,
3423         0x71, 0x33, 0x09, 0x15, 0xFD, 0xDD, 0x23, 0x87, 0x07, 0x5E, 0x89,
3424         0xAB,
3425         0x6B, 0x7C, 0x5F, 0xEC, 0xA6, 0x24, 0xDC, 0x53,
3426     };
3427     static unsigned char dh1024_g[] = {
3428         0x02,
3429     };
3430     DH *dh;
3431
3432     if ((dh = DH_new()) == NULL)
3433         return (NULL);
3434     dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
3435     dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
3436     if ((dh->p == NULL) || (dh->g == NULL)) {
3437         DH_free(dh);
3438         return (NULL);
3439     }
3440     return (dh);
3441 }
3442
3443 static DH *get_dh1024dsa()
3444 {
3445     static unsigned char dh1024_p[] = {
3446         0xC8, 0x00, 0xF7, 0x08, 0x07, 0x89, 0x4D, 0x90, 0x53, 0xF3, 0xD5,
3447         0x00,
3448         0x21, 0x1B, 0xF7, 0x31, 0xA6, 0xA2, 0xDA, 0x23, 0x9A, 0xC7, 0x87,
3449         0x19,
3450         0x3B, 0x47, 0xB6, 0x8C, 0x04, 0x6F, 0xFF, 0xC6, 0x9B, 0xB8, 0x65,
3451         0xD2,
3452         0xC2, 0x5F, 0x31, 0x83, 0x4A, 0xA7, 0x5F, 0x2F, 0x88, 0x38, 0xB6,
3453         0x55,
3454         0xCF, 0xD9, 0x87, 0x6D, 0x6F, 0x9F, 0xDA, 0xAC, 0xA6, 0x48, 0xAF,
3455         0xFC,
3456         0x33, 0x84, 0x37, 0x5B, 0x82, 0x4A, 0x31, 0x5D, 0xE7, 0xBD, 0x52,
3457         0x97,
3458         0xA1, 0x77, 0xBF, 0x10, 0x9E, 0x37, 0xEA, 0x64, 0xFA, 0xCA, 0x28,
3459         0x8D,
3460         0x9D, 0x3B, 0xD2, 0x6E, 0x09, 0x5C, 0x68, 0xC7, 0x45, 0x90, 0xFD,
3461         0xBB,
3462         0x70, 0xC9, 0x3A, 0xBB, 0xDF, 0xD4, 0x21, 0x0F, 0xC4, 0x6A, 0x3C,
3463         0xF6,
3464         0x61, 0xCF, 0x3F, 0xD6, 0x13, 0xF1, 0x5F, 0xBC, 0xCF, 0xBC, 0x26,
3465         0x9E,
3466         0xBC, 0x0B, 0xBD, 0xAB, 0x5D, 0xC9, 0x54, 0x39,
3467     };
3468     static unsigned char dh1024_g[] = {
3469         0x3B, 0x40, 0x86, 0xE7, 0xF3, 0x6C, 0xDE, 0x67, 0x1C, 0xCC, 0x80,
3470         0x05,
3471         0x5A, 0xDF, 0xFE, 0xBD, 0x20, 0x27, 0x74, 0x6C, 0x24, 0xC9, 0x03,
3472         0xF3,
3473         0xE1, 0x8D, 0xC3, 0x7D, 0x98, 0x27, 0x40, 0x08, 0xB8, 0x8C, 0x6A,
3474         0xE9,
3475         0xBB, 0x1A, 0x3A, 0xD6, 0x86, 0x83, 0x5E, 0x72, 0x41, 0xCE, 0x85,
3476         0x3C,
3477         0xD2, 0xB3, 0xFC, 0x13, 0xCE, 0x37, 0x81, 0x9E, 0x4C, 0x1C, 0x7B,
3478         0x65,
3479         0xD3, 0xE6, 0xA6, 0x00, 0xF5, 0x5A, 0x95, 0x43, 0x5E, 0x81, 0xCF,
3480         0x60,
3481         0xA2, 0x23, 0xFC, 0x36, 0xA7, 0x5D, 0x7A, 0x4C, 0x06, 0x91, 0x6E,
3482         0xF6,
3483         0x57, 0xEE, 0x36, 0xCB, 0x06, 0xEA, 0xF5, 0x3D, 0x95, 0x49, 0xCB,
3484         0xA7,
3485         0xDD, 0x81, 0xDF, 0x80, 0x09, 0x4A, 0x97, 0x4D, 0xA8, 0x22, 0x72,
3486         0xA1,
3487         0x7F, 0xC4, 0x70, 0x56, 0x70, 0xE8, 0x20, 0x10, 0x18, 0x8F, 0x2E,
3488         0x60,
3489         0x07, 0xE7, 0x68, 0x1A, 0x82, 0x5D, 0x32, 0xA2,
3490     };
3491     DH *dh;
3492
3493     if ((dh = DH_new()) == NULL)
3494         return (NULL);
3495     dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
3496     dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
3497     if ((dh->p == NULL) || (dh->g == NULL)) {
3498         DH_free(dh);
3499         return (NULL);
3500     }
3501     dh->length = 160;
3502     return (dh);
3503 }
3504 #endif
3505
3506 #ifndef OPENSSL_NO_PSK
3507 /* convert the PSK key (psk_key) in ascii to binary (psk) */
3508 static int psk_key2bn(const char *pskkey, unsigned char *psk,
3509                       unsigned int max_psk_len)
3510 {
3511     int ret;
3512     BIGNUM *bn = NULL;
3513
3514     ret = BN_hex2bn(&bn, pskkey);
3515     if (!ret) {
3516         BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
3517                    pskkey);
3518         BN_free(bn);
3519         return 0;
3520     }
3521     if (BN_num_bytes(bn) > (int)max_psk_len) {
3522         BIO_printf(bio_err,
3523                    "psk buffer of callback is too small (%d) for key (%d)\n",
3524                    max_psk_len, BN_num_bytes(bn));
3525         BN_free(bn);
3526         return 0;
3527     }
3528     ret = BN_bn2bin(bn, psk);
3529     BN_free(bn);
3530     return ret;
3531 }
3532
3533 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
3534                                         char *identity,
3535                                         unsigned int max_identity_len,
3536                                         unsigned char *psk,
3537                                         unsigned int max_psk_len)
3538 {
3539     int ret;
3540     unsigned int psk_len = 0;
3541
3542     ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3543     if (ret < 0)
3544         goto out_err;
3545     if (debug)
3546         fprintf(stderr, "client: created identity '%s' len=%d\n", identity,
3547                 ret);
3548     ret = psk_key2bn(psk_key, psk, max_psk_len);
3549     if (ret < 0)
3550         goto out_err;
3551     psk_len = ret;
3552  out_err:
3553     return psk_len;
3554 }
3555
3556 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3557                                         unsigned char *psk,
3558                                         unsigned int max_psk_len)
3559 {
3560     unsigned int psk_len = 0;
3561
3562     if (strcmp(identity, "Client_identity") != 0) {
3563         BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3564         return 0;
3565     }
3566     psk_len = psk_key2bn(psk_key, psk, max_psk_len);
3567     return psk_len;
3568 }
3569 #endif
3570
3571 static int do_test_cipherlist(void)
3572 {
3573 #ifndef OPENSSL_NO_TLS
3574     int i = 0;
3575     const SSL_METHOD *meth;
3576     const SSL_CIPHER *ci, *tci = NULL;
3577
3578     /*
3579      * This is required because ssltest "cheats" and uses internal headers to
3580      * call functions, thus avoiding auto-init
3581      */
3582     OPENSSL_init_crypto(0, NULL);
3583     OPENSSL_init_ssl(0, NULL);
3584
3585     meth = TLS_method();
3586     tci = NULL;
3587     while ((ci = meth->get_cipher(i++)) != NULL) {
3588         if (tci != NULL)
3589             if (ci->id >= tci->id) {
3590                 fprintf(stderr, "testing SSLv3 cipher list order: ");
3591                 fprintf(stderr, "failed %x vs. %x\n", ci->id, tci->id);
3592                 return 0;
3593             }
3594         tci = ci;
3595     }
3596 #endif
3597
3598     return 1;
3599 }