ssl/ssltest.c

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