ssl/ssltest.c

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