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 #include <openssl/bn.h>
 187
 188 /*
 189  * Or gethostname won't be declared properly
 190  * on Compaq platforms (at least with DEC C).
 191  * Do not try to put it earlier, or IPv6 includes
 192  * get screwed...
 193  */
 194 #define _XOPEN_SOURCE_EXTENDED  1
 195
 196 #ifdef OPENSSL_SYS_WINDOWS
 197 # include <winsock.h>
 198 #else
 199 # include OPENSSL_UNISTD
 200 #endif
 201
 202 #ifdef OPENSSL_SYS_VMS
 203 # define TEST_SERVER_CERT "SYS$DISK:[-.APPS]SERVER.PEM"
 204 # define TEST_CLIENT_CERT "SYS$DISK:[-.APPS]CLIENT.PEM"
 205 #elif defined(OPENSSL_SYS_WINCE)
 206 # define TEST_SERVER_CERT "\\OpenSSL\\server.pem"
 207 # define TEST_CLIENT_CERT "\\OpenSSL\\client.pem"
 208 #elif defined(OPENSSL_SYS_NETWARE)
 209 # define TEST_SERVER_CERT "\\openssl\\apps\\server.pem"
 210 # define TEST_CLIENT_CERT "\\openssl\\apps\\client.pem"
 211 #else
 212 # define TEST_SERVER_CERT "../apps/server.pem"
 213 # define TEST_CLIENT_CERT "../apps/client.pem"
 214 #endif
 215
 216 /*
 217  * There is really no standard for this, so let's assign some tentative
 218  * numbers.  In any case, these numbers are only for this test
 219  */
 220 #define COMP_RLE        255
 221 #define COMP_ZLIB       1
 222
 223 static int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx);
 224 #ifndef OPENSSL_NO_RSA
 225 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength);
 226 static void free_tmp_rsa(void);
 227 #endif
 228 static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg);
 229 #define APP_CALLBACK_STRING "Test Callback Argument"
 230 struct app_verify_arg {
 231     char *string;
 232     int app_verify;
 233     int allow_proxy_certs;
 234     char *proxy_auth;
 235     char *proxy_cond;
 236 };
 237
 238 #ifndef OPENSSL_NO_DH
 239 static DH *get_dh512(void);
 240 static DH *get_dh1024(void);
 241 static DH *get_dh1024dsa(void);
 242 #endif
 243
 244 static char *psk_key = NULL;    /* by default PSK is not used */
 245 #ifndef OPENSSL_NO_PSK
 246 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
 247                                         char *identity,
 248                                         unsigned int max_identity_len,
 249                                         unsigned char *psk,
 250                                         unsigned int max_psk_len);
 251 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
 252                                         unsigned char *psk,
 253                                         unsigned int max_psk_len);
 254 #endif
 255
 256 static BIO *bio_err = NULL;
 257 static BIO *bio_stdout = NULL;
 258
 259 static char *cipher = NULL;
 260 static int verbose = 0;
 261 static int debug = 0;
 262 #if 0
 263 /* Not used yet. */
 264 # ifdef FIONBIO
 265 static int s_nbio = 0;
 266 # endif
 267 #endif
 268
 269 static const char rnd_seed[] =
 270     "string to make the random number generator think it has entropy";
 271
 272 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long bytes, clock_t *s_time,
 273                  clock_t *c_time);
 274 int doit(SSL *s_ssl, SSL *c_ssl, long bytes);
 275 static int do_test_cipherlist(void);
 276 static void sv_usage(void)
 277 {
 278     fprintf(stderr, "usage: ssltest [args ...]\n");
 279     fprintf(stderr, "\n");
 280     fprintf(stderr, " -server_auth  - check server certificate\n");
 281     fprintf(stderr, " -client_auth  - do client authentication\n");
 282     fprintf(stderr, " -proxy        - allow proxy certificates\n");
 283     fprintf(stderr, " -proxy_auth <val> - set proxy policy rights\n");
 284     fprintf(stderr,
 285             " -proxy_cond <val> - experssion to test proxy policy rights\n");
 286     fprintf(stderr, " -v            - more output\n");
 287     fprintf(stderr, " -d            - debug output\n");
 288     fprintf(stderr, " -reuse        - use session-id reuse\n");
 289     fprintf(stderr, " -num <val>    - number of connections to perform\n");
 290     fprintf(stderr,
 291             " -bytes <val>  - number of bytes to swap between client/server\n");
 292 #ifndef OPENSSL_NO_DH
 293     fprintf(stderr,
 294             " -dhe1024      - use 1024 bit key (safe prime) for DHE\n");
 295     fprintf(stderr,
 296             " -dhe1024dsa   - use 1024 bit key (with 160-bit subprime) for DHE\n");
 297     fprintf(stderr, " -no_dhe       - disable DHE\n");
 298 #endif
 299 #ifndef OPENSSL_NO_ECDH
 300     fprintf(stderr, " -no_ecdhe     - disable ECDHE\n");
 301 #endif
 302 #ifndef OPENSSL_NO_PSK
 303     fprintf(stderr, " -psk arg      - PSK in hex (without 0x)\n");
 304 #endif
 305 #ifndef OPENSSL_NO_SSL2
 306     fprintf(stderr, " -ssl2         - use SSLv2\n");
 307 #endif
 308 #ifndef OPENSSL_NO_SSL3
 309     fprintf(stderr, " -ssl3         - use SSLv3\n");
 310 #endif
 311 #ifndef OPENSSL_NO_TLS1
 312     fprintf(stderr, " -tls1         - use TLSv1\n");
 313 #endif
 314     fprintf(stderr, " -CApath arg   - PEM format directory of CA's\n");
 315     fprintf(stderr, " -CAfile arg   - PEM format file of CA's\n");
 316     fprintf(stderr, " -cert arg     - Server certificate file\n");
 317     fprintf(stderr,
 318             " -key arg      - Server key file (default: same as -cert)\n");
 319     fprintf(stderr, " -c_cert arg   - Client certificate file\n");
 320     fprintf(stderr,
 321             " -c_key arg    - Client key file (default: same as -c_cert)\n");
 322     fprintf(stderr, " -cipher arg   - The cipher list\n");
 323     fprintf(stderr, " -bio_pair     - Use BIO pairs\n");
 324     fprintf(stderr, " -f            - Test even cases that can't work\n");
 325     fprintf(stderr,
 326             " -time         - measure processor time used by client and server\n");
 327     fprintf(stderr, " -zlib         - use zlib compression\n");
 328     fprintf(stderr, " -rle          - use rle compression\n");
 329 #ifndef OPENSSL_NO_ECDH
 330     fprintf(stderr,
 331             " -named_curve arg  - Elliptic curve name to use for ephemeral ECDH keys.\n"
 332             "                 Use \"openssl ecparam -list_curves\" for all names\n"
 333             "                 (default is sect163r2).\n");
 334 #endif
 335     fprintf(stderr,
 336             " -test_cipherlist - verifies the order of the ssl cipher lists\n");
 337 }
 338
 339 static void print_details(SSL *c_ssl, const char *prefix)
 340 {
 341     const SSL_CIPHER *ciph;
 342     X509 *cert;
 343
 344     ciph = SSL_get_current_cipher(c_ssl);
 345     BIO_printf(bio_stdout, "%s%s, cipher %s %s",
 346                prefix,
 347                SSL_get_version(c_ssl),
 348                SSL_CIPHER_get_version(ciph), SSL_CIPHER_get_name(ciph));
 349     cert = SSL_get_peer_certificate(c_ssl);
 350     if (cert != NULL) {
 351         EVP_PKEY *pkey = X509_get_pubkey(cert);
 352         if (pkey != NULL) {
 353             if (0) ;
 354 #ifndef OPENSSL_NO_RSA
 355             else if (pkey->type == EVP_PKEY_RSA && pkey->pkey.rsa != NULL
 356                      && pkey->pkey.rsa->n != NULL) {
 357                 BIO_printf(bio_stdout, ", %d bit RSA",
 358                            BN_num_bits(pkey->pkey.rsa->n));
 359             }
 360 #endif
 361 #ifndef OPENSSL_NO_DSA
 362             else if (pkey->type == EVP_PKEY_DSA && pkey->pkey.dsa != NULL
 363                      && pkey->pkey.dsa->p != NULL) {
 364                 BIO_printf(bio_stdout, ", %d bit DSA",
 365                            BN_num_bits(pkey->pkey.dsa->p));
 366             }
 367 #endif
 368             EVP_PKEY_free(pkey);
 369         }
 370         X509_free(cert);
 371     }
 372     /*
 373      * The SSL API does not allow us to look at temporary RSA/DH keys,
 374      * otherwise we should print their lengths too
 375      */
 376     BIO_printf(bio_stdout, "\n");
 377 }
 378
 379 static void lock_dbg_cb(int mode, int type, const char *file, int line)
 380 {
 381     static int modes[CRYPTO_NUM_LOCKS]; /* = {0, 0, ... } */
 382     const char *errstr = NULL;
 383     int rw;
 384
 385     rw = mode & (CRYPTO_READ | CRYPTO_WRITE);
 386     if (!((rw == CRYPTO_READ) || (rw == CRYPTO_WRITE))) {
 387         errstr = "invalid mode";
 388         goto err;
 389     }
 390
 391     if (type < 0 || type >= CRYPTO_NUM_LOCKS) {
 392         errstr = "type out of bounds";
 393         goto err;
 394     }
 395
 396     if (mode & CRYPTO_LOCK) {
 397         if (modes[type]) {
 398             errstr = "already locked";
 399             /*
 400              * must not happen in a single-threaded program (would deadlock)
 401              */
 402             goto err;
 403         }
 404
 405         modes[type] = rw;
 406     } else if (mode & CRYPTO_UNLOCK) {
 407         if (!modes[type]) {
 408             errstr = "not locked";
 409             goto err;
 410         }
 411
 412         if (modes[type] != rw) {
 413             errstr = (rw == CRYPTO_READ) ?
 414                 "CRYPTO_r_unlock on write lock" :
 415                 "CRYPTO_w_unlock on read lock";
 416         }
 417
 418         modes[type] = 0;
 419     } else {
 420         errstr = "invalid mode";
 421         goto err;
 422     }
 423
 424  err:
 425     if (errstr) {
 426         /* we cannot use bio_err here */
 427         fprintf(stderr,
 428                 "openssl (lock_dbg_cb): %s (mode=%d, type=%d) at %s:%d\n",
 429                 errstr, mode, type, file, line);
 430     }
 431 }
 432
 433 #ifdef TLSEXT_TYPE_opaque_prf_input
 434 struct cb_info_st {
 435     void *input;
 436     size_t len;
 437     int ret;
 438 };
 439 struct cb_info_st co1 = { "C", 1, 1 }; /* try to negotiate oqaque PRF input */
 440 struct cb_info_st co2 = { "C", 1, 2 }; /* insist on oqaque PRF input */
 441 struct cb_info_st so1 = { "S", 1, 1 }; /* try to negotiate oqaque PRF input */
 442 struct cb_info_st so2 = { "S", 1, 2 }; /* insist on oqaque PRF input */
 443
 444 int opaque_prf_input_cb(SSL *ssl, void *peerinput, size_t len, void *arg_)
 445 {
 446     struct cb_info_st *arg = arg_;
 447
 448     if (arg == NULL)
 449         return 1;
 450
 451     if (!SSL_set_tlsext_opaque_prf_input(ssl, arg->input, arg->len))
 452         return 0;
 453     return arg->ret;
 454 }
 455 #endif
 456
 457 int main(int argc, char *argv[])
 458 {
 459     char *CApath = NULL, *CAfile = NULL;
 460     int badop = 0;
 461     int bio_pair = 0;
 462     int force = 0;
 463     int tls1 = 0, ssl2 = 0, ssl3 = 0, ret = 1;
 464     int client_auth = 0;
 465     int server_auth = 0, i;
 466     struct app_verify_arg app_verify_arg =
 467         { APP_CALLBACK_STRING, 0, 0, NULL, NULL };
 468     char *server_cert = TEST_SERVER_CERT;
 469     char *server_key = NULL;
 470     char *client_cert = TEST_CLIENT_CERT;
 471     char *client_key = NULL;
 472 #ifndef OPENSSL_NO_ECDH
 473     char *named_curve = NULL;
 474 #endif
 475     SSL_CTX *s_ctx = NULL;
 476     SSL_CTX *c_ctx = NULL;
 477     const SSL_METHOD *meth = NULL;
 478     SSL *c_ssl, *s_ssl;
 479     int number = 1, reuse = 0;
 480     long bytes = 256L;
 481 #ifndef OPENSSL_NO_DH
 482     DH *dh;
 483     int dhe1024 = 0, dhe1024dsa = 0;
 484 #endif
 485 #ifndef OPENSSL_NO_ECDH
 486     EC_KEY *ecdh = NULL;
 487 #endif
 488     int no_dhe = 0;
 489     int no_ecdhe = 0;
 490     int no_psk = 0;
 491     int print_time = 0;
 492     clock_t s_time = 0, c_time = 0;
 493     int comp = 0;
 494 #ifndef OPENSSL_NO_COMP
 495     COMP_METHOD *cm = NULL;
 496 #endif
 497     STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
 498     int test_cipherlist = 0;
 499
 500     verbose = 0;
 501     debug = 0;
 502     cipher = 0;
 503
 504     bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
 505
 506     CRYPTO_set_locking_callback(lock_dbg_cb);
 507
 508     /* enable memory leak checking unless explicitly disabled */
 509     if (!((getenv("OPENSSL_DEBUG_MEMORY") != NULL)
 510           && (0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off")))) {
 511         CRYPTO_malloc_debug_init();
 512         CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
 513     } else {
 514         /* OPENSSL_DEBUG_MEMORY=off */
 515         CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);
 516     }
 517     CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
 518
 519     RAND_seed(rnd_seed, sizeof rnd_seed);
 520
 521     bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);
 522
 523     argc--;
 524     argv++;
 525
 526     while (argc >= 1) {
 527         if (strcmp(*argv, "-server_auth") == 0)
 528             server_auth = 1;
 529         else if (strcmp(*argv, "-client_auth") == 0)
 530             client_auth = 1;
 531         else if (strcmp(*argv, "-proxy_auth") == 0) {
 532             if (--argc < 1)
 533                 goto bad;
 534             app_verify_arg.proxy_auth = *(++argv);
 535         } else if (strcmp(*argv, "-proxy_cond") == 0) {
 536             if (--argc < 1)
 537                 goto bad;
 538             app_verify_arg.proxy_cond = *(++argv);
 539         } else if (strcmp(*argv, "-v") == 0)
 540             verbose = 1;
 541         else if (strcmp(*argv, "-d") == 0)
 542             debug = 1;
 543         else if (strcmp(*argv, "-reuse") == 0)
 544             reuse = 1;
 545         else if (strcmp(*argv, "-dhe1024") == 0) {
 546 #ifndef OPENSSL_NO_DH
 547             dhe1024 = 1;
 548 #else
 549             fprintf(stderr,
 550                     "ignoring -dhe1024, since I'm compiled without DH\n");
 551 #endif
 552         } else if (strcmp(*argv, "-dhe1024dsa") == 0) {
 553 #ifndef OPENSSL_NO_DH
 554             dhe1024dsa = 1;
 555 #else
 556             fprintf(stderr,
 557                     "ignoring -dhe1024, since I'm compiled without DH\n");
 558 #endif
 559         } else if (strcmp(*argv, "-no_dhe") == 0)
 560             no_dhe = 1;
 561         else if (strcmp(*argv, "-no_ecdhe") == 0)
 562             no_ecdhe = 1;
 563         else if (strcmp(*argv, "-psk") == 0) {
 564             if (--argc < 1)
 565                 goto bad;
 566             psk_key = *(++argv);
 567 #ifndef OPENSSL_NO_PSK
 568             if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key)) {
 569                 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
 570                 goto bad;
 571             }
 572 #else
 573             no_psk = 1;
 574 #endif
 575         } else if (strcmp(*argv, "-ssl2") == 0)
 576             ssl2 = 1;
 577         else if (strcmp(*argv, "-tls1") == 0)
 578             tls1 = 1;
 579         else if (strcmp(*argv, "-ssl3") == 0)
 580             ssl3 = 1;
 581         else if (strncmp(*argv, "-num", 4) == 0) {
 582             if (--argc < 1)
 583                 goto bad;
 584             number = atoi(*(++argv));
 585             if (number == 0)
 586                 number = 1;
 587         } else if (strcmp(*argv, "-bytes") == 0) {
 588             if (--argc < 1)
 589                 goto bad;
 590             bytes = atol(*(++argv));
 591             if (bytes == 0L)
 592                 bytes = 1L;
 593             i = strlen(argv[0]);
 594             if (argv[0][i - 1] == 'k')
 595                 bytes *= 1024L;
 596             if (argv[0][i - 1] == 'm')
 597                 bytes *= 1024L * 1024L;
 598         } else if (strcmp(*argv, "-cert") == 0) {
 599             if (--argc < 1)
 600                 goto bad;
 601             server_cert = *(++argv);
 602         } else if (strcmp(*argv, "-s_cert") == 0) {
 603             if (--argc < 1)
 604                 goto bad;
 605             server_cert = *(++argv);
 606         } else if (strcmp(*argv, "-key") == 0) {
 607             if (--argc < 1)
 608                 goto bad;
 609             server_key = *(++argv);
 610         } else if (strcmp(*argv, "-s_key") == 0) {
 611             if (--argc < 1)
 612                 goto bad;
 613             server_key = *(++argv);
 614         } else if (strcmp(*argv, "-c_cert") == 0) {
 615             if (--argc < 1)
 616                 goto bad;
 617             client_cert = *(++argv);
 618         } else if (strcmp(*argv, "-c_key") == 0) {
 619             if (--argc < 1)
 620                 goto bad;
 621             client_key = *(++argv);
 622         } else if (strcmp(*argv, "-cipher") == 0) {
 623             if (--argc < 1)
 624                 goto bad;
 625             cipher = *(++argv);
 626         } else if (strcmp(*argv, "-CApath") == 0) {
 627             if (--argc < 1)
 628                 goto bad;
 629             CApath = *(++argv);
 630         } else if (strcmp(*argv, "-CAfile") == 0) {
 631             if (--argc < 1)
 632                 goto bad;
 633             CAfile = *(++argv);
 634         } else if (strcmp(*argv, "-bio_pair") == 0) {
 635             bio_pair = 1;
 636         } else if (strcmp(*argv, "-f") == 0) {
 637             force = 1;
 638         } else if (strcmp(*argv, "-time") == 0) {
 639             print_time = 1;
 640         } else if (strcmp(*argv, "-zlib") == 0) {
 641             comp = COMP_ZLIB;
 642         } else if (strcmp(*argv, "-rle") == 0) {
 643             comp = COMP_RLE;
 644         } else if (strcmp(*argv, "-named_curve") == 0) {
 645             if (--argc < 1)
 646                 goto bad;
 647 #ifndef OPENSSL_NO_ECDH
 648             named_curve = *(++argv);
 649 #else
 650             fprintf(stderr,
 651                     "ignoring -named_curve, since I'm compiled without ECDH\n");
 652             ++argv;
 653 #endif
 654         } else if (strcmp(*argv, "-app_verify") == 0) {
 655             app_verify_arg.app_verify = 1;
 656         } else if (strcmp(*argv, "-proxy") == 0) {
 657             app_verify_arg.allow_proxy_certs = 1;
 658         } else if (strcmp(*argv, "-test_cipherlist") == 0) {
 659             test_cipherlist = 1;
 660         } else {
 661             fprintf(stderr, "unknown option %s\n", *argv);
 662             badop = 1;
 663             break;
 664         }
 665         argc--;
 666         argv++;
 667     }
 668     if (badop) {
 669  bad:
 670         sv_usage();
 671         goto end;
 672     }
 673
 674     if (test_cipherlist == 1) {
 675         /*
 676          * ensure that the cipher list are correctly sorted and exit
 677          */
 678         if (do_test_cipherlist() == 0)
 679             EXIT(1);
 680         ret = 0;
 681         goto end;
 682     }
 683
 684     if (!ssl2 && !ssl3 && !tls1 && number > 1 && !reuse && !force) {
 685         fprintf(stderr, "This case cannot work.  Use -f to perform "
 686                 "the test anyway (and\n-d to see what happens), "
 687                 "or add one of -ssl2, -ssl3, -tls1, -reuse\n"
 688                 "to avoid protocol mismatch.\n");
 689         EXIT(1);
 690     }
 691
 692     if (print_time) {
 693         if (!bio_pair) {
 694             fprintf(stderr, "Using BIO pair (-bio_pair)\n");
 695             bio_pair = 1;
 696         }
 697         if (number < 50 && !force)
 698             fprintf(stderr,
 699                     "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
 700     }
 701
 702 /*      if (cipher == NULL) cipher=getenv("SSL_CIPHER"); */
 703
 704     SSL_library_init();
 705     SSL_load_error_strings();
 706
 707 #ifndef OPENSSL_NO_COMP
 708     if (comp == COMP_ZLIB)
 709         cm = COMP_zlib();
 710     if (comp == COMP_RLE)
 711         cm = COMP_rle();
 712     if (cm != NULL) {
 713         if (cm->type != NID_undef) {
 714             if (SSL_COMP_add_compression_method(comp, cm) != 0) {
 715                 fprintf(stderr, "Failed to add compression method\n");
 716                 ERR_print_errors_fp(stderr);
 717             }
 718         } else {
 719             fprintf(stderr,
 720                     "Warning: %s compression not supported\n",
 721                     (comp == COMP_RLE ? "rle" :
 722                      (comp == COMP_ZLIB ? "zlib" : "unknown")));
 723             ERR_print_errors_fp(stderr);
 724         }
 725     }
 726     ssl_comp_methods = SSL_COMP_get_compression_methods();
 727     fprintf(stderr, "Available compression methods:\n");
 728     {
 729         int j, n = sk_SSL_COMP_num(ssl_comp_methods);
 730         if (n == 0)
 731             fprintf(stderr, "  NONE\n");
 732         else
 733             for (j = 0; j < n; j++) {
 734                 SSL_COMP *c = sk_SSL_COMP_value(ssl_comp_methods, j);
 735                 fprintf(stderr, "  %d: %s\n", c->id, c->name);
 736             }
 737     }
 738 #endif
 739
 740 #if !defined(OPENSSL_NO_SSL2) && !defined(OPENSSL_NO_SSL3)
 741     if (ssl2)
 742         meth = SSLv2_method();
 743     else if (tls1)
 744         meth = TLSv1_method();
 745     else if (ssl3)
 746         meth = SSLv3_method();
 747     else
 748         meth = SSLv23_method();
 749 #else
 750 # ifdef OPENSSL_NO_SSL2
 751     if (tls1)
 752         meth = TLSv1_method();
 753     else if (ssl3)
 754         meth = SSLv3_method();
 755     else
 756         meth = SSLv23_method();
 757 # else
 758     meth = SSLv2_method();
 759 # endif
 760 #endif
 761
 762     c_ctx = SSL_CTX_new(meth);
 763     s_ctx = SSL_CTX_new(meth);
 764     if ((c_ctx == NULL) || (s_ctx == NULL)) {
 765         ERR_print_errors(bio_err);
 766         goto end;
 767     }
 768
 769     if (cipher != NULL) {
 770         SSL_CTX_set_cipher_list(c_ctx, cipher);
 771         SSL_CTX_set_cipher_list(s_ctx, cipher);
 772     }
 773 #ifndef OPENSSL_NO_DH
 774     if (!no_dhe) {
 775         if (dhe1024dsa) {
 776             /*
 777              * use SSL_OP_SINGLE_DH_USE to avoid small subgroup attacks
 778              */
 779             SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_DH_USE);
 780             dh = get_dh1024dsa();
 781         } else if (dhe1024)
 782             dh = get_dh1024();
 783         else
 784             dh = get_dh512();
 785         SSL_CTX_set_tmp_dh(s_ctx, dh);
 786         DH_free(dh);
 787     }
 788 #else
 789     (void)no_dhe;
 790 #endif
 791
 792 #ifndef OPENSSL_NO_ECDH
 793     if (!no_ecdhe) {
 794         int nid;
 795
 796         if (named_curve != NULL) {
 797             nid = OBJ_sn2nid(named_curve);
 798             if (nid == 0) {
 799                 BIO_printf(bio_err, "unknown curve name (%s)\n", named_curve);
 800                 goto end;
 801             }
 802         } else
 803             nid = NID_sect163r2;
 804
 805         ecdh = EC_KEY_new_by_curve_name(nid);
 806         if (ecdh == NULL) {
 807             BIO_printf(bio_err, "unable to create curve\n");
 808             goto end;
 809         }
 810
 811         SSL_CTX_set_tmp_ecdh(s_ctx, ecdh);
 812         SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_ECDH_USE);
 813         EC_KEY_free(ecdh);
 814     }
 815 #else
 816     (void)no_ecdhe;
 817 #endif
 818
 819 #ifndef OPENSSL_NO_RSA
 820     SSL_CTX_set_tmp_rsa_callback(s_ctx, tmp_rsa_cb);
 821 #endif
 822
 823 #ifdef TLSEXT_TYPE_opaque_prf_input
 824     SSL_CTX_set_tlsext_opaque_prf_input_callback(c_ctx, opaque_prf_input_cb);
 825     SSL_CTX_set_tlsext_opaque_prf_input_callback(s_ctx, opaque_prf_input_cb);
 826     /* or &co2 or NULL */
 827     SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(c_ctx, &co1);
 828     /* or &so2 or NULL */
 829     SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(s_ctx, &so1);
 830 #endif
 831
 832     if (!SSL_CTX_use_certificate_file(s_ctx, server_cert, SSL_FILETYPE_PEM)) {
 833         ERR_print_errors(bio_err);
 834     } else if (!SSL_CTX_use_PrivateKey_file(s_ctx,
 835                                             (server_key ? server_key :
 836                                              server_cert),
 837                                             SSL_FILETYPE_PEM)) {
 838         ERR_print_errors(bio_err);
 839         goto end;
 840     }
 841
 842     if (client_auth) {
 843         SSL_CTX_use_certificate_file(c_ctx, client_cert, SSL_FILETYPE_PEM);
 844         SSL_CTX_use_PrivateKey_file(c_ctx,
 845                                     (client_key ? client_key : client_cert),
 846                                     SSL_FILETYPE_PEM);
 847     }
 848
 849     if ((!SSL_CTX_load_verify_locations(s_ctx, CAfile, CApath)) ||
 850         (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
 851         (!SSL_CTX_load_verify_locations(c_ctx, CAfile, CApath)) ||
 852         (!SSL_CTX_set_default_verify_paths(c_ctx))) {
 853         /* fprintf(stderr,"SSL_load_verify_locations\n"); */
 854         ERR_print_errors(bio_err);
 855         /* goto end; */
 856     }
 857
 858     if (client_auth) {
 859         BIO_printf(bio_err, "client authentication\n");
 860         SSL_CTX_set_verify(s_ctx,
 861                            SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
 862                            verify_callback);
 863         SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback,
 864                                          &app_verify_arg);
 865     }
 866     if (server_auth) {
 867         BIO_printf(bio_err, "server authentication\n");
 868         SSL_CTX_set_verify(c_ctx, SSL_VERIFY_PEER, verify_callback);
 869         SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback,
 870                                          &app_verify_arg);
 871     }
 872
 873     {
 874         int session_id_context = 0;
 875         SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context,
 876                                        sizeof session_id_context);
 877     }
 878
 879     /* Use PSK only if PSK key is given */
 880     if (psk_key != NULL) {
 881         /*
 882          * no_psk is used to avoid putting psk command to openssl tool
 883          */
 884         if (no_psk) {
 885             /*
 886              * if PSK is not compiled in and psk key is given, do nothing and
 887              * exit successfully
 888              */
 889             ret = 0;
 890             goto end;
 891         }
 892 #ifndef OPENSSL_NO_PSK
 893         SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
 894         SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
 895         if (debug)
 896             BIO_printf(bio_err, "setting PSK identity hint to s_ctx\n");
 897         if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint")) {
 898             BIO_printf(bio_err, "error setting PSK identity hint to s_ctx\n");
 899             ERR_print_errors(bio_err);
 900             goto end;
 901         }
 902 #endif
 903     }
 904
 905     c_ssl = SSL_new(c_ctx);
 906     s_ssl = SSL_new(s_ctx);
 907
 908 #ifndef OPENSSL_NO_KRB5
 909     if (c_ssl && c_ssl->kssl_ctx) {
 910         char localhost[MAXHOSTNAMELEN + 2];
 911
 912         if (gethostname(localhost, sizeof localhost - 1) == 0) {
 913             localhost[sizeof localhost - 1] = '\0';
 914             if (strlen(localhost) == sizeof localhost - 1) {
 915                 BIO_printf(bio_err, "localhost name too long\n");
 916                 goto end;
 917             }
 918             kssl_ctx_setstring(c_ssl->kssl_ctx, KSSL_SERVER, localhost);
 919         }
 920     }
 921 #endif                          /* OPENSSL_NO_KRB5 */
 922
 923     for (i = 0; i < number; i++) {
 924         if (!reuse)
 925             SSL_set_session(c_ssl, NULL);
 926         if (bio_pair)
 927             ret = doit_biopair(s_ssl, c_ssl, bytes, &s_time, &c_time);
 928         else
 929             ret = doit(s_ssl, c_ssl, bytes);
 930     }
 931
 932     if (!verbose) {
 933         print_details(c_ssl, "");
 934     }
 935     if ((number > 1) || (bytes > 1L))
 936         BIO_printf(bio_stdout, "%d handshakes of %ld bytes done\n", number,
 937                    bytes);
 938     if (print_time) {
 939 #ifdef CLOCKS_PER_SEC
 940         /*
 941          * "To determine the time in seconds, the value returned by the clock
 942          * function should be divided by the value of the macro
 943          * CLOCKS_PER_SEC." -- ISO/IEC 9899
 944          */
 945         BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
 946                    "Approximate total client time: %6.2f s\n",
 947                    (double)s_time / CLOCKS_PER_SEC,
 948                    (double)c_time / CLOCKS_PER_SEC);
 949 #else
 950         /*
 951          * "`CLOCKS_PER_SEC' undeclared (first use this function)" -- cc on
 952          * NeXTstep/OpenStep
 953          */
 954         BIO_printf(bio_stdout,
 955                    "Approximate total server time: %6.2f units\n"
 956                    "Approximate total client time: %6.2f units\n",
 957                    (double)s_time, (double)c_time);
 958 #endif
 959     }
 960
 961     SSL_free(s_ssl);
 962     SSL_free(c_ssl);
 963
 964  end:
 965     if (s_ctx != NULL)
 966         SSL_CTX_free(s_ctx);
 967     if (c_ctx != NULL)
 968         SSL_CTX_free(c_ctx);
 969
 970     if (bio_stdout != NULL)
 971         BIO_free(bio_stdout);
 972
 973 #ifndef OPENSSL_NO_RSA
 974     free_tmp_rsa();
 975 #endif
 976 #ifndef OPENSSL_NO_ENGINE
 977     ENGINE_cleanup();
 978 #endif
 979     CRYPTO_cleanup_all_ex_data();
 980     ERR_free_strings();
 981     ERR_remove_thread_state(NULL);
 982     EVP_cleanup();
 983     CRYPTO_mem_leaks(bio_err);
 984     if (bio_err != NULL)
 985         BIO_free(bio_err);
 986     EXIT(ret);
 987     return ret;
 988 }
 989
 990 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
 991                  clock_t *s_time, clock_t *c_time)
 992 {
 993     long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
 994     BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
 995     BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
 996     int ret = 1;
 997
 998     size_t bufsiz = 256;        /* small buffer for testing */
 999
1000     if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
1001         goto err;
1002     if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
1003         goto err;
1004
1005     s_ssl_bio = BIO_new(BIO_f_ssl());
1006     if (!s_ssl_bio)
1007         goto err;
1008
1009     c_ssl_bio = BIO_new(BIO_f_ssl());
1010     if (!c_ssl_bio)
1011         goto err;
1012
1013     SSL_set_connect_state(c_ssl);
1014     SSL_set_bio(c_ssl, client, client);
1015     (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1016
1017     SSL_set_accept_state(s_ssl);
1018     SSL_set_bio(s_ssl, server, server);
1019     (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1020
1021     do {
1022         /*-
1023          * c_ssl_bio:          SSL filter BIO
1024          *
1025          * client:             pseudo-I/O for SSL library
1026          *
1027          * client_io:          client's SSL communication; usually to be
1028          *                     relayed over some I/O facility, but in this
1029          *                     test program, we're the server, too:
1030          *
1031          * server_io:          server's SSL communication
1032          *
1033          * server:             pseudo-I/O for SSL library
1034          *
1035          * s_ssl_bio:          SSL filter BIO
1036          *
1037          * The client and the server each employ a "BIO pair":
1038          * client + client_io, server + server_io.
1039          * BIO pairs are symmetric.  A BIO pair behaves similar
1040          * to a non-blocking socketpair (but both endpoints must
1041          * be handled by the same thread).
1042          * [Here we could connect client and server to the ends
1043          * of a single BIO pair, but then this code would be less
1044          * suitable as an example for BIO pairs in general.]
1045          *
1046          * Useful functions for querying the state of BIO pair endpoints:
1047          *
1048          * BIO_ctrl_pending(bio)              number of bytes we can read now
1049          * BIO_ctrl_get_read_request(bio)     number of bytes needed to fulfil
1050          *                                      other side's read attempt
1051          * BIO_ctrl_get_write_guarantee(bio)   number of bytes we can write now
1052          *
1053          * ..._read_request is never more than ..._write_guarantee;
1054          * it depends on the application which one you should use.
1055          */
1056
1057         /*
1058          * We have non-blocking behaviour throughout this test program, but
1059          * can be sure that there is *some* progress in each iteration; so we
1060          * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
1061          * we just try everything in each iteration
1062          */
1063
1064         {
1065             /* CLIENT */
1066
1067             MS_STATIC char cbuf[1024 * 8];
1068             int i, r;
1069             clock_t c_clock = clock();
1070
1071             memset(cbuf, 0, sizeof(cbuf));
1072
1073             if (debug)
1074                 if (SSL_in_init(c_ssl))
1075                     printf("client waiting in SSL_connect - %s\n",
1076                            SSL_state_string_long(c_ssl));
1077
1078             if (cw_num > 0) {
1079                 /* Write to server. */
1080
1081                 if (cw_num > (long)sizeof cbuf)
1082                     i = sizeof cbuf;
1083                 else
1084                     i = (int)cw_num;
1085                 r = BIO_write(c_ssl_bio, cbuf, i);
1086                 if (r < 0) {
1087                     if (!BIO_should_retry(c_ssl_bio)) {
1088                         fprintf(stderr, "ERROR in CLIENT\n");
1089                         goto err;
1090                     }
1091                     /*
1092                      * BIO_should_retry(...) can just be ignored here. The
1093                      * library expects us to call BIO_write with the same
1094                      * arguments again, and that's what we will do in the
1095                      * next iteration.
1096                      */
1097                 } else if (r == 0) {
1098                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1099                     goto err;
1100                 } else {
1101                     if (debug)
1102                         printf("client wrote %d\n", r);
1103                     cw_num -= r;
1104                 }
1105             }
1106
1107             if (cr_num > 0) {
1108                 /* Read from server. */
1109
1110                 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1111                 if (r < 0) {
1112                     if (!BIO_should_retry(c_ssl_bio)) {
1113                         fprintf(stderr, "ERROR in CLIENT\n");
1114                         goto err;
1115                     }
1116                     /*
1117                      * Again, "BIO_should_retry" can be ignored.
1118                      */
1119                 } else if (r == 0) {
1120                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1121                     goto err;
1122                 } else {
1123                     if (debug)
1124                         printf("client read %d\n", r);
1125                     cr_num -= r;
1126                 }
1127             }
1128
1129             /*
1130              * c_time and s_time increments will typically be very small
1131              * (depending on machine speed and clock tick intervals), but
1132              * sampling over a large number of connections should result in
1133              * fairly accurate figures.  We cannot guarantee a lot, however
1134              * -- if each connection lasts for exactly one clock tick, it
1135              * will be counted only for the client or only for the server or
1136              * even not at all.
1137              */
1138             *c_time += (clock() - c_clock);
1139         }
1140
1141         {
1142             /* SERVER */
1143
1144             MS_STATIC char sbuf[1024 * 8];
1145             int i, r;
1146             clock_t s_clock = clock();
1147
1148             memset(sbuf, 0, sizeof(sbuf));
1149
1150             if (debug)
1151                 if (SSL_in_init(s_ssl))
1152                     printf("server waiting in SSL_accept - %s\n",
1153                            SSL_state_string_long(s_ssl));
1154
1155             if (sw_num > 0) {
1156                 /* Write to client. */
1157
1158                 if (sw_num > (long)sizeof sbuf)
1159                     i = sizeof sbuf;
1160                 else
1161                     i = (int)sw_num;
1162                 r = BIO_write(s_ssl_bio, sbuf, i);
1163                 if (r < 0) {
1164                     if (!BIO_should_retry(s_ssl_bio)) {
1165                         fprintf(stderr, "ERROR in SERVER\n");
1166                         goto err;
1167                     }
1168                     /* Ignore "BIO_should_retry". */
1169                 } else if (r == 0) {
1170                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
1171                     goto err;
1172                 } else {
1173                     if (debug)
1174                         printf("server wrote %d\n", r);
1175                     sw_num -= r;
1176                 }
1177             }
1178
1179             if (sr_num > 0) {
1180                 /* Read from client. */
1181
1182                 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
1183                 if (r < 0) {
1184                     if (!BIO_should_retry(s_ssl_bio)) {
1185                         fprintf(stderr, "ERROR in SERVER\n");
1186                         goto err;
1187                     }
1188                     /* blah, blah */
1189                 } else if (r == 0) {
1190                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
1191                     goto err;
1192                 } else {
1193                     if (debug)
1194                         printf("server read %d\n", r);
1195                     sr_num -= r;
1196                 }
1197             }
1198
1199             *s_time += (clock() - s_clock);
1200         }
1201
1202         {
1203             /* "I/O" BETWEEN CLIENT AND SERVER. */
1204
1205             size_t r1, r2;
1206             BIO *io1 = server_io, *io2 = client_io;
1207             /*
1208              * we use the non-copying interface for io1 and the standard
1209              * BIO_write/BIO_read interface for io2
1210              */
1211
1212             static int prev_progress = 1;
1213             int progress = 0;
1214
1215             /* io1 to io2 */
1216             do {
1217                 size_t num;
1218                 int r;
1219
1220                 r1 = BIO_ctrl_pending(io1);
1221                 r2 = BIO_ctrl_get_write_guarantee(io2);
1222
1223                 num = r1;
1224                 if (r2 < num)
1225                     num = r2;
1226                 if (num) {
1227                     char *dataptr;
1228
1229                     if (INT_MAX < num) /* yeah, right */
1230                         num = INT_MAX;
1231
1232                     r = BIO_nread(io1, &dataptr, (int)num);
1233                     assert(r > 0);
1234                     assert(r <= (int)num);
1235                     /*
1236                      * possibly r < num (non-contiguous data)
1237                      */
1238                     num = r;
1239                     r = BIO_write(io2, dataptr, (int)num);
1240                     if (r != (int)num) { /* can't happen */
1241                         fprintf(stderr, "ERROR: BIO_write could not write "
1242                                 "BIO_ctrl_get_write_guarantee() bytes");
1243                         goto err;
1244                     }
1245                     progress = 1;
1246
1247                     if (debug)
1248                         printf((io1 == client_io) ?
1249                                "C->S relaying: %d bytes\n" :
1250                                "S->C relaying: %d bytes\n", (int)num);
1251                 }
1252             }
1253             while (r1 && r2);
1254
1255             /* io2 to io1 */
1256             {
1257                 size_t num;
1258                 int r;
1259
1260                 r1 = BIO_ctrl_pending(io2);
1261                 r2 = BIO_ctrl_get_read_request(io1);
1262                 /*
1263                  * here we could use ..._get_write_guarantee instead of
1264                  * ..._get_read_request, but by using the latter we test
1265                  * restartability of the SSL implementation more thoroughly
1266                  */
1267                 num = r1;
1268                 if (r2 < num)
1269                     num = r2;
1270                 if (num) {
1271                     char *dataptr;
1272
1273                     if (INT_MAX < num)
1274                         num = INT_MAX;
1275
1276                     if (num > 1)
1277                         --num;  /* test restartability even more thoroughly */
1278
1279                     r = BIO_nwrite0(io1, &dataptr);
1280                     assert(r > 0);
1281                     if (r < (int)num)
1282                         num = r;
1283                     r = BIO_read(io2, dataptr, (int)num);
1284                     if (r != (int)num) { /* can't happen */
1285                         fprintf(stderr, "ERROR: BIO_read could not read "
1286                                 "BIO_ctrl_pending() bytes");
1287                         goto err;
1288                     }
1289                     progress = 1;
1290                     r = BIO_nwrite(io1, &dataptr, (int)num);
1291                     if (r != (int)num) { /* can't happen */
1292                         fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
1293                                 "BIO_nwrite0() bytes");
1294                         goto err;
1295                     }
1296
1297                     if (debug)
1298                         printf((io2 == client_io) ?
1299                                "C->S relaying: %d bytes\n" :
1300                                "S->C relaying: %d bytes\n", (int)num);
1301                 }
1302             }                   /* no loop, BIO_ctrl_get_read_request now
1303                                  * returns 0 anyway */
1304
1305             if (!progress && !prev_progress)
1306                 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0) {
1307                     fprintf(stderr, "ERROR: got stuck\n");
1308                     if (strcmp("SSLv2", SSL_get_version(c_ssl)) == 0) {
1309                         fprintf(stderr, "This can happen for SSL2 because "
1310                                 "CLIENT-FINISHED and SERVER-VERIFY are written \n"
1311                                 "concurrently ...");
1312                         if (strncmp("2SCF", SSL_state_string(c_ssl), 4) == 0
1313                             && strncmp("2SSV", SSL_state_string(s_ssl),
1314                                        4) == 0) {
1315                             fprintf(stderr, " ok.\n");
1316                             goto end;
1317                         }
1318                     }
1319                     fprintf(stderr, " ERROR.\n");
1320                     goto err;
1321                 }
1322             prev_progress = progress;
1323         }
1324     }
1325     while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
1326
1327     if (verbose)
1328         print_details(c_ssl, "DONE via BIO pair: ");
1329  end:
1330     ret = 0;
1331
1332  err:
1333     ERR_print_errors(bio_err);
1334
1335     if (server)
1336         BIO_free(server);
1337     if (server_io)
1338         BIO_free(server_io);
1339     if (client)
1340         BIO_free(client);
1341     if (client_io)
1342         BIO_free(client_io);
1343     if (s_ssl_bio)
1344         BIO_free(s_ssl_bio);
1345     if (c_ssl_bio)
1346         BIO_free(c_ssl_bio);
1347
1348     return ret;
1349 }
1350
1351 #define W_READ  1
1352 #define W_WRITE 2
1353 #define C_DONE  1
1354 #define S_DONE  2
1355
1356 int doit(SSL *s_ssl, SSL *c_ssl, long count)
1357 {
1358     MS_STATIC char cbuf[1024 * 8], sbuf[1024 * 8];
1359     long cw_num = count, cr_num = count;
1360     long sw_num = count, sr_num = count;
1361     int ret = 1;
1362     BIO *c_to_s = NULL;
1363     BIO *s_to_c = NULL;
1364     BIO *c_bio = NULL;
1365     BIO *s_bio = NULL;
1366     int c_r, c_w, s_r, s_w;
1367     int i, j;
1368     int done = 0;
1369     int c_write, s_write;
1370     int do_server = 0, do_client = 0;
1371
1372     memset(cbuf, 0, sizeof(cbuf));
1373     memset(sbuf, 0, sizeof(sbuf));
1374
1375     c_to_s = BIO_new(BIO_s_mem());
1376     s_to_c = BIO_new(BIO_s_mem());
1377     if ((s_to_c == NULL) || (c_to_s == NULL)) {
1378         ERR_print_errors(bio_err);
1379         goto err;
1380     }
1381
1382     c_bio = BIO_new(BIO_f_ssl());
1383     s_bio = BIO_new(BIO_f_ssl());
1384     if ((c_bio == NULL) || (s_bio == NULL)) {
1385         ERR_print_errors(bio_err);
1386         goto err;
1387     }
1388
1389     SSL_set_connect_state(c_ssl);
1390     SSL_set_bio(c_ssl, s_to_c, c_to_s);
1391     BIO_set_ssl(c_bio, c_ssl, BIO_NOCLOSE);
1392
1393     SSL_set_accept_state(s_ssl);
1394     SSL_set_bio(s_ssl, c_to_s, s_to_c);
1395     BIO_set_ssl(s_bio, s_ssl, BIO_NOCLOSE);
1396
1397     c_r = 0;
1398     s_r = 1;
1399     c_w = 1;
1400     s_w = 0;
1401     c_write = 1, s_write = 0;
1402
1403     /* We can always do writes */
1404     for (;;) {
1405         do_server = 0;
1406         do_client = 0;
1407
1408         i = (int)BIO_pending(s_bio);
1409         if ((i && s_r) || s_w)
1410             do_server = 1;
1411
1412         i = (int)BIO_pending(c_bio);
1413         if ((i && c_r) || c_w)
1414             do_client = 1;
1415
1416         if (do_server && debug) {
1417             if (SSL_in_init(s_ssl))
1418                 printf("server waiting in SSL_accept - %s\n",
1419                        SSL_state_string_long(s_ssl));
1420 /*-
1421             else if (s_write)
1422                 printf("server:SSL_write()\n");
1423             else
1424                 printf("server:SSL_read()\n"); */
1425         }
1426
1427         if (do_client && debug) {
1428             if (SSL_in_init(c_ssl))
1429                 printf("client waiting in SSL_connect - %s\n",
1430                        SSL_state_string_long(c_ssl));
1431 /*-
1432             else if (c_write)
1433                 printf("client:SSL_write()\n");
1434             else
1435                 printf("client:SSL_read()\n"); */
1436         }
1437
1438         if (!do_client && !do_server) {
1439             fprintf(stdout, "ERROR IN STARTUP\n");
1440             ERR_print_errors(bio_err);
1441             goto err;
1442         }
1443         if (do_client && !(done & C_DONE)) {
1444             if (c_write) {
1445                 j = (cw_num > (long)sizeof(cbuf)) ?
1446                     (int)sizeof(cbuf) : (int)cw_num;
1447                 i = BIO_write(c_bio, cbuf, j);
1448                 if (i < 0) {
1449                     c_r = 0;
1450                     c_w = 0;
1451                     if (BIO_should_retry(c_bio)) {
1452                         if (BIO_should_read(c_bio))
1453                             c_r = 1;
1454                         if (BIO_should_write(c_bio))
1455                             c_w = 1;
1456                     } else {
1457                         fprintf(stderr, "ERROR in CLIENT\n");
1458                         ERR_print_errors(bio_err);
1459                         goto err;
1460                     }
1461                 } else if (i == 0) {
1462                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1463                     goto err;
1464                 } else {
1465                     if (debug)
1466                         printf("client wrote %d\n", i);
1467                     /* ok */
1468                     s_r = 1;
1469                     c_write = 0;
1470                     cw_num -= i;
1471                 }
1472             } else {
1473                 i = BIO_read(c_bio, cbuf, sizeof(cbuf));
1474                 if (i < 0) {
1475                     c_r = 0;
1476                     c_w = 0;
1477                     if (BIO_should_retry(c_bio)) {
1478                         if (BIO_should_read(c_bio))
1479                             c_r = 1;
1480                         if (BIO_should_write(c_bio))
1481                             c_w = 1;
1482                     } else {
1483                         fprintf(stderr, "ERROR in CLIENT\n");
1484                         ERR_print_errors(bio_err);
1485                         goto err;
1486                     }
1487                 } else if (i == 0) {
1488                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1489                     goto err;
1490                 } else {
1491                     if (debug)
1492                         printf("client read %d\n", i);
1493                     cr_num -= i;
1494                     if (sw_num > 0) {
1495                         s_write = 1;
1496                         s_w = 1;
1497                     }
1498                     if (cr_num <= 0) {
1499                         s_write = 1;
1500                         s_w = 1;
1501                         done = S_DONE | C_DONE;
1502                     }
1503                 }
1504             }
1505         }
1506
1507         if (do_server && !(done & S_DONE)) {
1508             if (!s_write) {
1509                 i = BIO_read(s_bio, sbuf, sizeof(cbuf));
1510                 if (i < 0) {
1511                     s_r = 0;
1512                     s_w = 0;
1513                     if (BIO_should_retry(s_bio)) {
1514                         if (BIO_should_read(s_bio))
1515                             s_r = 1;
1516                         if (BIO_should_write(s_bio))
1517                             s_w = 1;
1518                     } else {
1519                         fprintf(stderr, "ERROR in SERVER\n");
1520                         ERR_print_errors(bio_err);
1521                         goto err;
1522                     }
1523                 } else if (i == 0) {
1524                     ERR_print_errors(bio_err);
1525                     fprintf(stderr,
1526                             "SSL SERVER STARTUP FAILED in SSL_read\n");
1527                     goto err;
1528                 } else {
1529                     if (debug)
1530                         printf("server read %d\n", i);
1531                     sr_num -= i;
1532                     if (cw_num > 0) {
1533                         c_write = 1;
1534                         c_w = 1;
1535                     }
1536                     if (sr_num <= 0) {
1537                         s_write = 1;
1538                         s_w = 1;
1539                         c_write = 0;
1540                     }
1541                 }
1542             } else {
1543                 j = (sw_num > (long)sizeof(sbuf)) ?
1544                     (int)sizeof(sbuf) : (int)sw_num;
1545                 i = BIO_write(s_bio, sbuf, j);
1546                 if (i < 0) {
1547                     s_r = 0;
1548                     s_w = 0;
1549                     if (BIO_should_retry(s_bio)) {
1550                         if (BIO_should_read(s_bio))
1551                             s_r = 1;
1552                         if (BIO_should_write(s_bio))
1553                             s_w = 1;
1554                     } else {
1555                         fprintf(stderr, "ERROR in SERVER\n");
1556                         ERR_print_errors(bio_err);
1557                         goto err;
1558                     }
1559                 } else if (i == 0) {
1560                     ERR_print_errors(bio_err);
1561                     fprintf(stderr,
1562                             "SSL SERVER STARTUP FAILED in SSL_write\n");
1563                     goto err;
1564                 } else {
1565                     if (debug)
1566                         printf("server wrote %d\n", i);
1567                     sw_num -= i;
1568                     s_write = 0;
1569                     c_r = 1;
1570                     if (sw_num <= 0)
1571                         done |= S_DONE;
1572                 }
1573             }
1574         }
1575
1576         if ((done & S_DONE) && (done & C_DONE))
1577             break;
1578     }
1579
1580     if (verbose)
1581         print_details(c_ssl, "DONE: ");
1582     ret = 0;
1583  err:
1584     /*
1585      * We have to set the BIO's to NULL otherwise they will be
1586      * OPENSSL_free()ed twice.  Once when th s_ssl is SSL_free()ed and again
1587      * when c_ssl is SSL_free()ed. This is a hack required because s_ssl and
1588      * c_ssl are sharing the same BIO structure and SSL_set_bio() and
1589      * SSL_free() automatically BIO_free non NULL entries. You should not
1590      * normally do this or be required to do this
1591      */
1592     if (s_ssl != NULL) {
1593         s_ssl->rbio = NULL;
1594         s_ssl->wbio = NULL;
1595     }
1596     if (c_ssl != NULL) {
1597         c_ssl->rbio = NULL;
1598         c_ssl->wbio = NULL;
1599     }
1600
1601     if (c_to_s != NULL)
1602         BIO_free(c_to_s);
1603     if (s_to_c != NULL)
1604         BIO_free(s_to_c);
1605     if (c_bio != NULL)
1606         BIO_free_all(c_bio);
1607     if (s_bio != NULL)
1608         BIO_free_all(s_bio);
1609     return (ret);
1610 }
1611
1612 static int get_proxy_auth_ex_data_idx(void)
1613 {
1614     static volatile int idx = -1;
1615     if (idx < 0) {
1616         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
1617         if (idx < 0) {
1618             idx = X509_STORE_CTX_get_ex_new_index(0,
1619                                                   "SSLtest for verify callback",
1620                                                   NULL, NULL, NULL);
1621         }
1622         CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
1623     }
1624     return idx;
1625 }
1626
1627 static int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx)
1628 {
1629     char *s, buf[256];
1630
1631     s = X509_NAME_oneline(X509_get_subject_name(ctx->current_cert), buf,
1632                           sizeof buf);
1633     if (s != NULL) {
1634         if (ok)
1635             fprintf(stderr, "depth=%d %s\n", ctx->error_depth, buf);
1636         else {
1637             fprintf(stderr, "depth=%d error=%d %s\n",
1638                     ctx->error_depth, ctx->error, buf);
1639         }
1640     }
1641
1642     if (ok == 0) {
1643         fprintf(stderr, "Error string: %s\n",
1644                 X509_verify_cert_error_string(ctx->error));
1645         switch (ctx->error) {
1646         case X509_V_ERR_CERT_NOT_YET_VALID:
1647         case X509_V_ERR_CERT_HAS_EXPIRED:
1648         case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
1649             fprintf(stderr, "  ... ignored.\n");
1650             ok = 1;
1651         }
1652     }
1653
1654     if (ok == 1) {
1655         X509 *xs = ctx->current_cert;
1656 #if 0
1657         X509 *xi = ctx->current_issuer;
1658 #endif
1659
1660         if (xs->ex_flags & EXFLAG_PROXY) {
1661             unsigned int *letters = X509_STORE_CTX_get_ex_data(ctx,
1662                                                                get_proxy_auth_ex_data_idx
1663                                                                ());
1664
1665             if (letters) {
1666                 int found_any = 0;
1667                 int i;
1668                 PROXY_CERT_INFO_EXTENSION *pci =
1669                     X509_get_ext_d2i(xs, NID_proxyCertInfo,
1670                                      NULL, NULL);
1671
1672                 switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage)) {
1673                 case NID_Independent:
1674                     /*
1675                      * Completely meaningless in this program, as there's no
1676                      * way to grant explicit rights to a specific PrC.
1677                      * Basically, using id-ppl-Independent is the perfect way
1678                      * to grant no rights at all.
1679                      */
1680                     fprintf(stderr, "  Independent proxy certificate");
1681                     for (i = 0; i < 26; i++)
1682                         letters[i] = 0;
1683                     break;
1684                 case NID_id_ppl_inheritAll:
1685                     /*
1686                      * This is basically a NOP, we simply let the current
1687                      * rights stand as they are.
1688                      */
1689                     fprintf(stderr, "  Proxy certificate inherits all");
1690                     break;
1691                 default:
1692                     s = (char *)
1693                         pci->proxyPolicy->policy->data;
1694                     i = pci->proxyPolicy->policy->length;
1695
1696                     /*
1697                      * The algorithm works as follows: it is assumed that
1698                      * previous iterations or the initial granted rights has
1699                      * already set some elements of `letters'.  What we need
1700                      * to do is to clear those that weren't granted by the
1701                      * current PrC as well.  The easiest way to do this is to
1702                      * add 1 to all the elements whose letters are given with
1703                      * the current policy. That way, all elements that are
1704                      * set by the current policy and were already set by
1705                      * earlier policies and through the original grant of
1706                      * rights will get the value 2 or higher. The last thing
1707                      * to do is to sweep through `letters' and keep the
1708                      * elements having the value 2 as set, and clear all the
1709                      * others.
1710                      */
1711
1712                     fprintf(stderr, "  Certificate proxy rights = %*.*s", i,
1713                             i, s);
1714                     while (i-- > 0) {
1715                         int c = *s++;
1716                         if (isascii(c) && isalpha(c)) {
1717                             if (islower(c))
1718                                 c = toupper(c);
1719                             letters[c - 'A']++;
1720                         }
1721                     }
1722                     for (i = 0; i < 26; i++)
1723                         if (letters[i] < 2)
1724                             letters[i] = 0;
1725                         else
1726                             letters[i] = 1;
1727                 }
1728
1729                 found_any = 0;
1730                 fprintf(stderr, ", resulting proxy rights = ");
1731                 for (i = 0; i < 26; i++)
1732                     if (letters[i]) {
1733                         fprintf(stderr, "%c", i + 'A');
1734                         found_any = 1;
1735                     }
1736                 if (!found_any)
1737                     fprintf(stderr, "none");
1738                 fprintf(stderr, "\n");
1739
1740                 PROXY_CERT_INFO_EXTENSION_free(pci);
1741             }
1742         }
1743     }
1744
1745     return (ok);
1746 }
1747
1748 static void process_proxy_debug(int indent, const char *format, ...)
1749 {
1750     /* That's 80 > */
1751     static const char indentation[] =
1752         ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
1753         ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
1754     char my_format[256];
1755     va_list args;
1756
1757     BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
1758                  indent, indent, indentation, format);
1759
1760     va_start(args, format);
1761     vfprintf(stderr, my_format, args);
1762     va_end(args);
1763 }
1764
1765 /*-
1766  * Priority levels:
1767  *  0   [!]var, ()
1768  *  1   & ^
1769  *  2   |
1770  */
1771 static int process_proxy_cond_adders(unsigned int letters[26],
1772                                      const char *cond, const char **cond_end,
1773                                      int *pos, int indent);
1774 static int process_proxy_cond_val(unsigned int letters[26], const char *cond,
1775                                   const char **cond_end, int *pos, int indent)
1776 {
1777     int c;
1778     int ok = 1;
1779     int negate = 0;
1780
1781     while (isspace((int)*cond)) {
1782         cond++;
1783         (*pos)++;
1784     }
1785     c = *cond;
1786
1787     if (debug)
1788         process_proxy_debug(indent,
1789                             "Start process_proxy_cond_val at position %d: %s\n",
1790                             *pos, cond);
1791
1792     while (c == '!') {
1793         negate = !negate;
1794         cond++;
1795         (*pos)++;
1796         while (isspace((int)*cond)) {
1797             cond++;
1798             (*pos)++;
1799         }
1800         c = *cond;
1801     }
1802
1803     if (c == '(') {
1804         cond++;
1805         (*pos)++;
1806         ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
1807                                        indent + 1);
1808         cond = *cond_end;
1809         if (ok < 0)
1810             goto end;
1811         while (isspace((int)*cond)) {
1812             cond++;
1813             (*pos)++;
1814         }
1815         c = *cond;
1816         if (c != ')') {
1817             fprintf(stderr,
1818                     "Weird condition character in position %d: "
1819                     "%c\n", *pos, c);
1820             ok = -1;
1821             goto end;
1822         }
1823         cond++;
1824         (*pos)++;
1825     } else if (isascii(c) && isalpha(c)) {
1826         if (islower(c))
1827             c = toupper(c);
1828         ok = letters[c - 'A'];
1829         cond++;
1830         (*pos)++;
1831     } else {
1832         fprintf(stderr,
1833                 "Weird condition character in position %d: " "%c\n", *pos, c);
1834         ok = -1;
1835         goto end;
1836     }
1837  end:
1838     *cond_end = cond;
1839     if (ok >= 0 && negate)
1840         ok = !ok;
1841
1842     if (debug)
1843         process_proxy_debug(indent,
1844                             "End process_proxy_cond_val at position %d: %s, returning %d\n",
1845                             *pos, cond, ok);
1846
1847     return ok;
1848 }
1849
1850 static int process_proxy_cond_multipliers(unsigned int letters[26],
1851                                           const char *cond,
1852                                           const char **cond_end, int *pos,
1853                                           int indent)
1854 {
1855     int ok;
1856     char c;
1857
1858     if (debug)
1859         process_proxy_debug(indent,
1860                             "Start process_proxy_cond_multipliers at position %d: %s\n",
1861                             *pos, cond);
1862
1863     ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
1864     cond = *cond_end;
1865     if (ok < 0)
1866         goto end;
1867
1868     while (ok >= 0) {
1869         while (isspace((int)*cond)) {
1870             cond++;
1871             (*pos)++;
1872         }
1873         c = *cond;
1874
1875         switch (c) {
1876         case '&':
1877         case '^':
1878             {
1879                 int save_ok = ok;
1880
1881                 cond++;
1882                 (*pos)++;
1883                 ok = process_proxy_cond_val(letters,
1884                                             cond, cond_end, pos, indent + 1);
1885                 cond = *cond_end;
1886                 if (ok < 0)
1887                     break;
1888
1889                 switch (c) {
1890                 case '&':
1891                     ok &= save_ok;
1892                     break;
1893                 case '^':
1894                     ok ^= save_ok;
1895                     break;
1896                 default:
1897                     fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
1898                             " STOPPING\n");
1899                     EXIT(1);
1900                 }
1901             }
1902             break;
1903         default:
1904             goto end;
1905         }
1906     }
1907  end:
1908     if (debug)
1909         process_proxy_debug(indent,
1910                             "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
1911                             *pos, cond, ok);
1912
1913     *cond_end = cond;
1914     return ok;
1915 }
1916
1917 static int process_proxy_cond_adders(unsigned int letters[26],
1918                                      const char *cond, const char **cond_end,
1919                                      int *pos, int indent)
1920 {
1921     int ok;
1922     char c;
1923
1924     if (debug)
1925         process_proxy_debug(indent,
1926                             "Start process_proxy_cond_adders at position %d: %s\n",
1927                             *pos, cond);
1928
1929     ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
1930                                         indent + 1);
1931     cond = *cond_end;
1932     if (ok < 0)
1933         goto end;
1934
1935     while (ok >= 0) {
1936         while (isspace((int)*cond)) {
1937             cond++;
1938             (*pos)++;
1939         }
1940         c = *cond;
1941
1942         switch (c) {
1943         case '|':
1944             {
1945                 int save_ok = ok;
1946
1947                 cond++;
1948                 (*pos)++;
1949                 ok = process_proxy_cond_multipliers(letters,
1950                                                     cond, cond_end, pos,
1951                                                     indent + 1);
1952                 cond = *cond_end;
1953                 if (ok < 0)
1954                     break;
1955
1956                 switch (c) {
1957                 case '|':
1958                     ok |= save_ok;
1959                     break;
1960                 default:
1961                     fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
1962                             " STOPPING\n");
1963                     EXIT(1);
1964                 }
1965             }
1966             break;
1967         default:
1968             goto end;
1969         }
1970     }
1971  end:
1972     if (debug)
1973         process_proxy_debug(indent,
1974                             "End process_proxy_cond_adders at position %d: %s, returning %d\n",
1975                             *pos, cond, ok);
1976
1977     *cond_end = cond;
1978     return ok;
1979 }
1980
1981 static int process_proxy_cond(unsigned int letters[26],
1982                               const char *cond, const char **cond_end)
1983 {
1984     int pos = 1;
1985     return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
1986 }
1987
1988 static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg)
1989 {
1990     int ok = 1;
1991     struct app_verify_arg *cb_arg = arg;
1992     unsigned int letters[26];   /* only used with proxy_auth */
1993
1994     if (cb_arg->app_verify) {
1995         char *s = NULL, buf[256];
1996
1997         fprintf(stderr, "In app_verify_callback, allowing cert. ");
1998         fprintf(stderr, "Arg is: %s\n", cb_arg->string);
1999         fprintf(stderr,
2000                 "Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2001                 (void *)ctx, (void *)ctx->cert);
2002         if (ctx->cert)
2003             s = X509_NAME_oneline(X509_get_subject_name(ctx->cert), buf, 256);
2004         if (s != NULL) {
2005             fprintf(stderr, "cert depth=%d %s\n", ctx->error_depth, buf);
2006         }
2007         return (1);
2008     }
2009     if (cb_arg->proxy_auth) {
2010         int found_any = 0, i;
2011         char *sp;
2012
2013         for (i = 0; i < 26; i++)
2014             letters[i] = 0;
2015         for (sp = cb_arg->proxy_auth; *sp; sp++) {
2016             int c = *sp;
2017             if (isascii(c) && isalpha(c)) {
2018                 if (islower(c))
2019                     c = toupper(c);
2020                 letters[c - 'A'] = 1;
2021             }
2022         }
2023
2024         fprintf(stderr, "  Initial proxy rights = ");
2025         for (i = 0; i < 26; i++)
2026             if (letters[i]) {
2027                 fprintf(stderr, "%c", i + 'A');
2028                 found_any = 1;
2029             }
2030         if (!found_any)
2031             fprintf(stderr, "none");
2032         fprintf(stderr, "\n");
2033
2034         X509_STORE_CTX_set_ex_data(ctx,
2035                                    get_proxy_auth_ex_data_idx(), letters);
2036     }
2037     if (cb_arg->allow_proxy_certs) {
2038         X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
2039     }
2040 #ifndef OPENSSL_NO_X509_VERIFY
2041 # ifdef OPENSSL_FIPS
2042     if (s->version == TLS1_VERSION)
2043         FIPS_allow_md5(1);
2044 # endif
2045     ok = X509_verify_cert(ctx);
2046 # ifdef OPENSSL_FIPS
2047     if (s->version == TLS1_VERSION)
2048         FIPS_allow_md5(0);
2049 # endif
2050 #endif
2051
2052     if (cb_arg->proxy_auth) {
2053         if (ok > 0) {
2054             const char *cond_end = NULL;
2055
2056             ok = process_proxy_cond(letters, cb_arg->proxy_cond, &cond_end);
2057
2058             if (ok < 0)
2059                 EXIT(3);
2060             if (*cond_end) {
2061                 fprintf(stderr,
2062                         "Stopped processing condition before it's end.\n");
2063                 ok = 0;
2064             }
2065             if (!ok)
2066                 fprintf(stderr,
2067                         "Proxy rights check with condition '%s' proved invalid\n",
2068                         cb_arg->proxy_cond);
2069             else
2070                 fprintf(stderr,
2071                         "Proxy rights check with condition '%s' proved valid\n",
2072                         cb_arg->proxy_cond);
2073         }
2074     }
2075     return (ok);
2076 }
2077
2078 #ifndef OPENSSL_NO_RSA
2079 static RSA *rsa_tmp = NULL;
2080
2081 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
2082 {
2083     BIGNUM *bn = NULL;
2084     if (rsa_tmp == NULL) {
2085         bn = BN_new();
2086         rsa_tmp = RSA_new();
2087         if (!bn || !rsa_tmp || !BN_set_word(bn, RSA_F4)) {
2088             BIO_printf(bio_err, "Memory error...");
2089             goto end;
2090         }
2091         BIO_printf(bio_err, "Generating temp (%d bit) RSA key...", keylength);
2092         (void)BIO_flush(bio_err);
2093         if (!RSA_generate_key_ex(rsa_tmp, keylength, bn, NULL)) {
2094             BIO_printf(bio_err, "Error generating key.");
2095             RSA_free(rsa_tmp);
2096             rsa_tmp = NULL;
2097         }
2098  end:
2099         BIO_printf(bio_err, "\n");
2100         (void)BIO_flush(bio_err);
2101     }
2102     if (bn)
2103         BN_free(bn);
2104     return (rsa_tmp);
2105 }
2106
2107 static void free_tmp_rsa(void)
2108 {
2109     if (rsa_tmp != NULL) {
2110         RSA_free(rsa_tmp);
2111         rsa_tmp = NULL;
2112     }
2113 }
2114 #endif
2115
2116 #ifndef OPENSSL_NO_DH
2117 /*-
2118  * These DH parameters have been generated as follows:
2119  *    $ openssl dhparam -C -noout 512
2120  *    $ openssl dhparam -C -noout 1024
2121  *    $ openssl dhparam -C -noout -dsaparam 1024
2122  * (The third function has been renamed to avoid name conflicts.)
2123  */
2124 static DH *get_dh512()
2125 {
2126     static unsigned char dh512_p[] = {
2127         0xCB, 0xC8, 0xE1, 0x86, 0xD0, 0x1F, 0x94, 0x17, 0xA6, 0x99, 0xF0,
2128         0xC6,
2129         0x1F, 0x0D, 0xAC, 0xB6, 0x25, 0x3E, 0x06, 0x39, 0xCA, 0x72, 0x04,
2130         0xB0,
2131         0x6E, 0xDA, 0xC0, 0x61, 0xE6, 0x7A, 0x77, 0x25, 0xE8, 0x3B, 0xB9,
2132         0x5F,
2133         0x9A, 0xB6, 0xB5, 0xFE, 0x99, 0x0B, 0xA1, 0x93, 0x4E, 0x35, 0x33,
2134         0xB8,
2135         0xE1, 0xF1, 0x13, 0x4F, 0x59, 0x1A, 0xD2, 0x57, 0xC0, 0x26, 0x21,
2136         0x33,
2137         0x02, 0xC5, 0xAE, 0x23,
2138     };
2139     static unsigned char dh512_g[] = {
2140         0x02,
2141     };
2142     DH *dh;
2143
2144     if ((dh = DH_new()) == NULL)
2145         return (NULL);
2146     dh->p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
2147     dh->g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
2148     if ((dh->p == NULL) || (dh->g == NULL)) {
2149         DH_free(dh);
2150         return (NULL);
2151     }
2152     return (dh);
2153 }
2154
2155 static DH *get_dh1024()
2156 {
2157     static unsigned char dh1024_p[] = {
2158         0xF8, 0x81, 0x89, 0x7D, 0x14, 0x24, 0xC5, 0xD1, 0xE6, 0xF7, 0xBF,
2159         0x3A,
2160         0xE4, 0x90, 0xF4, 0xFC, 0x73, 0xFB, 0x34, 0xB5, 0xFA, 0x4C, 0x56,
2161         0xA2,
2162         0xEA, 0xA7, 0xE9, 0xC0, 0xC0, 0xCE, 0x89, 0xE1, 0xFA, 0x63, 0x3F,
2163         0xB0,
2164         0x6B, 0x32, 0x66, 0xF1, 0xD1, 0x7B, 0xB0, 0x00, 0x8F, 0xCA, 0x87,
2165         0xC2,
2166         0xAE, 0x98, 0x89, 0x26, 0x17, 0xC2, 0x05, 0xD2, 0xEC, 0x08, 0xD0,
2167         0x8C,
2168         0xFF, 0x17, 0x52, 0x8C, 0xC5, 0x07, 0x93, 0x03, 0xB1, 0xF6, 0x2F,
2169         0xB8,
2170         0x1C, 0x52, 0x47, 0x27, 0x1B, 0xDB, 0xD1, 0x8D, 0x9D, 0x69, 0x1D,
2171         0x52,
2172         0x4B, 0x32, 0x81, 0xAA, 0x7F, 0x00, 0xC8, 0xDC, 0xE6, 0xD9, 0xCC,
2173         0xC1,
2174         0x11, 0x2D, 0x37, 0x34, 0x6C, 0xEA, 0x02, 0x97, 0x4B, 0x0E, 0xBB,
2175         0xB1,
2176         0x71, 0x33, 0x09, 0x15, 0xFD, 0xDD, 0x23, 0x87, 0x07, 0x5E, 0x89,
2177         0xAB,
2178         0x6B, 0x7C, 0x5F, 0xEC, 0xA6, 0x24, 0xDC, 0x53,
2179     };
2180     static unsigned char dh1024_g[] = {
2181         0x02,
2182     };
2183     DH *dh;
2184
2185     if ((dh = DH_new()) == NULL)
2186         return (NULL);
2187     dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
2188     dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
2189     if ((dh->p == NULL) || (dh->g == NULL)) {
2190         DH_free(dh);
2191         return (NULL);
2192     }
2193     return (dh);
2194 }
2195
2196 static DH *get_dh1024dsa()
2197 {
2198     static unsigned char dh1024_p[] = {
2199         0xC8, 0x00, 0xF7, 0x08, 0x07, 0x89, 0x4D, 0x90, 0x53, 0xF3, 0xD5,
2200         0x00,
2201         0x21, 0x1B, 0xF7, 0x31, 0xA6, 0xA2, 0xDA, 0x23, 0x9A, 0xC7, 0x87,
2202         0x19,
2203         0x3B, 0x47, 0xB6, 0x8C, 0x04, 0x6F, 0xFF, 0xC6, 0x9B, 0xB8, 0x65,
2204         0xD2,
2205         0xC2, 0x5F, 0x31, 0x83, 0x4A, 0xA7, 0x5F, 0x2F, 0x88, 0x38, 0xB6,
2206         0x55,
2207         0xCF, 0xD9, 0x87, 0x6D, 0x6F, 0x9F, 0xDA, 0xAC, 0xA6, 0x48, 0xAF,
2208         0xFC,
2209         0x33, 0x84, 0x37, 0x5B, 0x82, 0x4A, 0x31, 0x5D, 0xE7, 0xBD, 0x52,
2210         0x97,
2211         0xA1, 0x77, 0xBF, 0x10, 0x9E, 0x37, 0xEA, 0x64, 0xFA, 0xCA, 0x28,
2212         0x8D,
2213         0x9D, 0x3B, 0xD2, 0x6E, 0x09, 0x5C, 0x68, 0xC7, 0x45, 0x90, 0xFD,
2214         0xBB,
2215         0x70, 0xC9, 0x3A, 0xBB, 0xDF, 0xD4, 0x21, 0x0F, 0xC4, 0x6A, 0x3C,
2216         0xF6,
2217         0x61, 0xCF, 0x3F, 0xD6, 0x13, 0xF1, 0x5F, 0xBC, 0xCF, 0xBC, 0x26,
2218         0x9E,
2219         0xBC, 0x0B, 0xBD, 0xAB, 0x5D, 0xC9, 0x54, 0x39,
2220     };
2221     static unsigned char dh1024_g[] = {
2222         0x3B, 0x40, 0x86, 0xE7, 0xF3, 0x6C, 0xDE, 0x67, 0x1C, 0xCC, 0x80,
2223         0x05,
2224         0x5A, 0xDF, 0xFE, 0xBD, 0x20, 0x27, 0x74, 0x6C, 0x24, 0xC9, 0x03,
2225         0xF3,
2226         0xE1, 0x8D, 0xC3, 0x7D, 0x98, 0x27, 0x40, 0x08, 0xB8, 0x8C, 0x6A,
2227         0xE9,
2228         0xBB, 0x1A, 0x3A, 0xD6, 0x86, 0x83, 0x5E, 0x72, 0x41, 0xCE, 0x85,
2229         0x3C,
2230         0xD2, 0xB3, 0xFC, 0x13, 0xCE, 0x37, 0x81, 0x9E, 0x4C, 0x1C, 0x7B,
2231         0x65,
2232         0xD3, 0xE6, 0xA6, 0x00, 0xF5, 0x5A, 0x95, 0x43, 0x5E, 0x81, 0xCF,
2233         0x60,
2234         0xA2, 0x23, 0xFC, 0x36, 0xA7, 0x5D, 0x7A, 0x4C, 0x06, 0x91, 0x6E,
2235         0xF6,
2236         0x57, 0xEE, 0x36, 0xCB, 0x06, 0xEA, 0xF5, 0x3D, 0x95, 0x49, 0xCB,
2237         0xA7,
2238         0xDD, 0x81, 0xDF, 0x80, 0x09, 0x4A, 0x97, 0x4D, 0xA8, 0x22, 0x72,
2239         0xA1,
2240         0x7F, 0xC4, 0x70, 0x56, 0x70, 0xE8, 0x20, 0x10, 0x18, 0x8F, 0x2E,
2241         0x60,
2242         0x07, 0xE7, 0x68, 0x1A, 0x82, 0x5D, 0x32, 0xA2,
2243     };
2244     DH *dh;
2245
2246     if ((dh = DH_new()) == NULL)
2247         return (NULL);
2248     dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
2249     dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
2250     if ((dh->p == NULL) || (dh->g == NULL)) {
2251         DH_free(dh);
2252         return (NULL);
2253     }
2254     dh->length = 160;
2255     return (dh);
2256 }
2257 #endif
2258
2259 #ifndef OPENSSL_NO_PSK
2260 /* convert the PSK key (psk_key) in ascii to binary (psk) */
2261 static int psk_key2bn(const char *pskkey, unsigned char *psk,
2262                       unsigned int max_psk_len)
2263 {
2264     int ret;
2265     BIGNUM *bn = NULL;
2266
2267     ret = BN_hex2bn(&bn, pskkey);
2268     if (!ret) {
2269         BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
2270                    pskkey);
2271         if (bn)
2272             BN_free(bn);
2273         return 0;
2274     }
2275     if (BN_num_bytes(bn) > (int)max_psk_len) {
2276         BIO_printf(bio_err,
2277                    "psk buffer of callback is too small (%d) for key (%d)\n",
2278                    max_psk_len, BN_num_bytes(bn));
2279         BN_free(bn);
2280         return 0;
2281     }
2282     ret = BN_bn2bin(bn, psk);
2283     BN_free(bn);
2284     return ret;
2285 }
2286
2287 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
2288                                         char *identity,
2289                                         unsigned int max_identity_len,
2290                                         unsigned char *psk,
2291                                         unsigned int max_psk_len)
2292 {
2293     int ret;
2294     unsigned int psk_len = 0;
2295
2296     ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
2297     if (ret < 0)
2298         goto out_err;
2299     if (debug)
2300         fprintf(stderr, "client: created identity '%s' len=%d\n", identity,
2301                 ret);
2302     ret = psk_key2bn(psk_key, psk, max_psk_len);
2303     if (ret < 0)
2304         goto out_err;
2305     psk_len = ret;
2306  out_err:
2307     return psk_len;
2308 }
2309
2310 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
2311                                         unsigned char *psk,
2312                                         unsigned int max_psk_len)
2313 {
2314     unsigned int psk_len = 0;
2315
2316     if (strcmp(identity, "Client_identity") != 0) {
2317         BIO_printf(bio_err, "server: PSK error: client identity not found\n");
2318         return 0;
2319     }
2320     psk_len = psk_key2bn(psk_key, psk, max_psk_len);
2321     return psk_len;
2322 }
2323 #endif
2324
2325 static int do_test_cipherlist(void)
2326 {
2327     int i = 0;
2328     const SSL_METHOD *meth;
2329     const SSL_CIPHER *ci, *tci = NULL;
2330
2331 #ifndef OPENSSL_NO_SSL2
2332     fprintf(stderr, "testing SSLv2 cipher list order: ");
2333     meth = SSLv2_method();
2334     while ((ci = meth->get_cipher(i++)) != NULL) {
2335         if (tci != NULL)
2336             if (ci->id >= tci->id) {
2337                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
2338                 return 0;
2339             }
2340         tci = ci;
2341     }
2342     fprintf(stderr, "ok\n");
2343 #endif
2344 #ifndef OPENSSL_NO_SSL3
2345     fprintf(stderr, "testing SSLv3 cipher list order: ");
2346     meth = SSLv3_method();
2347     tci = NULL;
2348     while ((ci = meth->get_cipher(i++)) != NULL) {
2349         if (tci != NULL)
2350             if (ci->id >= tci->id) {
2351                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
2352                 return 0;
2353             }
2354         tci = ci;
2355     }
2356     fprintf(stderr, "ok\n");
2357 #endif
2358 #ifndef OPENSSL_NO_TLS1
2359     fprintf(stderr, "testing TLSv1 cipher list order: ");
2360     meth = TLSv1_method();
2361     tci = NULL;
2362     while ((ci = meth->get_cipher(i++)) != NULL) {
2363         if (tci != NULL)
2364             if (ci->id >= tci->id) {
2365                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
2366                 return 0;
2367             }
2368         tci = ci;
2369     }
2370     fprintf(stderr, "ok\n");
2371 #endif
2372
2373     return 1;
2374 }