ssl/ssltest.c

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