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