ssl/ssltest.c

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