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