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