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