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