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