ssl/ssltest.c

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