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