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