ssl/ssltest.c

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