test/ssltest.c

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