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