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