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