ssl/ssltest.c

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