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         if (tls1)
 981                 meth=TLSv1_method();
 982         else
 983         if (ssl3)
 984                 meth=SSLv3_method();
 985         else
 986                 meth=SSLv23_method();
 987 #else
 988         meth=SSLv2_method();
 989 #endif
 990 #endif
 991
 992         c_ctx=SSL_CTX_new(meth);
 993         s_ctx=SSL_CTX_new(meth);
 994         if ((c_ctx == NULL) || (s_ctx == NULL))
 995                 {
 996                 ERR_print_errors(bio_err);
 997                 goto end;
 998                 }
 999
1000         if (cipher != NULL)
1001                 {
1002                 SSL_CTX_set_cipher_list(c_ctx,cipher);
1003                 SSL_CTX_set_cipher_list(s_ctx,cipher);
1004                 }
1005
1006 #ifndef OPENSSL_NO_DH
1007         if (!no_dhe)
1008                 {
1009                 if (dhe1024dsa)
1010                         {
1011                         /* use SSL_OP_SINGLE_DH_USE to avoid small subgroup attacks */
1012                         SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_DH_USE);
1013                         dh=get_dh1024dsa();
1014                         }
1015                 else if (dhe1024)
1016                         dh=get_dh1024();
1017                 else
1018                         dh=get_dh512();
1019                 SSL_CTX_set_tmp_dh(s_ctx,dh);
1020                 DH_free(dh);
1021                 }
1022 #else
1023         (void)no_dhe;
1024 #endif
1025
1026 #ifndef OPENSSL_NO_ECDH
1027         if (!no_ecdhe)
1028                 {
1029                 int nid;
1030
1031                 if (named_curve != NULL)
1032                         {
1033                         nid = OBJ_sn2nid(named_curve);
1034                         if (nid == 0)
1035                         {
1036                                 BIO_printf(bio_err, "unknown curve name (%s)\n", named_curve);
1037                                 goto end;
1038                                 }
1039                         }
1040                 else
1041 #ifdef OPENSSL_NO_EC2M
1042                         nid = NID_X9_62_prime256v1;
1043 #else
1044                         nid = NID_sect163r2;
1045 #endif
1046
1047                 ecdh = EC_KEY_new_by_curve_name(nid);
1048                 if (ecdh == NULL)
1049                         {
1050                         BIO_printf(bio_err, "unable to create curve\n");
1051                         goto end;
1052                         }
1053
1054                 SSL_CTX_set_tmp_ecdh(s_ctx, ecdh);
1055                 SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_ECDH_USE);
1056                 EC_KEY_free(ecdh);
1057                 }
1058 #else
1059         (void)no_ecdhe;
1060 #endif
1061
1062 #ifndef OPENSSL_NO_RSA
1063         SSL_CTX_set_tmp_rsa_callback(s_ctx,tmp_rsa_cb);
1064 #endif
1065
1066 #ifdef TLSEXT_TYPE_opaque_prf_input
1067         SSL_CTX_set_tlsext_opaque_prf_input_callback(c_ctx, opaque_prf_input_cb);
1068         SSL_CTX_set_tlsext_opaque_prf_input_callback(s_ctx, opaque_prf_input_cb);
1069         SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(c_ctx, &co1); /* or &co2 or NULL */
1070         SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(s_ctx, &so1); /* or &so2 or NULL */
1071 #endif
1072
1073         if (!SSL_CTX_use_certificate_file(s_ctx,server_cert,SSL_FILETYPE_PEM))
1074                 {
1075                 ERR_print_errors(bio_err);
1076                 }
1077         else if (!SSL_CTX_use_PrivateKey_file(s_ctx,
1078                 (server_key?server_key:server_cert), SSL_FILETYPE_PEM))
1079                 {
1080                 ERR_print_errors(bio_err);
1081                 goto end;
1082                 }
1083
1084         if (client_auth)
1085                 {
1086                 SSL_CTX_use_certificate_file(c_ctx,client_cert,
1087                         SSL_FILETYPE_PEM);
1088                 SSL_CTX_use_PrivateKey_file(c_ctx,
1089                         (client_key?client_key:client_cert),
1090                         SSL_FILETYPE_PEM);
1091                 }
1092
1093         if (    (!SSL_CTX_load_verify_locations(s_ctx,CAfile,CApath)) ||
1094                 (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1095                 (!SSL_CTX_load_verify_locations(c_ctx,CAfile,CApath)) ||
1096                 (!SSL_CTX_set_default_verify_paths(c_ctx)))
1097                 {
1098                 /* fprintf(stderr,"SSL_load_verify_locations\n"); */
1099                 ERR_print_errors(bio_err);
1100                 /* goto end; */
1101                 }
1102
1103         if (client_auth)
1104                 {
1105                 BIO_printf(bio_err,"client authentication\n");
1106                 SSL_CTX_set_verify(s_ctx,
1107                         SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1108                         verify_callback);
1109                 SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback, &app_verify_arg);
1110                 }
1111         if (server_auth)
1112                 {
1113                 BIO_printf(bio_err,"server authentication\n");
1114                 SSL_CTX_set_verify(c_ctx,SSL_VERIFY_PEER,
1115                         verify_callback);
1116                 SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback, &app_verify_arg);
1117                 }
1118
1119         {
1120                 int session_id_context = 0;
1121                 SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context, sizeof session_id_context);
1122         }
1123
1124         /* Use PSK only if PSK key is given */
1125         if (psk_key != NULL)
1126                 {
1127                 /* no_psk is used to avoid putting psk command to openssl tool */
1128                 if (no_psk)
1129                         {
1130                         /* if PSK is not compiled in and psk key is
1131                          * given, do nothing and exit successfully */
1132                         ret=0;
1133                         goto end;
1134                         }
1135 #ifndef OPENSSL_NO_PSK
1136                 SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1137                 SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1138                 if (debug)
1139                         BIO_printf(bio_err,"setting PSK identity hint to s_ctx\n");
1140                 if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint"))
1141                         {
1142                         BIO_printf(bio_err,"error setting PSK identity hint to s_ctx\n");
1143                         ERR_print_errors(bio_err);
1144                         goto end;
1145                         }
1146 #endif
1147                 }
1148 #ifndef OPENSSL_NO_SRP
1149         if (srp_client_arg.srplogin)
1150                 {
1151                 if (!SSL_CTX_set_srp_username(c_ctx, srp_client_arg.srplogin))
1152                         {
1153                         BIO_printf(bio_err,"Unable to set SRP username\n");
1154                         goto end;
1155                         }
1156                 SSL_CTX_set_srp_cb_arg(c_ctx,&srp_client_arg);
1157                 SSL_CTX_set_srp_client_pwd_callback(c_ctx, ssl_give_srp_client_pwd_cb);
1158                 /*SSL_CTX_set_srp_strength(c_ctx, srp_client_arg.strength);*/
1159                 }
1160
1161         if (srp_server_arg.expected_user != NULL)
1162                 {
1163                 SSL_CTX_set_verify(s_ctx,SSL_VERIFY_NONE,verify_callback);
1164                 SSL_CTX_set_srp_cb_arg(s_ctx, &srp_server_arg);
1165                 SSL_CTX_set_srp_username_callback(s_ctx, ssl_srp_server_param_cb);
1166                 }
1167 #endif
1168
1169 #ifndef OPENSSL_NO_NPN
1170         if (npn_client)
1171                 {
1172                 SSL_CTX_set_next_proto_select_cb(c_ctx, cb_client_npn, NULL);
1173                 }
1174         if (npn_server)
1175                 {
1176                 if (npn_server_reject)
1177                         {
1178                         BIO_printf(bio_err, "Can't have both -npn_server and -npn_server_reject\n");
1179                         goto end;
1180                         }
1181                 SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_npn, NULL);
1182                 }
1183         if (npn_server_reject)
1184                 {
1185                 SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_rejects_npn, NULL);
1186                 }
1187 #endif
1188
1189         c_ssl=SSL_new(c_ctx);
1190         s_ssl=SSL_new(s_ctx);
1191
1192 #ifndef OPENSSL_NO_KRB5
1193         if (c_ssl  &&  c_ssl->kssl_ctx)
1194                 {
1195                 char    localhost[MAXHOSTNAMELEN+2];
1196
1197                 if (gethostname(localhost, sizeof localhost-1) == 0)
1198                         {
1199                         localhost[sizeof localhost-1]='\0';
1200                         if(strlen(localhost) == sizeof localhost-1)
1201                                 {
1202                                 BIO_printf(bio_err,"localhost name too long\n");
1203                                 goto end;
1204                                 }
1205                         kssl_ctx_setstring(c_ssl->kssl_ctx, KSSL_SERVER,
1206                                 localhost);
1207                         }
1208                 }
1209 #endif    /* OPENSSL_NO_KRB5  */
1210
1211         for (i=0; i<number; i++)
1212                 {
1213                 if (!reuse) SSL_set_session(c_ssl,NULL);
1214                 if (bio_pair)
1215                         ret=doit_biopair(s_ssl,c_ssl,bytes,&s_time,&c_time);
1216                 else
1217                         ret=doit(s_ssl,c_ssl,bytes);
1218                 }
1219
1220         if (!verbose)
1221                 {
1222                 print_details(c_ssl, "");
1223                 }
1224         if ((number > 1) || (bytes > 1L))
1225                 BIO_printf(bio_stdout, "%d handshakes of %ld bytes done\n",number,bytes);
1226         if (print_time)
1227                 {
1228 #ifdef CLOCKS_PER_SEC
1229                 /* "To determine the time in seconds, the value returned
1230                  * by the clock function should be divided by the value
1231                  * of the macro CLOCKS_PER_SEC."
1232                  *                                       -- ISO/IEC 9899 */
1233                 BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1234                         "Approximate total client time: %6.2f s\n",
1235                         (double)s_time/CLOCKS_PER_SEC,
1236                         (double)c_time/CLOCKS_PER_SEC);
1237 #else
1238                 /* "`CLOCKS_PER_SEC' undeclared (first use this function)"
1239                  *                            -- cc on NeXTstep/OpenStep */
1240                 BIO_printf(bio_stdout,
1241                         "Approximate total server time: %6.2f units\n"
1242                         "Approximate total client time: %6.2f units\n",
1243                         (double)s_time,
1244                         (double)c_time);
1245 #endif
1246                 }
1247
1248         SSL_free(s_ssl);
1249         SSL_free(c_ssl);
1250
1251 end:
1252         if (s_ctx != NULL) SSL_CTX_free(s_ctx);
1253         if (c_ctx != NULL) SSL_CTX_free(c_ctx);
1254
1255         if (bio_stdout != NULL) BIO_free(bio_stdout);
1256
1257 #ifndef OPENSSL_NO_RSA
1258         free_tmp_rsa();
1259 #endif
1260 #ifndef OPENSSL_NO_ENGINE
1261         ENGINE_cleanup();
1262 #endif
1263         CRYPTO_cleanup_all_ex_data();
1264         ERR_free_strings();
1265         ERR_remove_thread_state(NULL);
1266         EVP_cleanup();
1267         CRYPTO_mem_leaks(bio_err);
1268         if (bio_err != NULL) BIO_free(bio_err);
1269         EXIT(ret);
1270         return ret;
1271         }
1272
1273 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
1274         clock_t *s_time, clock_t *c_time)
1275         {
1276         long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1277         BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1278         BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
1279         int ret = 1;
1280
1281         size_t bufsiz = 256; /* small buffer for testing */
1282
1283         if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
1284                 goto err;
1285         if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
1286                 goto err;
1287
1288         s_ssl_bio = BIO_new(BIO_f_ssl());
1289         if (!s_ssl_bio)
1290                 goto err;
1291
1292         c_ssl_bio = BIO_new(BIO_f_ssl());
1293         if (!c_ssl_bio)
1294                 goto err;
1295
1296         SSL_set_connect_state(c_ssl);
1297         SSL_set_bio(c_ssl, client, client);
1298         (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1299
1300         SSL_set_accept_state(s_ssl);
1301         SSL_set_bio(s_ssl, server, server);
1302         (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1303
1304         do
1305                 {
1306                 /* c_ssl_bio:          SSL filter BIO
1307                  *
1308                  * client:             pseudo-I/O for SSL library
1309                  *
1310                  * client_io:          client's SSL communication; usually to be
1311                  *                     relayed over some I/O facility, but in this
1312                  *                     test program, we're the server, too:
1313                  *
1314                  * server_io:          server's SSL communication
1315                  *
1316                  * server:             pseudo-I/O for SSL library
1317                  *
1318                  * s_ssl_bio:          SSL filter BIO
1319                  *
1320                  * The client and the server each employ a "BIO pair":
1321                  * client + client_io, server + server_io.
1322                  * BIO pairs are symmetric.  A BIO pair behaves similar
1323                  * to a non-blocking socketpair (but both endpoints must
1324                  * be handled by the same thread).
1325                  * [Here we could connect client and server to the ends
1326                  * of a single BIO pair, but then this code would be less
1327                  * suitable as an example for BIO pairs in general.]
1328                  *
1329                  * Useful functions for querying the state of BIO pair endpoints:
1330                  *
1331                  * BIO_ctrl_pending(bio)              number of bytes we can read now
1332                  * BIO_ctrl_get_read_request(bio)     number of bytes needed to fulfil
1333                  *                                      other side's read attempt
1334                  * BIO_ctrl_get_write_guarantee(bio)   number of bytes we can write now
1335                  *
1336                  * ..._read_request is never more than ..._write_guarantee;
1337                  * it depends on the application which one you should use.
1338                  */
1339
1340                 /* We have non-blocking behaviour throughout this test program, but
1341                  * can be sure that there is *some* progress in each iteration; so
1342                  * we don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE
1343                  * -- we just try everything in each iteration
1344                  */
1345
1346                         {
1347                         /* CLIENT */
1348
1349                         MS_STATIC char cbuf[1024*8];
1350                         int i, r;
1351                         clock_t c_clock = clock();
1352
1353                         memset(cbuf, 0, sizeof(cbuf));
1354
1355                         if (debug)
1356                                 if (SSL_in_init(c_ssl))
1357                                         printf("client waiting in SSL_connect - %s\n",
1358                                                 SSL_state_string_long(c_ssl));
1359
1360                         if (cw_num > 0)
1361                                 {
1362                                 /* Write to server. */
1363
1364                                 if (cw_num > (long)sizeof cbuf)
1365                                         i = sizeof cbuf;
1366                                 else
1367                                         i = (int)cw_num;
1368                                 r = BIO_write(c_ssl_bio, cbuf, i);
1369                                 if (r < 0)
1370                                         {
1371                                         if (!BIO_should_retry(c_ssl_bio))
1372                                                 {
1373                                                 fprintf(stderr,"ERROR in CLIENT\n");
1374                                                 goto err;
1375                                                 }
1376                                         /* BIO_should_retry(...) can just be ignored here.
1377                                          * The library expects us to call BIO_write with
1378                                          * the same arguments again, and that's what we will
1379                                          * do in the next iteration. */
1380                                         }
1381                                 else if (r == 0)
1382                                         {
1383                                         fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1384                                         goto err;
1385                                         }
1386                                 else
1387                                         {
1388                                         if (debug)
1389                                                 printf("client wrote %d\n", r);
1390                                         cw_num -= r;
1391                                         }
1392                                 }
1393
1394                         if (cr_num > 0)
1395                                 {
1396                                 /* Read from server. */
1397
1398                                 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1399                                 if (r < 0)
1400                                         {
1401                                         if (!BIO_should_retry(c_ssl_bio))
1402                                                 {
1403                                                 fprintf(stderr,"ERROR in CLIENT\n");
1404                                                 goto err;
1405                                                 }
1406                                         /* Again, "BIO_should_retry" can be ignored. */
1407                                         }
1408                                 else if (r == 0)
1409                                         {
1410                                         fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1411                                         goto err;
1412                                         }
1413                                 else
1414                                         {
1415                                         if (debug)
1416                                                 printf("client read %d\n", r);
1417                                         cr_num -= r;
1418                                         }
1419                                 }
1420
1421                         /* c_time and s_time increments will typically be very small
1422                          * (depending on machine speed and clock tick intervals),
1423                          * but sampling over a large number of connections should
1424                          * result in fairly accurate figures.  We cannot guarantee
1425                          * a lot, however -- if each connection lasts for exactly
1426                          * one clock tick, it will be counted only for the client
1427                          * or only for the server or even not at all.
1428                          */
1429                         *c_time += (clock() - c_clock);
1430                         }
1431
1432                         {
1433                         /* SERVER */
1434
1435                         MS_STATIC char sbuf[1024*8];
1436                         int i, r;
1437                         clock_t s_clock = clock();
1438
1439                         memset(sbuf, 0, sizeof(sbuf));
1440
1441                         if (debug)
1442                                 if (SSL_in_init(s_ssl))
1443                                         printf("server waiting in SSL_accept - %s\n",
1444                                                 SSL_state_string_long(s_ssl));
1445
1446                         if (sw_num > 0)
1447                                 {
1448                                 /* Write to client. */
1449
1450                                 if (sw_num > (long)sizeof sbuf)
1451                                         i = sizeof sbuf;
1452                                 else
1453                                         i = (int)sw_num;
1454                                 r = BIO_write(s_ssl_bio, sbuf, i);
1455                                 if (r < 0)
1456                                         {
1457                                         if (!BIO_should_retry(s_ssl_bio))
1458                                                 {
1459                                                 fprintf(stderr,"ERROR in SERVER\n");
1460                                                 goto err;
1461                                                 }
1462                                         /* Ignore "BIO_should_retry". */
1463                                         }
1464                                 else if (r == 0)
1465                                         {
1466                                         fprintf(stderr,"SSL SERVER STARTUP FAILED\n");
1467                                         goto err;
1468                                         }
1469                                 else
1470                                         {
1471                                         if (debug)
1472                                                 printf("server wrote %d\n", r);
1473                                         sw_num -= r;
1474                                         }
1475                                 }
1476
1477                         if (sr_num > 0)
1478                                 {
1479                                 /* Read from client. */
1480
1481                                 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
1482                                 if (r < 0)
1483                                         {
1484                                         if (!BIO_should_retry(s_ssl_bio))
1485                                                 {
1486                                                 fprintf(stderr,"ERROR in SERVER\n");
1487                                                 goto err;
1488                                                 }
1489                                         /* blah, blah */
1490                                         }
1491                                 else if (r == 0)
1492                                         {
1493                                         fprintf(stderr,"SSL SERVER STARTUP FAILED\n");
1494                                         goto err;
1495                                         }
1496                                 else
1497                                         {
1498                                         if (debug)
1499                                                 printf("server read %d\n", r);
1500                                         sr_num -= r;
1501                                         }
1502                                 }
1503
1504                         *s_time += (clock() - s_clock);
1505                         }
1506
1507                         {
1508                         /* "I/O" BETWEEN CLIENT AND SERVER. */
1509
1510                         size_t r1, r2;
1511                         BIO *io1 = server_io, *io2 = client_io;
1512                         /* we use the non-copying interface for io1
1513                          * and the standard BIO_write/BIO_read interface for io2
1514                          */
1515
1516                         static int prev_progress = 1;
1517                         int progress = 0;
1518
1519                         /* io1 to io2 */
1520                         do
1521                                 {
1522                                 size_t num;
1523                                 int r;
1524
1525                                 r1 = BIO_ctrl_pending(io1);
1526                                 r2 = BIO_ctrl_get_write_guarantee(io2);
1527
1528                                 num = r1;
1529                                 if (r2 < num)
1530                                         num = r2;
1531                                 if (num)
1532                                         {
1533                                         char *dataptr;
1534
1535                                         if (INT_MAX < num) /* yeah, right */
1536                                                 num = INT_MAX;
1537
1538                                         r = BIO_nread(io1, &dataptr, (int)num);
1539                                         assert(r > 0);
1540                                         assert(r <= (int)num);
1541                                         /* possibly r < num (non-contiguous data) */
1542                                         num = r;
1543                                         r = BIO_write(io2, dataptr, (int)num);
1544                                         if (r != (int)num) /* can't happen */
1545                                                 {
1546                                                 fprintf(stderr, "ERROR: BIO_write could not write "
1547                                                         "BIO_ctrl_get_write_guarantee() bytes");
1548                                                 goto err;
1549                                                 }
1550                                         progress = 1;
1551
1552                                         if (debug)
1553                                                 printf((io1 == client_io) ?
1554                                                         "C->S relaying: %d bytes\n" :
1555                                                         "S->C relaying: %d bytes\n",
1556                                                         (int)num);
1557                                         }
1558                                 }
1559                         while (r1 && r2);
1560
1561                         /* io2 to io1 */
1562                         {
1563                                 size_t num;
1564                                 int r;
1565
1566                                 r1 = BIO_ctrl_pending(io2);
1567                                 r2 = BIO_ctrl_get_read_request(io1);
1568                                 /* here we could use ..._get_write_guarantee instead of
1569                                  * ..._get_read_request, but by using the latter
1570                                  * we test restartability of the SSL implementation
1571                                  * more thoroughly */
1572                                 num = r1;
1573                                 if (r2 < num)
1574                                         num = r2;
1575                                 if (num)
1576                                         {
1577                                         char *dataptr;
1578
1579                                         if (INT_MAX < num)
1580                                                 num = INT_MAX;
1581
1582                                         if (num > 1)
1583                                                 --num; /* test restartability even more thoroughly */
1584
1585                                         r = BIO_nwrite0(io1, &dataptr);
1586                                         assert(r > 0);
1587                                         if (r < (int)num)
1588                                                 num = r;
1589                                         r = BIO_read(io2, dataptr, (int)num);
1590                                         if (r != (int)num) /* can't happen */
1591                                                 {
1592                                                 fprintf(stderr, "ERROR: BIO_read could not read "
1593                                                         "BIO_ctrl_pending() bytes");
1594                                                 goto err;
1595                                                 }
1596                                         progress = 1;
1597                                         r = BIO_nwrite(io1, &dataptr, (int)num);
1598                                         if (r != (int)num) /* can't happen */
1599                                                 {
1600                                                 fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
1601                                                         "BIO_nwrite0() bytes");
1602                                                 goto err;
1603                                                 }
1604
1605                                         if (debug)
1606                                                 printf((io2 == client_io) ?
1607                                                         "C->S relaying: %d bytes\n" :
1608                                                         "S->C relaying: %d bytes\n",
1609                                                         (int)num);
1610                                         }
1611                         } /* no loop, BIO_ctrl_get_read_request now returns 0 anyway */
1612
1613                         if (!progress && !prev_progress)
1614                                 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0)
1615                                         {
1616                                         fprintf(stderr, "ERROR: got stuck\n");
1617                                         if (strcmp("SSLv2", SSL_get_version(c_ssl)) == 0)
1618                                                 {
1619                                                 fprintf(stderr, "This can happen for SSL2 because "
1620                                                         "CLIENT-FINISHED and SERVER-VERIFY are written \n"
1621                                                         "concurrently ...");
1622                                                 if (strncmp("2SCF", SSL_state_string(c_ssl), 4) == 0
1623                                                         && strncmp("2SSV", SSL_state_string(s_ssl), 4) == 0)
1624                                                         {
1625                                                         fprintf(stderr, " ok.\n");
1626                                                         goto end;
1627                                                         }
1628                                                 }
1629                                         fprintf(stderr, " ERROR.\n");
1630                                         goto err;
1631                                         }
1632                         prev_progress = progress;
1633                         }
1634                 }
1635         while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
1636
1637         if (verbose)
1638                 print_details(c_ssl, "DONE via BIO pair: ");
1639 #ifndef OPENSSL_NO_NPN
1640         if (verify_npn(c_ssl, s_ssl) < 0)
1641                 {
1642                 ret = 1;
1643                 goto end;
1644                 }
1645 #endif
1646 end:
1647         ret = 0;
1648
1649  err:
1650         ERR_print_errors(bio_err);
1651
1652         if (server)
1653                 BIO_free(server);
1654         if (server_io)
1655                 BIO_free(server_io);
1656         if (client)
1657                 BIO_free(client);
1658         if (client_io)
1659                 BIO_free(client_io);
1660         if (s_ssl_bio)
1661                 BIO_free(s_ssl_bio);
1662         if (c_ssl_bio)
1663                 BIO_free(c_ssl_bio);
1664
1665         return ret;
1666         }
1667
1668
1669 #define W_READ  1
1670 #define W_WRITE 2
1671 #define C_DONE  1
1672 #define S_DONE  2
1673
1674 int doit(SSL *s_ssl, SSL *c_ssl, long count)
1675         {
1676         MS_STATIC char cbuf[1024*8],sbuf[1024*8];
1677         long cw_num=count,cr_num=count;
1678         long sw_num=count,sr_num=count;
1679         int ret=1;
1680         BIO *c_to_s=NULL;
1681         BIO *s_to_c=NULL;
1682         BIO *c_bio=NULL;
1683         BIO *s_bio=NULL;
1684         int c_r,c_w,s_r,s_w;
1685         int i,j;
1686         int done=0;
1687         int c_write,s_write;
1688         int do_server=0,do_client=0;
1689
1690         memset(cbuf,0,sizeof(cbuf));
1691         memset(sbuf,0,sizeof(sbuf));
1692
1693         c_to_s=BIO_new(BIO_s_mem());
1694         s_to_c=BIO_new(BIO_s_mem());
1695         if ((s_to_c == NULL) || (c_to_s == NULL))
1696                 {
1697                 ERR_print_errors(bio_err);
1698                 goto err;
1699                 }
1700
1701         c_bio=BIO_new(BIO_f_ssl());
1702         s_bio=BIO_new(BIO_f_ssl());
1703         if ((c_bio == NULL) || (s_bio == NULL))
1704                 {
1705                 ERR_print_errors(bio_err);
1706                 goto err;
1707                 }
1708
1709         SSL_set_connect_state(c_ssl);
1710         SSL_set_bio(c_ssl,s_to_c,c_to_s);
1711         BIO_set_ssl(c_bio,c_ssl,BIO_NOCLOSE);
1712
1713         SSL_set_accept_state(s_ssl);
1714         SSL_set_bio(s_ssl,c_to_s,s_to_c);
1715         BIO_set_ssl(s_bio,s_ssl,BIO_NOCLOSE);
1716
1717         c_r=0; s_r=1;
1718         c_w=1; s_w=0;
1719         c_write=1,s_write=0;
1720
1721         /* We can always do writes */
1722         for (;;)
1723                 {
1724                 do_server=0;
1725                 do_client=0;
1726
1727                 i=(int)BIO_pending(s_bio);
1728                 if ((i && s_r) || s_w) do_server=1;
1729
1730                 i=(int)BIO_pending(c_bio);
1731                 if ((i && c_r) || c_w) do_client=1;
1732
1733                 if (do_server && debug)
1734                         {
1735                         if (SSL_in_init(s_ssl))
1736                                 printf("server waiting in SSL_accept - %s\n",
1737                                         SSL_state_string_long(s_ssl));
1738 /*                      else if (s_write)
1739                                 printf("server:SSL_write()\n");
1740                         else
1741                                 printf("server:SSL_read()\n"); */
1742                         }
1743
1744                 if (do_client && debug)
1745                         {
1746                         if (SSL_in_init(c_ssl))
1747                                 printf("client waiting in SSL_connect - %s\n",
1748                                         SSL_state_string_long(c_ssl));
1749 /*                      else if (c_write)
1750                                 printf("client:SSL_write()\n");
1751                         else
1752                                 printf("client:SSL_read()\n"); */
1753                         }
1754
1755                 if (!do_client && !do_server)
1756                         {
1757                         fprintf(stdout,"ERROR IN STARTUP\n");
1758                         ERR_print_errors(bio_err);
1759                         break;
1760                         }
1761                 if (do_client && !(done & C_DONE))
1762                         {
1763                         if (c_write)
1764                                 {
1765                                 j = (cw_num > (long)sizeof(cbuf)) ?
1766                                         (int)sizeof(cbuf) : (int)cw_num;
1767                                 i=BIO_write(c_bio,cbuf,j);
1768                                 if (i < 0)
1769                                         {
1770                                         c_r=0;
1771                                         c_w=0;
1772                                         if (BIO_should_retry(c_bio))
1773                                                 {
1774                                                 if (BIO_should_read(c_bio))
1775                                                         c_r=1;
1776                                                 if (BIO_should_write(c_bio))
1777                                                         c_w=1;
1778                                                 }
1779                                         else
1780                                                 {
1781                                                 fprintf(stderr,"ERROR in CLIENT\n");
1782                                                 ERR_print_errors(bio_err);
1783                                                 goto err;
1784                                                 }
1785                                         }
1786                                 else if (i == 0)
1787                                         {
1788                                         fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1789                                         goto err;
1790                                         }
1791                                 else
1792                                         {
1793                                         if (debug)
1794                                                 printf("client wrote %d\n",i);
1795                                         /* ok */
1796                                         s_r=1;
1797                                         c_write=0;
1798                                         cw_num-=i;
1799                                         }
1800                                 }
1801                         else
1802                                 {
1803                                 i=BIO_read(c_bio,cbuf,sizeof(cbuf));
1804                                 if (i < 0)
1805                                         {
1806                                         c_r=0;
1807                                         c_w=0;
1808                                         if (BIO_should_retry(c_bio))
1809                                                 {
1810                                                 if (BIO_should_read(c_bio))
1811                                                         c_r=1;
1812                                                 if (BIO_should_write(c_bio))
1813                                                         c_w=1;
1814                                                 }
1815                                         else
1816                                                 {
1817                                                 fprintf(stderr,"ERROR in CLIENT\n");
1818                                                 ERR_print_errors(bio_err);
1819                                                 goto err;
1820                                                 }
1821                                         }
1822                                 else if (i == 0)
1823                                         {
1824                                         fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1825                                         goto err;
1826                                         }
1827                                 else
1828                                         {
1829                                         if (debug)
1830                                                 printf("client read %d\n",i);
1831                                         cr_num-=i;
1832                                         if (sw_num > 0)
1833                                                 {
1834                                                 s_write=1;
1835                                                 s_w=1;
1836                                                 }
1837                                         if (cr_num <= 0)
1838                                                 {
1839                                                 s_write=1;
1840                                                 s_w=1;
1841                                                 done=S_DONE|C_DONE;
1842                                                 }
1843                                         }
1844                                 }
1845                         }
1846
1847                 if (do_server && !(done & S_DONE))
1848                         {
1849                         if (!s_write)
1850                                 {
1851                                 i=BIO_read(s_bio,sbuf,sizeof(cbuf));
1852                                 if (i < 0)
1853                                         {
1854                                         s_r=0;
1855                                         s_w=0;
1856                                         if (BIO_should_retry(s_bio))
1857                                                 {
1858                                                 if (BIO_should_read(s_bio))
1859                                                         s_r=1;
1860                                                 if (BIO_should_write(s_bio))
1861                                                         s_w=1;
1862                                                 }
1863                                         else
1864                                                 {
1865                                                 fprintf(stderr,"ERROR in SERVER\n");
1866                                                 ERR_print_errors(bio_err);
1867                                                 goto err;
1868                                                 }
1869                                         }
1870                                 else if (i == 0)
1871                                         {
1872                                         ERR_print_errors(bio_err);
1873                                         fprintf(stderr,"SSL SERVER STARTUP FAILED in SSL_read\n");
1874                                         goto err;
1875                                         }
1876                                 else
1877                                         {
1878                                         if (debug)
1879                                                 printf("server read %d\n",i);
1880                                         sr_num-=i;
1881                                         if (cw_num > 0)
1882                                                 {
1883                                                 c_write=1;
1884                                                 c_w=1;
1885                                                 }
1886                                         if (sr_num <= 0)
1887                                                 {
1888                                                 s_write=1;
1889                                                 s_w=1;
1890                                                 c_write=0;
1891                                                 }
1892                                         }
1893                                 }
1894                         else
1895                                 {
1896                                 j = (sw_num > (long)sizeof(sbuf)) ?
1897                                         (int)sizeof(sbuf) : (int)sw_num;
1898                                 i=BIO_write(s_bio,sbuf,j);
1899                                 if (i < 0)
1900                                         {
1901                                         s_r=0;
1902                                         s_w=0;
1903                                         if (BIO_should_retry(s_bio))
1904                                                 {
1905                                                 if (BIO_should_read(s_bio))
1906                                                         s_r=1;
1907                                                 if (BIO_should_write(s_bio))
1908                                                         s_w=1;
1909                                                 }
1910                                         else
1911                                                 {
1912                                                 fprintf(stderr,"ERROR in SERVER\n");
1913                                                 ERR_print_errors(bio_err);
1914                                                 goto err;
1915                                                 }
1916                                         }
1917                                 else if (i == 0)
1918                                         {
1919                                         ERR_print_errors(bio_err);
1920                                         fprintf(stderr,"SSL SERVER STARTUP FAILED in SSL_write\n");
1921                                         goto err;
1922                                         }
1923                                 else
1924                                         {
1925                                         if (debug)
1926                                                 printf("server wrote %d\n",i);
1927                                         sw_num-=i;
1928                                         s_write=0;
1929                                         c_r=1;
1930                                         if (sw_num <= 0)
1931                                                 done|=S_DONE;
1932                                         }
1933                                 }
1934                         }
1935
1936                 if ((done & S_DONE) && (done & C_DONE)) break;
1937                 }
1938
1939         if (verbose)
1940                 print_details(c_ssl, "DONE: ");
1941 #ifndef OPENSSL_NO_NPN
1942         if (verify_npn(c_ssl, s_ssl) < 0)
1943                 {
1944                 ret = 1;
1945                 goto err;
1946                 }
1947 #endif
1948         ret=0;
1949 err:
1950         /* We have to set the BIO's to NULL otherwise they will be
1951          * OPENSSL_free()ed twice.  Once when th s_ssl is SSL_free()ed and
1952          * again when c_ssl is SSL_free()ed.
1953          * This is a hack required because s_ssl and c_ssl are sharing the same
1954          * BIO structure and SSL_set_bio() and SSL_free() automatically
1955          * BIO_free non NULL entries.
1956          * You should not normally do this or be required to do this */
1957         if (s_ssl != NULL)
1958                 {
1959                 s_ssl->rbio=NULL;
1960                 s_ssl->wbio=NULL;
1961                 }
1962         if (c_ssl != NULL)
1963                 {
1964                 c_ssl->rbio=NULL;
1965                 c_ssl->wbio=NULL;
1966                 }
1967
1968         if (c_to_s != NULL) BIO_free(c_to_s);
1969         if (s_to_c != NULL) BIO_free(s_to_c);
1970         if (c_bio != NULL) BIO_free_all(c_bio);
1971         if (s_bio != NULL) BIO_free_all(s_bio);
1972         return(ret);
1973         }
1974
1975 static int get_proxy_auth_ex_data_idx(void)
1976         {
1977         static volatile int idx = -1;
1978         if (idx < 0)
1979                 {
1980                 CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
1981                 if (idx < 0)
1982                         {
1983                         idx = X509_STORE_CTX_get_ex_new_index(0,
1984                                 "SSLtest for verify callback", NULL,NULL,NULL);
1985                         }
1986                 CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
1987                 }
1988         return idx;
1989         }
1990
1991 static int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx)
1992         {
1993         char *s,buf[256];
1994
1995         s=X509_NAME_oneline(X509_get_subject_name(ctx->current_cert),buf,
1996                             sizeof buf);
1997         if (s != NULL)
1998                 {
1999                 if (ok)
2000                         fprintf(stderr,"depth=%d %s\n",
2001                                 ctx->error_depth,buf);
2002                 else
2003                         {
2004                         fprintf(stderr,"depth=%d error=%d %s\n",
2005                                 ctx->error_depth,ctx->error,buf);
2006                         }
2007                 }
2008
2009         if (ok == 0)
2010                 {
2011                 fprintf(stderr,"Error string: %s\n",
2012                         X509_verify_cert_error_string(ctx->error));
2013                 switch (ctx->error)
2014                         {
2015                 case X509_V_ERR_CERT_NOT_YET_VALID:
2016                 case X509_V_ERR_CERT_HAS_EXPIRED:
2017                 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2018                         fprintf(stderr,"  ... ignored.\n");
2019                         ok=1;
2020                         }
2021                 }
2022
2023         if (ok == 1)
2024                 {
2025                 X509 *xs = ctx->current_cert;
2026 #if 0
2027                 X509 *xi = ctx->current_issuer;
2028 #endif
2029
2030                 if (xs->ex_flags & EXFLAG_PROXY)
2031                         {
2032                         unsigned int *letters =
2033                                 X509_STORE_CTX_get_ex_data(ctx,
2034                                         get_proxy_auth_ex_data_idx());
2035
2036                         if (letters)
2037                                 {
2038                                 int found_any = 0;
2039                                 int i;
2040                                 PROXY_CERT_INFO_EXTENSION *pci =
2041                                         X509_get_ext_d2i(xs, NID_proxyCertInfo,
2042                                                 NULL, NULL);
2043
2044                                 switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage))
2045                                         {
2046                                 case NID_Independent:
2047                                         /* Completely meaningless in this
2048                                            program, as there's no way to
2049                                            grant explicit rights to a
2050                                            specific PrC.  Basically, using
2051                                            id-ppl-Independent is the perfect
2052                                            way to grant no rights at all. */
2053                                         fprintf(stderr, "  Independent proxy certificate");
2054                                         for (i = 0; i < 26; i++)
2055                                                 letters[i] = 0;
2056                                         break;
2057                                 case NID_id_ppl_inheritAll:
2058                                         /* This is basically a NOP, we
2059                                            simply let the current rights
2060                                            stand as they are. */
2061                                         fprintf(stderr, "  Proxy certificate inherits all");
2062                                         break;
2063                                 default:
2064                                         s = (char *)
2065                                                 pci->proxyPolicy->policy->data;
2066                                         i = pci->proxyPolicy->policy->length;
2067
2068                                         /* The algorithm works as follows:
2069                                            it is assumed that previous
2070                                            iterations or the initial granted
2071                                            rights has already set some elements
2072                                            of `letters'.  What we need to do is
2073                                            to clear those that weren't granted
2074                                            by the current PrC as well.  The
2075                                            easiest way to do this is to add 1
2076                                            to all the elements whose letters
2077                                            are given with the current policy.
2078                                            That way, all elements that are set
2079                                            by the current policy and were
2080                                            already set by earlier policies and
2081                                            through the original grant of rights
2082                                            will get the value 2 or higher.
2083                                            The last thing to do is to sweep
2084                                            through `letters' and keep the
2085                                            elements having the value 2 as set,
2086                                            and clear all the others. */
2087
2088                                         fprintf(stderr, "  Certificate proxy rights = %*.*s", i, i, s);
2089                                         while(i-- > 0)
2090                                                 {
2091                                                 int c = *s++;
2092                                                 if (isascii(c) && isalpha(c))
2093                                                         {
2094                                                         if (islower(c))
2095                                                                 c = toupper(c);
2096                                                         letters[c - 'A']++;
2097                                                         }
2098                                                 }
2099                                         for (i = 0; i < 26; i++)
2100                                                 if (letters[i] < 2)
2101                                                         letters[i] = 0;
2102                                                 else
2103                                                         letters[i] = 1;
2104                                         }
2105
2106                                 found_any = 0;
2107                                 fprintf(stderr,
2108                                         ", resulting proxy rights = ");
2109                                 for(i = 0; i < 26; i++)
2110                                         if (letters[i])
2111                                                 {
2112                                                 fprintf(stderr, "%c", i + 'A');
2113                                                 found_any = 1;
2114                                                 }
2115                                 if (!found_any)
2116                                         fprintf(stderr, "none");
2117                                 fprintf(stderr, "\n");
2118
2119                                 PROXY_CERT_INFO_EXTENSION_free(pci);
2120                                 }
2121                         }
2122                 }
2123
2124         return(ok);
2125         }
2126
2127 static void process_proxy_debug(int indent, const char *format, ...)
2128         {
2129         static const char indentation[] =
2130                 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
2131                 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"; /* That's 80 > */
2132         char my_format[256];
2133         va_list args;
2134
2135         BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
2136                 indent, indent, indentation, format);
2137
2138         va_start(args, format);
2139         vfprintf(stderr, my_format, args);
2140         va_end(args);
2141         }
2142 /* Priority levels:
2143    0    [!]var, ()
2144    1    & ^
2145    2    |
2146 */
2147 static int process_proxy_cond_adders(unsigned int letters[26],
2148         const char *cond, const char **cond_end, int *pos, int indent);
2149 static int process_proxy_cond_val(unsigned int letters[26],
2150         const char *cond, const char **cond_end, int *pos, int indent)
2151         {
2152         int c;
2153         int ok = 1;
2154         int negate = 0;
2155
2156         while(isspace((int)*cond))
2157                 {
2158                 cond++; (*pos)++;
2159                 }
2160         c = *cond;
2161
2162         if (debug)
2163                 process_proxy_debug(indent,
2164                         "Start process_proxy_cond_val at position %d: %s\n",
2165                         *pos, cond);
2166
2167         while(c == '!')
2168                 {
2169                 negate = !negate;
2170                 cond++; (*pos)++;
2171                 while(isspace((int)*cond))
2172                         {
2173                         cond++; (*pos)++;
2174                         }
2175                 c = *cond;
2176                 }
2177
2178         if (c == '(')
2179                 {
2180                 cond++; (*pos)++;
2181                 ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
2182                         indent + 1);
2183                 cond = *cond_end;
2184                 if (ok < 0)
2185                         goto end;
2186                 while(isspace((int)*cond))
2187                         {
2188                         cond++; (*pos)++;
2189                         }
2190                 c = *cond;
2191                 if (c != ')')
2192                         {
2193                         fprintf(stderr,
2194                                 "Weird condition character in position %d: "
2195                                 "%c\n", *pos, c);
2196                         ok = -1;
2197                         goto end;
2198                         }
2199                 cond++; (*pos)++;
2200                 }
2201         else if (isascii(c) && isalpha(c))
2202                 {
2203                 if (islower(c))
2204                         c = toupper(c);
2205                 ok = letters[c - 'A'];
2206                 cond++; (*pos)++;
2207                 }
2208         else
2209                 {
2210                 fprintf(stderr,
2211                         "Weird condition character in position %d: "
2212                         "%c\n", *pos, c);
2213                 ok = -1;
2214                 goto end;
2215                 }
2216  end:
2217         *cond_end = cond;
2218         if (ok >= 0 && negate)
2219                 ok = !ok;
2220
2221         if (debug)
2222                 process_proxy_debug(indent,
2223                         "End process_proxy_cond_val at position %d: %s, returning %d\n",
2224                         *pos, cond, ok);
2225
2226         return ok;
2227         }
2228 static int process_proxy_cond_multipliers(unsigned int letters[26],
2229         const char *cond, const char **cond_end, int *pos, int indent)
2230         {
2231         int ok;
2232         char c;
2233
2234         if (debug)
2235                 process_proxy_debug(indent,
2236                         "Start process_proxy_cond_multipliers at position %d: %s\n",
2237                         *pos, cond);
2238
2239         ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
2240         cond = *cond_end;
2241         if (ok < 0)
2242                 goto end;
2243
2244         while(ok >= 0)
2245                 {
2246                 while(isspace((int)*cond))
2247                         {
2248                         cond++; (*pos)++;
2249                         }
2250                 c = *cond;
2251
2252                 switch(c)
2253                         {
2254                 case '&':
2255                 case '^':
2256                         {
2257                         int save_ok = ok;
2258
2259                         cond++; (*pos)++;
2260                         ok = process_proxy_cond_val(letters,
2261                                 cond, cond_end, pos, indent + 1);
2262                         cond = *cond_end;
2263                         if (ok < 0)
2264                                 break;
2265
2266                         switch(c)
2267                                 {
2268                         case '&':
2269                                 ok &= save_ok;
2270                                 break;
2271                         case '^':
2272                                 ok ^= save_ok;
2273                                 break;
2274                         default:
2275                                 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2276                                         " STOPPING\n");
2277                                 EXIT(1);
2278                                 }
2279                         }
2280                         break;
2281                 default:
2282                         goto end;
2283                         }
2284                 }
2285  end:
2286         if (debug)
2287                 process_proxy_debug(indent,
2288                         "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
2289                         *pos, cond, ok);
2290
2291         *cond_end = cond;
2292         return ok;
2293         }
2294 static int process_proxy_cond_adders(unsigned int letters[26],
2295         const char *cond, const char **cond_end, int *pos, int indent)
2296         {
2297         int ok;
2298         char c;
2299
2300         if (debug)
2301                 process_proxy_debug(indent,
2302                         "Start process_proxy_cond_adders at position %d: %s\n",
2303                         *pos, cond);
2304
2305         ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
2306                 indent + 1);
2307         cond = *cond_end;
2308         if (ok < 0)
2309                 goto end;
2310
2311         while(ok >= 0)
2312                 {
2313                 while(isspace((int)*cond))
2314                         {
2315                         cond++; (*pos)++;
2316                         }
2317                 c = *cond;
2318
2319                 switch(c)
2320                         {
2321                 case '|':
2322                         {
2323                         int save_ok = ok;
2324
2325                         cond++; (*pos)++;
2326                         ok = process_proxy_cond_multipliers(letters,
2327                                 cond, cond_end, pos, indent + 1);
2328                         cond = *cond_end;
2329                         if (ok < 0)
2330                                 break;
2331
2332                         switch(c)
2333                                 {
2334                         case '|':
2335                                 ok |= save_ok;
2336                                 break;
2337                         default:
2338                                 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2339                                         " STOPPING\n");
2340                                 EXIT(1);
2341                                 }
2342                         }
2343                         break;
2344                 default:
2345                         goto end;
2346                         }
2347                 }
2348  end:
2349         if (debug)
2350                 process_proxy_debug(indent,
2351                         "End process_proxy_cond_adders at position %d: %s, returning %d\n",
2352                         *pos, cond, ok);
2353
2354         *cond_end = cond;
2355         return ok;
2356         }
2357
2358 static int process_proxy_cond(unsigned int letters[26],
2359         const char *cond, const char **cond_end)
2360         {
2361         int pos = 1;
2362         return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
2363         }
2364
2365 static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2366         {
2367         int ok=1;
2368         struct app_verify_arg *cb_arg = arg;
2369         unsigned int letters[26]; /* only used with proxy_auth */
2370
2371         if (cb_arg->app_verify)
2372                 {
2373                 char *s = NULL,buf[256];
2374
2375                 fprintf(stderr, "In app_verify_callback, allowing cert. ");
2376                 fprintf(stderr, "Arg is: %s\n", cb_arg->string);
2377                 fprintf(stderr, "Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2378                         (void *)ctx, (void *)ctx->cert);
2379                 if (ctx->cert)
2380                         s=X509_NAME_oneline(X509_get_subject_name(ctx->cert),buf,256);
2381                 if (s != NULL)
2382                         {
2383                         fprintf(stderr,"cert depth=%d %s\n",ctx->error_depth,buf);
2384                         }
2385                 return(1);
2386                 }
2387         if (cb_arg->proxy_auth)
2388                 {
2389                 int found_any = 0, i;
2390                 char *sp;
2391
2392                 for(i = 0; i < 26; i++)
2393                         letters[i] = 0;
2394                 for(sp = cb_arg->proxy_auth; *sp; sp++)
2395                         {
2396                         int c = *sp;
2397                         if (isascii(c) && isalpha(c))
2398                                 {
2399                                 if (islower(c))
2400                                         c = toupper(c);
2401                                 letters[c - 'A'] = 1;
2402                                 }
2403                         }
2404
2405                 fprintf(stderr,
2406                         "  Initial proxy rights = ");
2407                 for(i = 0; i < 26; i++)
2408                         if (letters[i])
2409                                 {
2410                                 fprintf(stderr, "%c", i + 'A');
2411                                 found_any = 1;
2412                                 }
2413                 if (!found_any)
2414                         fprintf(stderr, "none");
2415                 fprintf(stderr, "\n");
2416
2417                 X509_STORE_CTX_set_ex_data(ctx,
2418                         get_proxy_auth_ex_data_idx(),letters);
2419                 }
2420         if (cb_arg->allow_proxy_certs)
2421                 {
2422                 X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
2423                 }
2424
2425 #ifndef OPENSSL_NO_X509_VERIFY
2426         ok = X509_verify_cert(ctx);
2427 #endif
2428
2429         if (cb_arg->proxy_auth)
2430                 {
2431                 if (ok > 0)
2432                         {
2433                         const char *cond_end = NULL;
2434
2435                         ok = process_proxy_cond(letters,
2436                                 cb_arg->proxy_cond, &cond_end);
2437
2438                         if (ok < 0)
2439                                 EXIT(3);
2440                         if (*cond_end)
2441                                 {
2442                                 fprintf(stderr, "Stopped processing condition before it's end.\n");
2443                                 ok = 0;
2444                                 }
2445                         if (!ok)
2446                                 fprintf(stderr, "Proxy rights check with condition '%s' proved invalid\n",
2447                                         cb_arg->proxy_cond);
2448                         else
2449                                 fprintf(stderr, "Proxy rights check with condition '%s' proved valid\n",
2450                                         cb_arg->proxy_cond);
2451                         }
2452                 }
2453         return(ok);
2454         }
2455
2456 #ifndef OPENSSL_NO_RSA
2457 static RSA *rsa_tmp=NULL;
2458
2459 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
2460         {
2461         BIGNUM *bn = NULL;
2462         if (rsa_tmp == NULL)
2463                 {
2464                 bn = BN_new();
2465                 rsa_tmp = RSA_new();
2466                 if(!bn || !rsa_tmp || !BN_set_word(bn, RSA_F4))
2467                         {
2468                         BIO_printf(bio_err, "Memory error...");
2469                         goto end;
2470                         }
2471                 BIO_printf(bio_err,"Generating temp (%d bit) RSA key...",keylength);
2472                 (void)BIO_flush(bio_err);
2473                 if(!RSA_generate_key_ex(rsa_tmp,keylength,bn,NULL))
2474                         {
2475                         BIO_printf(bio_err, "Error generating key.");
2476                         RSA_free(rsa_tmp);
2477                         rsa_tmp = NULL;
2478                         }
2479 end:
2480                 BIO_printf(bio_err,"\n");
2481                 (void)BIO_flush(bio_err);
2482                 }
2483         if(bn) BN_free(bn);
2484         return(rsa_tmp);
2485         }
2486
2487 static void free_tmp_rsa(void)
2488         {
2489         if (rsa_tmp != NULL)
2490                 {
2491                 RSA_free(rsa_tmp);
2492                 rsa_tmp = NULL;
2493                 }
2494         }
2495 #endif
2496
2497 #ifndef OPENSSL_NO_DH
2498 /* These DH parameters have been generated as follows:
2499  *    $ openssl dhparam -C -noout 512
2500  *    $ openssl dhparam -C -noout 1024
2501  *    $ openssl dhparam -C -noout -dsaparam 1024
2502  * (The third function has been renamed to avoid name conflicts.)
2503  */
2504 static DH *get_dh512()
2505         {
2506         static unsigned char dh512_p[]={
2507                 0xCB,0xC8,0xE1,0x86,0xD0,0x1F,0x94,0x17,0xA6,0x99,0xF0,0xC6,
2508                 0x1F,0x0D,0xAC,0xB6,0x25,0x3E,0x06,0x39,0xCA,0x72,0x04,0xB0,
2509                 0x6E,0xDA,0xC0,0x61,0xE6,0x7A,0x77,0x25,0xE8,0x3B,0xB9,0x5F,
2510                 0x9A,0xB6,0xB5,0xFE,0x99,0x0B,0xA1,0x93,0x4E,0x35,0x33,0xB8,
2511                 0xE1,0xF1,0x13,0x4F,0x59,0x1A,0xD2,0x57,0xC0,0x26,0x21,0x33,
2512                 0x02,0xC5,0xAE,0x23,
2513                 };
2514         static unsigned char dh512_g[]={
2515                 0x02,
2516                 };
2517         DH *dh;
2518
2519         if ((dh=DH_new()) == NULL) return(NULL);
2520         dh->p=BN_bin2bn(dh512_p,sizeof(dh512_p),NULL);
2521         dh->g=BN_bin2bn(dh512_g,sizeof(dh512_g),NULL);
2522         if ((dh->p == NULL) || (dh->g == NULL))
2523                 { DH_free(dh); return(NULL); }
2524         return(dh);
2525         }
2526
2527 static DH *get_dh1024()
2528         {
2529         static unsigned char dh1024_p[]={
2530                 0xF8,0x81,0x89,0x7D,0x14,0x24,0xC5,0xD1,0xE6,0xF7,0xBF,0x3A,
2531                 0xE4,0x90,0xF4,0xFC,0x73,0xFB,0x34,0xB5,0xFA,0x4C,0x56,0xA2,
2532                 0xEA,0xA7,0xE9,0xC0,0xC0,0xCE,0x89,0xE1,0xFA,0x63,0x3F,0xB0,
2533                 0x6B,0x32,0x66,0xF1,0xD1,0x7B,0xB0,0x00,0x8F,0xCA,0x87,0xC2,
2534                 0xAE,0x98,0x89,0x26,0x17,0xC2,0x05,0xD2,0xEC,0x08,0xD0,0x8C,
2535                 0xFF,0x17,0x52,0x8C,0xC5,0x07,0x93,0x03,0xB1,0xF6,0x2F,0xB8,
2536                 0x1C,0x52,0x47,0x27,0x1B,0xDB,0xD1,0x8D,0x9D,0x69,0x1D,0x52,
2537                 0x4B,0x32,0x81,0xAA,0x7F,0x00,0xC8,0xDC,0xE6,0xD9,0xCC,0xC1,
2538                 0x11,0x2D,0x37,0x34,0x6C,0xEA,0x02,0x97,0x4B,0x0E,0xBB,0xB1,
2539                 0x71,0x33,0x09,0x15,0xFD,0xDD,0x23,0x87,0x07,0x5E,0x89,0xAB,
2540                 0x6B,0x7C,0x5F,0xEC,0xA6,0x24,0xDC,0x53,
2541                 };
2542         static unsigned char dh1024_g[]={
2543                 0x02,
2544                 };
2545         DH *dh;
2546
2547         if ((dh=DH_new()) == NULL) return(NULL);
2548         dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
2549         dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
2550         if ((dh->p == NULL) || (dh->g == NULL))
2551                 { DH_free(dh); return(NULL); }
2552         return(dh);
2553         }
2554
2555 static DH *get_dh1024dsa()
2556         {
2557         static unsigned char dh1024_p[]={
2558                 0xC8,0x00,0xF7,0x08,0x07,0x89,0x4D,0x90,0x53,0xF3,0xD5,0x00,
2559                 0x21,0x1B,0xF7,0x31,0xA6,0xA2,0xDA,0x23,0x9A,0xC7,0x87,0x19,
2560                 0x3B,0x47,0xB6,0x8C,0x04,0x6F,0xFF,0xC6,0x9B,0xB8,0x65,0xD2,
2561                 0xC2,0x5F,0x31,0x83,0x4A,0xA7,0x5F,0x2F,0x88,0x38,0xB6,0x55,
2562                 0xCF,0xD9,0x87,0x6D,0x6F,0x9F,0xDA,0xAC,0xA6,0x48,0xAF,0xFC,
2563                 0x33,0x84,0x37,0x5B,0x82,0x4A,0x31,0x5D,0xE7,0xBD,0x52,0x97,
2564                 0xA1,0x77,0xBF,0x10,0x9E,0x37,0xEA,0x64,0xFA,0xCA,0x28,0x8D,
2565                 0x9D,0x3B,0xD2,0x6E,0x09,0x5C,0x68,0xC7,0x45,0x90,0xFD,0xBB,
2566                 0x70,0xC9,0x3A,0xBB,0xDF,0xD4,0x21,0x0F,0xC4,0x6A,0x3C,0xF6,
2567                 0x61,0xCF,0x3F,0xD6,0x13,0xF1,0x5F,0xBC,0xCF,0xBC,0x26,0x9E,
2568                 0xBC,0x0B,0xBD,0xAB,0x5D,0xC9,0x54,0x39,
2569                 };
2570         static unsigned char dh1024_g[]={
2571                 0x3B,0x40,0x86,0xE7,0xF3,0x6C,0xDE,0x67,0x1C,0xCC,0x80,0x05,
2572                 0x5A,0xDF,0xFE,0xBD,0x20,0x27,0x74,0x6C,0x24,0xC9,0x03,0xF3,
2573                 0xE1,0x8D,0xC3,0x7D,0x98,0x27,0x40,0x08,0xB8,0x8C,0x6A,0xE9,
2574                 0xBB,0x1A,0x3A,0xD6,0x86,0x83,0x5E,0x72,0x41,0xCE,0x85,0x3C,
2575                 0xD2,0xB3,0xFC,0x13,0xCE,0x37,0x81,0x9E,0x4C,0x1C,0x7B,0x65,
2576                 0xD3,0xE6,0xA6,0x00,0xF5,0x5A,0x95,0x43,0x5E,0x81,0xCF,0x60,
2577                 0xA2,0x23,0xFC,0x36,0xA7,0x5D,0x7A,0x4C,0x06,0x91,0x6E,0xF6,
2578                 0x57,0xEE,0x36,0xCB,0x06,0xEA,0xF5,0x3D,0x95,0x49,0xCB,0xA7,
2579                 0xDD,0x81,0xDF,0x80,0x09,0x4A,0x97,0x4D,0xA8,0x22,0x72,0xA1,
2580                 0x7F,0xC4,0x70,0x56,0x70,0xE8,0x20,0x10,0x18,0x8F,0x2E,0x60,
2581                 0x07,0xE7,0x68,0x1A,0x82,0x5D,0x32,0xA2,
2582                 };
2583         DH *dh;
2584
2585         if ((dh=DH_new()) == NULL) return(NULL);
2586         dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
2587         dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
2588         if ((dh->p == NULL) || (dh->g == NULL))
2589                 { DH_free(dh); return(NULL); }
2590         dh->length = 160;
2591         return(dh);
2592         }
2593 #endif
2594
2595 #ifndef OPENSSL_NO_PSK
2596 /* convert the PSK key (psk_key) in ascii to binary (psk) */
2597 static int psk_key2bn(const char *pskkey, unsigned char *psk,
2598         unsigned int max_psk_len)
2599         {
2600         int ret;
2601         BIGNUM *bn = NULL;
2602
2603         ret = BN_hex2bn(&bn, pskkey);
2604         if (!ret)
2605                 {
2606                 BIO_printf(bio_err,"Could not convert PSK key '%s' to BIGNUM\n", pskkey);
2607                 if (bn)
2608                         BN_free(bn);
2609                 return 0;
2610                 }
2611         if (BN_num_bytes(bn) > (int)max_psk_len)
2612                 {
2613                 BIO_printf(bio_err,"psk buffer of callback is too small (%d) for key (%d)\n",
2614                         max_psk_len, BN_num_bytes(bn));
2615                 BN_free(bn);
2616                 return 0;
2617                 }
2618         ret = BN_bn2bin(bn, psk);
2619         BN_free(bn);
2620         return ret;
2621         }
2622
2623 static unsigned int psk_client_callback(SSL *ssl, const char *hint, char *identity,
2624         unsigned int max_identity_len, unsigned char *psk,
2625         unsigned int max_psk_len)
2626         {
2627         int ret;
2628         unsigned int psk_len = 0;
2629
2630         ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
2631         if (ret < 0)
2632                 goto out_err;
2633         if (debug)
2634                 fprintf(stderr, "client: created identity '%s' len=%d\n", identity, ret);
2635         ret = psk_key2bn(psk_key, psk, max_psk_len);
2636         if (ret < 0)
2637                 goto out_err;
2638         psk_len = ret;
2639 out_err:
2640         return psk_len;
2641         }
2642
2643 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
2644         unsigned char *psk, unsigned int max_psk_len)
2645         {
2646         unsigned int psk_len=0;
2647
2648         if (strcmp(identity, "Client_identity") != 0)
2649                 {
2650                 BIO_printf(bio_err, "server: PSK error: client identity not found\n");
2651                 return 0;
2652                 }
2653         psk_len=psk_key2bn(psk_key, psk, max_psk_len);
2654         return psk_len;
2655         }
2656 #endif
2657
2658 static int do_test_cipherlist(void)
2659         {
2660         int i = 0;
2661         const SSL_METHOD *meth;
2662         const SSL_CIPHER *ci, *tci = NULL;
2663
2664 #ifndef OPENSSL_NO_SSL2
2665         fprintf(stderr, "testing SSLv2 cipher list order: ");
2666         meth = SSLv2_method();
2667         while ((ci = meth->get_cipher(i++)) != NULL)
2668                 {
2669                 if (tci != NULL)
2670                         if (ci->id >= tci->id)
2671                                 {
2672                                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
2673                                 return 0;
2674                                 }
2675                 tci = ci;
2676                 }
2677         fprintf(stderr, "ok\n");
2678 #endif
2679 #ifndef OPENSSL_NO_SSL3
2680         fprintf(stderr, "testing SSLv3 cipher list order: ");
2681         meth = SSLv3_method();
2682         tci = NULL;
2683         while ((ci = meth->get_cipher(i++)) != NULL)
2684                 {
2685                 if (tci != NULL)
2686                         if (ci->id >= tci->id)
2687                                 {
2688                                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
2689                                 return 0;
2690                                 }
2691                 tci = ci;
2692                 }
2693         fprintf(stderr, "ok\n");
2694 #endif
2695 #ifndef OPENSSL_NO_TLS1
2696         fprintf(stderr, "testing TLSv1 cipher list order: ");
2697         meth = TLSv1_method();
2698         tci = NULL;
2699         while ((ci = meth->get_cipher(i++)) != NULL)
2700                 {
2701                 if (tci != NULL)
2702                         if (ci->id >= tci->id)
2703                                 {
2704                                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
2705                                 return 0;
2706                                 }
2707                 tci = ci;
2708                 }
2709         fprintf(stderr, "ok\n");
2710 #endif
2711
2712         return 1;
2713         }