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         SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(c_ctx, &co1); /* or &co2 or NULL */
1414         SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(s_ctx, &so1); /* or &so2 or NULL */
1415 #endif
1416
1417         if (!SSL_CTX_use_certificate_file(s_ctx,server_cert,SSL_FILETYPE_PEM))
1418                 {
1419                 ERR_print_errors(bio_err);
1420                 }
1421         else if (!SSL_CTX_use_PrivateKey_file(s_ctx,
1422                 (server_key?server_key:server_cert), SSL_FILETYPE_PEM))
1423                 {
1424                 ERR_print_errors(bio_err);
1425                 goto end;
1426                 }
1427
1428         if (client_auth)
1429                 {
1430                 SSL_CTX_use_certificate_file(c_ctx,client_cert,
1431                         SSL_FILETYPE_PEM);
1432                 SSL_CTX_use_PrivateKey_file(c_ctx,
1433                         (client_key?client_key:client_cert),
1434                         SSL_FILETYPE_PEM);
1435                 }
1436
1437         if (    (!SSL_CTX_load_verify_locations(s_ctx,CAfile,CApath)) ||
1438                 (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1439                 (!SSL_CTX_load_verify_locations(c_ctx,CAfile,CApath)) ||
1440                 (!SSL_CTX_set_default_verify_paths(c_ctx)))
1441                 {
1442                 /* fprintf(stderr,"SSL_load_verify_locations\n"); */
1443                 ERR_print_errors(bio_err);
1444                 /* goto end; */
1445                 }
1446
1447         if (client_auth)
1448                 {
1449                 BIO_printf(bio_err,"client authentication\n");
1450                 SSL_CTX_set_verify(s_ctx,
1451                         SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1452                         verify_callback);
1453                 SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback, &app_verify_arg);
1454                 }
1455         if (server_auth)
1456                 {
1457                 BIO_printf(bio_err,"server authentication\n");
1458                 SSL_CTX_set_verify(c_ctx,SSL_VERIFY_PEER,
1459                         verify_callback);
1460                 SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback, &app_verify_arg);
1461                 }
1462
1463         {
1464                 int session_id_context = 0;
1465                 SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context, sizeof session_id_context);
1466         }
1467
1468         /* Use PSK only if PSK key is given */
1469         if (psk_key != NULL)
1470                 {
1471                 /* no_psk is used to avoid putting psk command to openssl tool */
1472                 if (no_psk)
1473                         {
1474                         /* if PSK is not compiled in and psk key is
1475                          * given, do nothing and exit successfully */
1476                         ret=0;
1477                         goto end;
1478                         }
1479 #ifndef OPENSSL_NO_PSK
1480                 SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1481                 SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1482                 if (debug)
1483                         BIO_printf(bio_err,"setting PSK identity hint to s_ctx\n");
1484                 if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint"))
1485                         {
1486                         BIO_printf(bio_err,"error setting PSK identity hint to s_ctx\n");
1487                         ERR_print_errors(bio_err);
1488                         goto end;
1489                         }
1490 #endif
1491                 }
1492 #ifndef OPENSSL_NO_SRP
1493         if (srp_client_arg.srplogin)
1494                 {
1495                 if (!SSL_CTX_set_srp_username(c_ctx, srp_client_arg.srplogin))
1496                         {
1497                         BIO_printf(bio_err,"Unable to set SRP username\n");
1498                         goto end;
1499                         }
1500                 SSL_CTX_set_srp_cb_arg(c_ctx,&srp_client_arg);
1501                 SSL_CTX_set_srp_client_pwd_callback(c_ctx, ssl_give_srp_client_pwd_cb);
1502                 /*SSL_CTX_set_srp_strength(c_ctx, srp_client_arg.strength);*/
1503                 }
1504
1505         if (srp_server_arg.expected_user != NULL)
1506                 {
1507                 SSL_CTX_set_verify(s_ctx,SSL_VERIFY_NONE,verify_callback);
1508                 SSL_CTX_set_srp_cb_arg(s_ctx, &srp_server_arg);
1509                 SSL_CTX_set_srp_username_callback(s_ctx, ssl_srp_server_param_cb);
1510                 }
1511 #endif
1512
1513         if (serverinfo_sct)
1514                 SSL_CTX_add_client_custom_ext(c_ctx, SCT_EXT_TYPE,
1515                                               NULL, NULL, NULL,
1516                                               serverinfo_cli_parse_cb, NULL);
1517         if (serverinfo_tack)
1518                 SSL_CTX_add_client_custom_ext(c_ctx, TACK_EXT_TYPE,
1519                                               NULL, NULL, NULL,
1520                                               serverinfo_cli_parse_cb, NULL);
1521
1522         if (serverinfo_file)
1523                 if (!SSL_CTX_use_serverinfo_file(s_ctx, serverinfo_file))
1524                         {
1525                         BIO_printf(bio_err, "missing serverinfo file\n");
1526                         goto end;
1527                         }
1528
1529         if (custom_ext)
1530                 {
1531                 SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_0,
1532                                               custom_ext_0_cli_add_cb,
1533                                               NULL, NULL,
1534                                               custom_ext_0_cli_parse_cb, NULL);
1535                 SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_1,
1536                                               custom_ext_1_cli_add_cb,
1537                                               NULL, NULL,
1538                                               custom_ext_1_cli_parse_cb, NULL);
1539                 SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_2,
1540                                               custom_ext_2_cli_add_cb,
1541                                               NULL, NULL,
1542                                               custom_ext_2_cli_parse_cb, NULL);
1543                 SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_3,
1544                                               custom_ext_3_cli_add_cb,
1545                                               NULL, NULL,
1546                                               custom_ext_3_cli_parse_cb, NULL);
1547
1548
1549                 SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_0,
1550                                               custom_ext_0_srv_add_cb,
1551                                               NULL, NULL,
1552                                               custom_ext_0_srv_parse_cb, NULL);
1553                 SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_1,
1554                                               custom_ext_1_srv_add_cb,
1555                                               NULL, NULL,
1556                                               custom_ext_1_srv_parse_cb, NULL);
1557                 SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_2,
1558                                               custom_ext_2_srv_add_cb,
1559                                               NULL, NULL,
1560                                               custom_ext_2_srv_parse_cb, NULL);
1561                 SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_3,
1562                                               custom_ext_3_srv_add_cb,
1563                                               NULL, NULL,
1564                                               custom_ext_3_srv_parse_cb, NULL);
1565                 }
1566
1567         if (alpn_server)
1568                 SSL_CTX_set_alpn_select_cb(s_ctx, cb_server_alpn, NULL);
1569
1570         if (alpn_client)
1571                 {
1572                 unsigned short alpn_len;
1573                 unsigned char *alpn = next_protos_parse(&alpn_len, alpn_client);
1574
1575                 if (alpn == NULL)
1576                         {
1577                         BIO_printf(bio_err, "Error parsing -alpn_client argument\n");
1578                         goto end;
1579                         }
1580                 SSL_CTX_set_alpn_protos(c_ctx, alpn, alpn_len);
1581                 OPENSSL_free(alpn);
1582                 }
1583
1584         c_ssl=SSL_new(c_ctx);
1585         s_ssl=SSL_new(s_ctx);
1586
1587 #ifndef OPENSSL_NO_KRB5
1588         if (c_ssl  &&  c_ssl->kssl_ctx)
1589                 {
1590                 char    localhost[MAXHOSTNAMELEN+2];
1591
1592                 if (gethostname(localhost, sizeof localhost-1) == 0)
1593                         {
1594                         localhost[sizeof localhost-1]='\0';
1595                         if(strlen(localhost) == sizeof localhost-1)
1596                                 {
1597                                 BIO_printf(bio_err,"localhost name too long\n");
1598                                 goto end;
1599                                 }
1600                         kssl_ctx_setstring(c_ssl->kssl_ctx, KSSL_SERVER,
1601                                 localhost);
1602                         }
1603                 }
1604 #endif    /* OPENSSL_NO_KRB5  */
1605
1606         for (i=0; i<number; i++)
1607                 {
1608                 if (!reuse) SSL_set_session(c_ssl,NULL);
1609                 if (bio_pair)
1610                         ret=doit_biopair(s_ssl,c_ssl,bytes,&s_time,&c_time);
1611                 else
1612                         ret=doit(s_ssl,c_ssl,bytes);
1613                 }
1614
1615         if (!verbose)
1616                 {
1617                 print_details(c_ssl, "");
1618                 }
1619         if ((number > 1) || (bytes > 1L))
1620                 BIO_printf(bio_stdout, "%d handshakes of %ld bytes done\n",number,bytes);
1621         if (print_time)
1622                 {
1623 #ifdef CLOCKS_PER_SEC
1624                 /* "To determine the time in seconds, the value returned
1625                  * by the clock function should be divided by the value
1626                  * of the macro CLOCKS_PER_SEC."
1627                  *                                       -- ISO/IEC 9899 */
1628                 BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1629                         "Approximate total client time: %6.2f s\n",
1630                         (double)s_time/CLOCKS_PER_SEC,
1631                         (double)c_time/CLOCKS_PER_SEC);
1632 #else
1633                 /* "`CLOCKS_PER_SEC' undeclared (first use this function)"
1634                  *                            -- cc on NeXTstep/OpenStep */
1635                 BIO_printf(bio_stdout,
1636                         "Approximate total server time: %6.2f units\n"
1637                         "Approximate total client time: %6.2f units\n",
1638                         (double)s_time,
1639                         (double)c_time);
1640 #endif
1641                 }
1642
1643         SSL_free(s_ssl);
1644         SSL_free(c_ssl);
1645
1646 end:
1647         if (s_ctx != NULL) SSL_CTX_free(s_ctx);
1648         if (c_ctx != NULL) SSL_CTX_free(c_ctx);
1649
1650         if (bio_stdout != NULL) BIO_free(bio_stdout);
1651
1652 #ifndef OPENSSL_NO_RSA
1653         free_tmp_rsa();
1654 #endif
1655 #ifndef OPENSSL_NO_ENGINE
1656         ENGINE_cleanup();
1657 #endif
1658         CRYPTO_cleanup_all_ex_data();
1659         ERR_free_strings();
1660         ERR_remove_thread_state(NULL);
1661         EVP_cleanup();
1662         CRYPTO_mem_leaks(bio_err);
1663         if (bio_err != NULL) BIO_free(bio_err);
1664         EXIT(ret);
1665         return ret;
1666         }
1667
1668 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
1669         clock_t *s_time, clock_t *c_time)
1670         {
1671         long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1672         BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1673         BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
1674         int ret = 1;
1675
1676         size_t bufsiz = 256; /* small buffer for testing */
1677
1678         if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
1679                 goto err;
1680         if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
1681                 goto err;
1682
1683         s_ssl_bio = BIO_new(BIO_f_ssl());
1684         if (!s_ssl_bio)
1685                 goto err;
1686
1687         c_ssl_bio = BIO_new(BIO_f_ssl());
1688         if (!c_ssl_bio)
1689                 goto err;
1690
1691         SSL_set_connect_state(c_ssl);
1692         SSL_set_bio(c_ssl, client, client);
1693         (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1694
1695         SSL_set_accept_state(s_ssl);
1696         SSL_set_bio(s_ssl, server, server);
1697         (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1698
1699         do
1700                 {
1701                 /*-
1702                  * c_ssl_bio:          SSL filter BIO
1703                  *
1704                  * client:             pseudo-I/O for SSL library
1705                  *
1706                  * client_io:          client's SSL communication; usually to be
1707                  *                     relayed over some I/O facility, but in this
1708                  *                     test program, we're the server, too:
1709                  *
1710                  * server_io:          server's SSL communication
1711                  *
1712                  * server:             pseudo-I/O for SSL library
1713                  *
1714                  * s_ssl_bio:          SSL filter BIO
1715                  *
1716                  * The client and the server each employ a "BIO pair":
1717                  * client + client_io, server + server_io.
1718                  * BIO pairs are symmetric.  A BIO pair behaves similar
1719                  * to a non-blocking socketpair (but both endpoints must
1720                  * be handled by the same thread).
1721                  * [Here we could connect client and server to the ends
1722                  * of a single BIO pair, but then this code would be less
1723                  * suitable as an example for BIO pairs in general.]
1724                  *
1725                  * Useful functions for querying the state of BIO pair endpoints:
1726                  *
1727                  * BIO_ctrl_pending(bio)              number of bytes we can read now
1728                  * BIO_ctrl_get_read_request(bio)     number of bytes needed to fulfil
1729                  *                                      other side's read attempt
1730                  * BIO_ctrl_get_write_guarantee(bio)   number of bytes we can write now
1731                  *
1732                  * ..._read_request is never more than ..._write_guarantee;
1733                  * it depends on the application which one you should use.
1734                  */
1735
1736                 /* We have non-blocking behaviour throughout this test program, but
1737                  * can be sure that there is *some* progress in each iteration; so
1738                  * we don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE
1739                  * -- we just try everything in each iteration
1740                  */
1741
1742                         {
1743                         /* CLIENT */
1744
1745                         MS_STATIC char cbuf[1024*8];
1746                         int i, r;
1747                         clock_t c_clock = clock();
1748
1749                         memset(cbuf, 0, sizeof(cbuf));
1750
1751                         if (debug)
1752                                 if (SSL_in_init(c_ssl))
1753                                         printf("client waiting in SSL_connect - %s\n",
1754                                                 SSL_state_string_long(c_ssl));
1755
1756                         if (cw_num > 0)
1757                                 {
1758                                 /* Write to server. */
1759
1760                                 if (cw_num > (long)sizeof cbuf)
1761                                         i = sizeof cbuf;
1762                                 else
1763                                         i = (int)cw_num;
1764                                 r = BIO_write(c_ssl_bio, cbuf, i);
1765                                 if (r < 0)
1766                                         {
1767                                         if (!BIO_should_retry(c_ssl_bio))
1768                                                 {
1769                                                 fprintf(stderr,"ERROR in CLIENT\n");
1770                                                 goto err;
1771                                                 }
1772                                         /* BIO_should_retry(...) can just be ignored here.
1773                                          * The library expects us to call BIO_write with
1774                                          * the same arguments again, and that's what we will
1775                                          * do in the next iteration. */
1776                                         }
1777                                 else if (r == 0)
1778                                         {
1779                                         fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1780                                         goto err;
1781                                         }
1782                                 else
1783                                         {
1784                                         if (debug)
1785                                                 printf("client wrote %d\n", r);
1786                                         cw_num -= r;
1787                                         }
1788                                 }
1789
1790                         if (cr_num > 0)
1791                                 {
1792                                 /* Read from server. */
1793
1794                                 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1795                                 if (r < 0)
1796                                         {
1797                                         if (!BIO_should_retry(c_ssl_bio))
1798                                                 {
1799                                                 fprintf(stderr,"ERROR in CLIENT\n");
1800                                                 goto err;
1801                                                 }
1802                                         /* Again, "BIO_should_retry" can be ignored. */
1803                                         }
1804                                 else if (r == 0)
1805                                         {
1806                                         fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1807                                         goto err;
1808                                         }
1809                                 else
1810                                         {
1811                                         if (debug)
1812                                                 printf("client read %d\n", r);
1813                                         cr_num -= r;
1814                                         }
1815                                 }
1816
1817                         /* c_time and s_time increments will typically be very small
1818                          * (depending on machine speed and clock tick intervals),
1819                          * but sampling over a large number of connections should
1820                          * result in fairly accurate figures.  We cannot guarantee
1821                          * a lot, however -- if each connection lasts for exactly
1822                          * one clock tick, it will be counted only for the client
1823                          * or only for the server or even not at all.
1824                          */
1825                         *c_time += (clock() - c_clock);
1826                         }
1827
1828                         {
1829                         /* SERVER */
1830
1831                         MS_STATIC char sbuf[1024*8];
1832                         int i, r;
1833                         clock_t s_clock = clock();
1834
1835                         memset(sbuf, 0, sizeof(sbuf));
1836
1837                         if (debug)
1838                                 if (SSL_in_init(s_ssl))
1839                                         printf("server waiting in SSL_accept - %s\n",
1840                                                 SSL_state_string_long(s_ssl));
1841
1842                         if (sw_num > 0)
1843                                 {
1844                                 /* Write to client. */
1845
1846                                 if (sw_num > (long)sizeof sbuf)
1847                                         i = sizeof sbuf;
1848                                 else
1849                                         i = (int)sw_num;
1850                                 r = BIO_write(s_ssl_bio, sbuf, i);
1851                                 if (r < 0)
1852                                         {
1853                                         if (!BIO_should_retry(s_ssl_bio))
1854                                                 {
1855                                                 fprintf(stderr,"ERROR in SERVER\n");
1856                                                 goto err;
1857                                                 }
1858                                         /* Ignore "BIO_should_retry". */
1859                                         }
1860                                 else if (r == 0)
1861                                         {
1862                                         fprintf(stderr,"SSL SERVER STARTUP FAILED\n");
1863                                         goto err;
1864                                         }
1865                                 else
1866                                         {
1867                                         if (debug)
1868                                                 printf("server wrote %d\n", r);
1869                                         sw_num -= r;
1870                                         }
1871                                 }
1872
1873                         if (sr_num > 0)
1874                                 {
1875                                 /* Read from client. */
1876
1877                                 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
1878                                 if (r < 0)
1879                                         {
1880                                         if (!BIO_should_retry(s_ssl_bio))
1881                                                 {
1882                                                 fprintf(stderr,"ERROR in SERVER\n");
1883                                                 goto err;
1884                                                 }
1885                                         /* blah, blah */
1886                                         }
1887                                 else if (r == 0)
1888                                         {
1889                                         fprintf(stderr,"SSL SERVER STARTUP FAILED\n");
1890                                         goto err;
1891                                         }
1892                                 else
1893                                         {
1894                                         if (debug)
1895                                                 printf("server read %d\n", r);
1896                                         sr_num -= r;
1897                                         }
1898                                 }
1899
1900                         *s_time += (clock() - s_clock);
1901                         }
1902
1903                         {
1904                         /* "I/O" BETWEEN CLIENT AND SERVER. */
1905
1906                         size_t r1, r2;
1907                         BIO *io1 = server_io, *io2 = client_io;
1908                         /* we use the non-copying interface for io1
1909                          * and the standard BIO_write/BIO_read interface for io2
1910                          */
1911
1912                         static int prev_progress = 1;
1913                         int progress = 0;
1914
1915                         /* io1 to io2 */
1916                         do
1917                                 {
1918                                 size_t num;
1919                                 int r;
1920
1921                                 r1 = BIO_ctrl_pending(io1);
1922                                 r2 = BIO_ctrl_get_write_guarantee(io2);
1923
1924                                 num = r1;
1925                                 if (r2 < num)
1926                                         num = r2;
1927                                 if (num)
1928                                         {
1929                                         char *dataptr;
1930
1931                                         if (INT_MAX < num) /* yeah, right */
1932                                                 num = INT_MAX;
1933
1934                                         r = BIO_nread(io1, &dataptr, (int)num);
1935                                         assert(r > 0);
1936                                         assert(r <= (int)num);
1937                                         /* possibly r < num (non-contiguous data) */
1938                                         num = r;
1939                                         r = BIO_write(io2, dataptr, (int)num);
1940                                         if (r != (int)num) /* can't happen */
1941                                                 {
1942                                                 fprintf(stderr, "ERROR: BIO_write could not write "
1943                                                         "BIO_ctrl_get_write_guarantee() bytes");
1944                                                 goto err;
1945                                                 }
1946                                         progress = 1;
1947
1948                                         if (debug)
1949                                                 printf((io1 == client_io) ?
1950                                                         "C->S relaying: %d bytes\n" :
1951                                                         "S->C relaying: %d bytes\n",
1952                                                         (int)num);
1953                                         }
1954                                 }
1955                         while (r1 && r2);
1956
1957                         /* io2 to io1 */
1958                         {
1959                                 size_t num;
1960                                 int r;
1961
1962                                 r1 = BIO_ctrl_pending(io2);
1963                                 r2 = BIO_ctrl_get_read_request(io1);
1964                                 /* here we could use ..._get_write_guarantee instead of
1965                                  * ..._get_read_request, but by using the latter
1966                                  * we test restartability of the SSL implementation
1967                                  * more thoroughly */
1968                                 num = r1;
1969                                 if (r2 < num)
1970                                         num = r2;
1971                                 if (num)
1972                                         {
1973                                         char *dataptr;
1974
1975                                         if (INT_MAX < num)
1976                                                 num = INT_MAX;
1977
1978                                         if (num > 1)
1979                                                 --num; /* test restartability even more thoroughly */
1980
1981                                         r = BIO_nwrite0(io1, &dataptr);
1982                                         assert(r > 0);
1983                                         if (r < (int)num)
1984                                                 num = r;
1985                                         r = BIO_read(io2, dataptr, (int)num);
1986                                         if (r != (int)num) /* can't happen */
1987                                                 {
1988                                                 fprintf(stderr, "ERROR: BIO_read could not read "
1989                                                         "BIO_ctrl_pending() bytes");
1990                                                 goto err;
1991                                                 }
1992                                         progress = 1;
1993                                         r = BIO_nwrite(io1, &dataptr, (int)num);
1994                                         if (r != (int)num) /* can't happen */
1995                                                 {
1996                                                 fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
1997                                                         "BIO_nwrite0() bytes");
1998                                                 goto err;
1999                                                 }
2000
2001                                         if (debug)
2002                                                 printf((io2 == client_io) ?
2003                                                         "C->S relaying: %d bytes\n" :
2004                                                         "S->C relaying: %d bytes\n",
2005                                                         (int)num);
2006                                         }
2007                         } /* no loop, BIO_ctrl_get_read_request now returns 0 anyway */
2008
2009                         if (!progress && !prev_progress)
2010                                 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0)
2011                                         {
2012                                         fprintf(stderr, "ERROR: got stuck\n");
2013                                         if (strcmp("SSLv2", SSL_get_version(c_ssl)) == 0)
2014                                                 {
2015                                                 fprintf(stderr, "This can happen for SSL2 because "
2016                                                         "CLIENT-FINISHED and SERVER-VERIFY are written \n"
2017                                                         "concurrently ...");
2018                                                 if (strncmp("2SCF", SSL_state_string(c_ssl), 4) == 0
2019                                                         && strncmp("2SSV", SSL_state_string(s_ssl), 4) == 0)
2020                                                         {
2021                                                         fprintf(stderr, " ok.\n");
2022                                                         goto end;
2023                                                         }
2024                                                 }
2025                                         fprintf(stderr, " ERROR.\n");
2026                                         goto err;
2027                                         }
2028                         prev_progress = progress;
2029                         }
2030                 }
2031         while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2032
2033         if (verbose)
2034                 print_details(c_ssl, "DONE via BIO pair: ");
2035
2036         if (verify_serverinfo() < 0)
2037                 {
2038                 ret = 1;
2039                 goto err;
2040                 }
2041         if (verify_alpn(c_ssl, s_ssl) < 0)
2042                 {
2043                 ret = 1;
2044                 goto err;
2045                 }
2046
2047         if (custom_ext_error)
2048                 {
2049                 ret = 1;
2050                 goto err;
2051                 }
2052
2053 end:
2054         ret = 0;
2055
2056  err:
2057         ERR_print_errors(bio_err);
2058
2059         if (server)
2060                 BIO_free(server);
2061         if (server_io)
2062                 BIO_free(server_io);
2063         if (client)
2064                 BIO_free(client);
2065         if (client_io)
2066                 BIO_free(client_io);
2067         if (s_ssl_bio)
2068                 BIO_free(s_ssl_bio);
2069         if (c_ssl_bio)
2070                 BIO_free(c_ssl_bio);
2071
2072         return ret;
2073         }
2074
2075
2076 #define W_READ  1
2077 #define W_WRITE 2
2078 #define C_DONE  1
2079 #define S_DONE  2
2080
2081 int doit(SSL *s_ssl, SSL *c_ssl, long count)
2082         {
2083         char *cbuf=NULL,*sbuf=NULL;
2084         long bufsiz;
2085         long cw_num=count,cr_num=count;
2086         long sw_num=count,sr_num=count;
2087         int ret=1;
2088         BIO *c_to_s=NULL;
2089         BIO *s_to_c=NULL;
2090         BIO *c_bio=NULL;
2091         BIO *s_bio=NULL;
2092         int c_r,c_w,s_r,s_w;
2093         int i,j;
2094         int done=0;
2095         int c_write,s_write;
2096         int do_server=0,do_client=0;
2097         int max_frag = 5*1024;
2098
2099         bufsiz = count>40*1024 ? 40*1024 : count;
2100
2101         if ((cbuf = OPENSSL_malloc(bufsiz))==NULL) goto err;
2102         if ((sbuf = OPENSSL_malloc(bufsiz))==NULL) goto err;
2103
2104         memset(cbuf,0,bufsiz);
2105         memset(sbuf,0,bufsiz);
2106
2107         c_to_s=BIO_new(BIO_s_mem());
2108         s_to_c=BIO_new(BIO_s_mem());
2109         if ((s_to_c == NULL) || (c_to_s == NULL))
2110                 {
2111                 ERR_print_errors(bio_err);
2112                 goto err;
2113                 }
2114
2115         c_bio=BIO_new(BIO_f_ssl());
2116         s_bio=BIO_new(BIO_f_ssl());
2117         if ((c_bio == NULL) || (s_bio == NULL))
2118                 {
2119                 ERR_print_errors(bio_err);
2120                 goto err;
2121                 }
2122
2123         SSL_set_connect_state(c_ssl);
2124         SSL_set_bio(c_ssl,s_to_c,c_to_s);
2125         SSL_set_max_send_fragment(c_ssl,max_frag);
2126         BIO_set_ssl(c_bio,c_ssl,BIO_NOCLOSE);
2127
2128         SSL_set_accept_state(s_ssl);
2129         SSL_set_bio(s_ssl,c_to_s,s_to_c);
2130         SSL_set_max_send_fragment(s_ssl,max_frag);
2131         BIO_set_ssl(s_bio,s_ssl,BIO_NOCLOSE);
2132
2133         c_r=0; s_r=1;
2134         c_w=1; s_w=0;
2135         c_write=1,s_write=0;
2136
2137         /* We can always do writes */
2138         for (;;)
2139                 {
2140                 do_server=0;
2141                 do_client=0;
2142
2143                 i=(int)BIO_pending(s_bio);
2144                 if ((i && s_r) || s_w) do_server=1;
2145
2146                 i=(int)BIO_pending(c_bio);
2147                 if ((i && c_r) || c_w) do_client=1;
2148
2149                 if (do_server && debug)
2150                         {
2151                         if (SSL_in_init(s_ssl))
2152                                 printf("server waiting in SSL_accept - %s\n",
2153                                         SSL_state_string_long(s_ssl));
2154 /*-
2155                         else if (s_write)
2156                                 printf("server:SSL_write()\n");
2157                         else
2158                                 printf("server:SSL_read()\n"); */
2159                         }
2160
2161                 if (do_client && debug)
2162                         {
2163                         if (SSL_in_init(c_ssl))
2164                                 printf("client waiting in SSL_connect - %s\n",
2165                                         SSL_state_string_long(c_ssl));
2166 /*-
2167                         else if (c_write)
2168                                 printf("client:SSL_write()\n");
2169                         else
2170                                 printf("client:SSL_read()\n"); */
2171                         }
2172
2173                 if (!do_client && !do_server)
2174                         {
2175                         fprintf(stdout,"ERROR IN STARTUP\n");
2176                         ERR_print_errors(bio_err);
2177                         break;
2178                         }
2179                 if (do_client && !(done & C_DONE))
2180                         {
2181                         if (c_write)
2182                                 {
2183                                 j = (cw_num > bufsiz) ?
2184                                         (int)bufsiz : (int)cw_num;
2185                                 i=BIO_write(c_bio,cbuf,j);
2186                                 if (i < 0)
2187                                         {
2188                                         c_r=0;
2189                                         c_w=0;
2190                                         if (BIO_should_retry(c_bio))
2191                                                 {
2192                                                 if (BIO_should_read(c_bio))
2193                                                         c_r=1;
2194                                                 if (BIO_should_write(c_bio))
2195                                                         c_w=1;
2196                                                 }
2197                                         else
2198                                                 {
2199                                                 fprintf(stderr,"ERROR in CLIENT\n");
2200                                                 ERR_print_errors(bio_err);
2201                                                 goto err;
2202                                                 }
2203                                         }
2204                                 else if (i == 0)
2205                                         {
2206                                         fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
2207                                         goto err;
2208                                         }
2209                                 else
2210                                         {
2211                                         if (debug)
2212                                                 printf("client wrote %d\n",i);
2213                                         /* ok */
2214                                         s_r=1;
2215                                         c_write=0;
2216                                         cw_num-=i;
2217                                         if (max_frag>1029)
2218                                                 SSL_set_max_send_fragment(c_ssl,max_frag-=5);
2219                                         }
2220                                 }
2221                         else
2222                                 {
2223                                 i=BIO_read(c_bio,cbuf,bufsiz);
2224                                 if (i < 0)
2225                                         {
2226                                         c_r=0;
2227                                         c_w=0;
2228                                         if (BIO_should_retry(c_bio))
2229                                                 {
2230                                                 if (BIO_should_read(c_bio))
2231                                                         c_r=1;
2232                                                 if (BIO_should_write(c_bio))
2233                                                         c_w=1;
2234                                                 }
2235                                         else
2236                                                 {
2237                                                 fprintf(stderr,"ERROR in CLIENT\n");
2238                                                 ERR_print_errors(bio_err);
2239                                                 goto err;
2240                                                 }
2241                                         }
2242                                 else if (i == 0)
2243                                         {
2244                                         fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
2245                                         goto err;
2246                                         }
2247                                 else
2248                                         {
2249                                         if (debug)
2250                                                 printf("client read %d\n",i);
2251                                         cr_num-=i;
2252                                         if (sw_num > 0)
2253                                                 {
2254                                                 s_write=1;
2255                                                 s_w=1;
2256                                                 }
2257                                         if (cr_num <= 0)
2258                                                 {
2259                                                 s_write=1;
2260                                                 s_w=1;
2261                                                 done=S_DONE|C_DONE;
2262                                                 }
2263                                         }
2264                                 }
2265                         }
2266
2267                 if (do_server && !(done & S_DONE))
2268                         {
2269                         if (!s_write)
2270                                 {
2271                                 i=BIO_read(s_bio,sbuf,bufsiz);
2272                                 if (i < 0)
2273                                         {
2274                                         s_r=0;
2275                                         s_w=0;
2276                                         if (BIO_should_retry(s_bio))
2277                                                 {
2278                                                 if (BIO_should_read(s_bio))
2279                                                         s_r=1;
2280                                                 if (BIO_should_write(s_bio))
2281                                                         s_w=1;
2282                                                 }
2283                                         else
2284                                                 {
2285                                                 fprintf(stderr,"ERROR in SERVER\n");
2286                                                 ERR_print_errors(bio_err);
2287                                                 goto err;
2288                                                 }
2289                                         }
2290                                 else if (i == 0)
2291                                         {
2292                                         ERR_print_errors(bio_err);
2293                                         fprintf(stderr,"SSL SERVER STARTUP FAILED in SSL_read\n");
2294                                         goto err;
2295                                         }
2296                                 else
2297                                         {
2298                                         if (debug)
2299                                                 printf("server read %d\n",i);
2300                                         sr_num-=i;
2301                                         if (cw_num > 0)
2302                                                 {
2303                                                 c_write=1;
2304                                                 c_w=1;
2305                                                 }
2306                                         if (sr_num <= 0)
2307                                                 {
2308                                                 s_write=1;
2309                                                 s_w=1;
2310                                                 c_write=0;
2311                                                 }
2312                                         }
2313                                 }
2314                         else
2315                                 {
2316                                 j = (sw_num > bufsiz) ?
2317                                         (int)bufsiz : (int)sw_num;
2318                                 i=BIO_write(s_bio,sbuf,j);
2319                                 if (i < 0)
2320                                         {
2321                                         s_r=0;
2322                                         s_w=0;
2323                                         if (BIO_should_retry(s_bio))
2324                                                 {
2325                                                 if (BIO_should_read(s_bio))
2326                                                         s_r=1;
2327                                                 if (BIO_should_write(s_bio))
2328                                                         s_w=1;
2329                                                 }
2330                                         else
2331                                                 {
2332                                                 fprintf(stderr,"ERROR in SERVER\n");
2333                                                 ERR_print_errors(bio_err);
2334                                                 goto err;
2335                                                 }
2336                                         }
2337                                 else if (i == 0)
2338                                         {
2339                                         ERR_print_errors(bio_err);
2340                                         fprintf(stderr,"SSL SERVER STARTUP FAILED in SSL_write\n");
2341                                         goto err;
2342                                         }
2343                                 else
2344                                         {
2345                                         if (debug)
2346                                                 printf("server wrote %d\n",i);
2347                                         sw_num-=i;
2348                                         s_write=0;
2349                                         c_r=1;
2350                                         if (sw_num <= 0)
2351                                                 done|=S_DONE;
2352                                         if (max_frag>1029)
2353                                                 SSL_set_max_send_fragment(s_ssl,max_frag-=5);
2354                                         }
2355                                 }
2356                         }
2357
2358                 if ((done & S_DONE) && (done & C_DONE)) break;
2359                 }
2360
2361         if (verbose)
2362                 print_details(c_ssl, "DONE: ");
2363         if (verify_serverinfo() < 0)
2364                 {
2365                 ret = 1;
2366                 goto err;
2367                 }
2368         if (custom_ext_error)
2369                 {
2370                 ret = 1;
2371                 goto err;
2372                 }
2373         ret=0;
2374 err:
2375         /* We have to set the BIO's to NULL otherwise they will be
2376          * OPENSSL_free()ed twice.  Once when th s_ssl is SSL_free()ed and
2377          * again when c_ssl is SSL_free()ed.
2378          * This is a hack required because s_ssl and c_ssl are sharing the same
2379          * BIO structure and SSL_set_bio() and SSL_free() automatically
2380          * BIO_free non NULL entries.
2381          * You should not normally do this or be required to do this */
2382         if (s_ssl != NULL)
2383                 {
2384                 s_ssl->rbio=NULL;
2385                 s_ssl->wbio=NULL;
2386                 }
2387         if (c_ssl != NULL)
2388                 {
2389                 c_ssl->rbio=NULL;
2390                 c_ssl->wbio=NULL;
2391                 }
2392
2393         if (c_to_s != NULL) BIO_free(c_to_s);
2394         if (s_to_c != NULL) BIO_free(s_to_c);
2395         if (c_bio != NULL) BIO_free_all(c_bio);
2396         if (s_bio != NULL) BIO_free_all(s_bio);
2397
2398         if (cbuf) OPENSSL_free(cbuf);
2399         if (sbuf) OPENSSL_free(sbuf);
2400
2401         return(ret);
2402         }
2403
2404 static int get_proxy_auth_ex_data_idx(void)
2405         {
2406         static volatile int idx = -1;
2407         if (idx < 0)
2408                 {
2409                 CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
2410                 if (idx < 0)
2411                         {
2412                         idx = X509_STORE_CTX_get_ex_new_index(0,
2413                                 "SSLtest for verify callback", NULL,NULL,NULL);
2414                         }
2415                 CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
2416                 }
2417         return idx;
2418         }
2419
2420 static int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx)
2421         {
2422         char *s,buf[256];
2423
2424         s=X509_NAME_oneline(X509_get_subject_name(ctx->current_cert),buf,
2425                             sizeof buf);
2426         if (s != NULL)
2427                 {
2428                 if (ok)
2429                         fprintf(stderr,"depth=%d %s\n",
2430                                 ctx->error_depth,buf);
2431                 else
2432                         {
2433                         fprintf(stderr,"depth=%d error=%d %s\n",
2434                                 ctx->error_depth,ctx->error,buf);
2435                         }
2436                 }
2437
2438         if (ok == 0)
2439                 {
2440                 fprintf(stderr,"Error string: %s\n",
2441                         X509_verify_cert_error_string(ctx->error));
2442                 switch (ctx->error)
2443                         {
2444                 case X509_V_ERR_CERT_NOT_YET_VALID:
2445                 case X509_V_ERR_CERT_HAS_EXPIRED:
2446                 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2447                         fprintf(stderr,"  ... ignored.\n");
2448                         ok=1;
2449                         }
2450                 }
2451
2452         if (ok == 1)
2453                 {
2454                 X509 *xs = ctx->current_cert;
2455 #if 0
2456                 X509 *xi = ctx->current_issuer;
2457 #endif
2458
2459                 if (xs->ex_flags & EXFLAG_PROXY)
2460                         {
2461                         unsigned int *letters =
2462                                 X509_STORE_CTX_get_ex_data(ctx,
2463                                         get_proxy_auth_ex_data_idx());
2464
2465                         if (letters)
2466                                 {
2467                                 int found_any = 0;
2468                                 int i;
2469                                 PROXY_CERT_INFO_EXTENSION *pci =
2470                                         X509_get_ext_d2i(xs, NID_proxyCertInfo,
2471                                                 NULL, NULL);
2472
2473                                 switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage))
2474                                         {
2475                                 case NID_Independent:
2476                                         /* Completely meaningless in this
2477                                            program, as there's no way to
2478                                            grant explicit rights to a
2479                                            specific PrC.  Basically, using
2480                                            id-ppl-Independent is the perfect
2481                                            way to grant no rights at all. */
2482                                         fprintf(stderr, "  Independent proxy certificate");
2483                                         for (i = 0; i < 26; i++)
2484                                                 letters[i] = 0;
2485                                         break;
2486                                 case NID_id_ppl_inheritAll:
2487                                         /* This is basically a NOP, we
2488                                            simply let the current rights
2489                                            stand as they are. */
2490                                         fprintf(stderr, "  Proxy certificate inherits all");
2491                                         break;
2492                                 default:
2493                                         s = (char *)
2494                                                 pci->proxyPolicy->policy->data;
2495                                         i = pci->proxyPolicy->policy->length;
2496
2497                                         /* The algorithm works as follows:
2498                                            it is assumed that previous
2499                                            iterations or the initial granted
2500                                            rights has already set some elements
2501                                            of `letters'.  What we need to do is
2502                                            to clear those that weren't granted
2503                                            by the current PrC as well.  The
2504                                            easiest way to do this is to add 1
2505                                            to all the elements whose letters
2506                                            are given with the current policy.
2507                                            That way, all elements that are set
2508                                            by the current policy and were
2509                                            already set by earlier policies and
2510                                            through the original grant of rights
2511                                            will get the value 2 or higher.
2512                                            The last thing to do is to sweep
2513                                            through `letters' and keep the
2514                                            elements having the value 2 as set,
2515                                            and clear all the others. */
2516
2517                                         fprintf(stderr, "  Certificate proxy rights = %*.*s", i, i, s);
2518                                         while(i-- > 0)
2519                                                 {
2520                                                 int c = *s++;
2521                                                 if (isascii(c) && isalpha(c))
2522                                                         {
2523                                                         if (islower(c))
2524                                                                 c = toupper(c);
2525                                                         letters[c - 'A']++;
2526                                                         }
2527                                                 }
2528                                         for (i = 0; i < 26; i++)
2529                                                 if (letters[i] < 2)
2530                                                         letters[i] = 0;
2531                                                 else
2532                                                         letters[i] = 1;
2533                                         }
2534
2535                                 found_any = 0;
2536                                 fprintf(stderr,
2537                                         ", resulting proxy rights = ");
2538                                 for(i = 0; i < 26; i++)
2539                                         if (letters[i])
2540                                                 {
2541                                                 fprintf(stderr, "%c", i + 'A');
2542                                                 found_any = 1;
2543                                                 }
2544                                 if (!found_any)
2545                                         fprintf(stderr, "none");
2546                                 fprintf(stderr, "\n");
2547
2548                                 PROXY_CERT_INFO_EXTENSION_free(pci);
2549                                 }
2550                         }
2551                 }
2552
2553         return(ok);
2554         }
2555
2556 static void process_proxy_debug(int indent, const char *format, ...)
2557         {
2558         /* That's 80 > */
2559         static const char indentation[] =
2560                 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
2561                 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
2562         char my_format[256];
2563         va_list args;
2564
2565         BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
2566                 indent, indent, indentation, format);
2567
2568         va_start(args, format);
2569         vfprintf(stderr, my_format, args);
2570         va_end(args);
2571         }
2572 /*-
2573  * Priority levels:
2574  *  0   [!]var, ()
2575  *  1   & ^
2576  *  2   |
2577  */
2578 static int process_proxy_cond_adders(unsigned int letters[26],
2579         const char *cond, const char **cond_end, int *pos, int indent);
2580 static int process_proxy_cond_val(unsigned int letters[26],
2581         const char *cond, const char **cond_end, int *pos, int indent)
2582         {
2583         int c;
2584         int ok = 1;
2585         int negate = 0;
2586
2587         while(isspace((int)*cond))
2588                 {
2589                 cond++; (*pos)++;
2590                 }
2591         c = *cond;
2592
2593         if (debug)
2594                 process_proxy_debug(indent,
2595                         "Start process_proxy_cond_val at position %d: %s\n",
2596                         *pos, cond);
2597
2598         while(c == '!')
2599                 {
2600                 negate = !negate;
2601                 cond++; (*pos)++;
2602                 while(isspace((int)*cond))
2603                         {
2604                         cond++; (*pos)++;
2605                         }
2606                 c = *cond;
2607                 }
2608
2609         if (c == '(')
2610                 {
2611                 cond++; (*pos)++;
2612                 ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
2613                         indent + 1);
2614                 cond = *cond_end;
2615                 if (ok < 0)
2616                         goto end;
2617                 while(isspace((int)*cond))
2618                         {
2619                         cond++; (*pos)++;
2620                         }
2621                 c = *cond;
2622                 if (c != ')')
2623                         {
2624                         fprintf(stderr,
2625                                 "Weird condition character in position %d: "
2626                                 "%c\n", *pos, c);
2627                         ok = -1;
2628                         goto end;
2629                         }
2630                 cond++; (*pos)++;
2631                 }
2632         else if (isascii(c) && isalpha(c))
2633                 {
2634                 if (islower(c))
2635                         c = toupper(c);
2636                 ok = letters[c - 'A'];
2637                 cond++; (*pos)++;
2638                 }
2639         else
2640                 {
2641                 fprintf(stderr,
2642                         "Weird condition character in position %d: "
2643                         "%c\n", *pos, c);
2644                 ok = -1;
2645                 goto end;
2646                 }
2647  end:
2648         *cond_end = cond;
2649         if (ok >= 0 && negate)
2650                 ok = !ok;
2651
2652         if (debug)
2653                 process_proxy_debug(indent,
2654                         "End process_proxy_cond_val at position %d: %s, returning %d\n",
2655                         *pos, cond, ok);
2656
2657         return ok;
2658         }
2659 static int process_proxy_cond_multipliers(unsigned int letters[26],
2660         const char *cond, const char **cond_end, int *pos, int indent)
2661         {
2662         int ok;
2663         char c;
2664
2665         if (debug)
2666                 process_proxy_debug(indent,
2667                         "Start process_proxy_cond_multipliers at position %d: %s\n",
2668                         *pos, cond);
2669
2670         ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
2671         cond = *cond_end;
2672         if (ok < 0)
2673                 goto end;
2674
2675         while(ok >= 0)
2676                 {
2677                 while(isspace((int)*cond))
2678                         {
2679                         cond++; (*pos)++;
2680                         }
2681                 c = *cond;
2682
2683                 switch(c)
2684                         {
2685                 case '&':
2686                 case '^':
2687                         {
2688                         int save_ok = ok;
2689
2690                         cond++; (*pos)++;
2691                         ok = process_proxy_cond_val(letters,
2692                                 cond, cond_end, pos, indent + 1);
2693                         cond = *cond_end;
2694                         if (ok < 0)
2695                                 break;
2696
2697                         switch(c)
2698                                 {
2699                         case '&':
2700                                 ok &= save_ok;
2701                                 break;
2702                         case '^':
2703                                 ok ^= save_ok;
2704                                 break;
2705                         default:
2706                                 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2707                                         " STOPPING\n");
2708                                 EXIT(1);
2709                                 }
2710                         }
2711                         break;
2712                 default:
2713                         goto end;
2714                         }
2715                 }
2716  end:
2717         if (debug)
2718                 process_proxy_debug(indent,
2719                         "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
2720                         *pos, cond, ok);
2721
2722         *cond_end = cond;
2723         return ok;
2724         }
2725 static int process_proxy_cond_adders(unsigned int letters[26],
2726         const char *cond, const char **cond_end, int *pos, int indent)
2727         {
2728         int ok;
2729         char c;
2730
2731         if (debug)
2732                 process_proxy_debug(indent,
2733                         "Start process_proxy_cond_adders at position %d: %s\n",
2734                         *pos, cond);
2735
2736         ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
2737                 indent + 1);
2738         cond = *cond_end;
2739         if (ok < 0)
2740                 goto end;
2741
2742         while(ok >= 0)
2743                 {
2744                 while(isspace((int)*cond))
2745                         {
2746                         cond++; (*pos)++;
2747                         }
2748                 c = *cond;
2749
2750                 switch(c)
2751                         {
2752                 case '|':
2753                         {
2754                         int save_ok = ok;
2755
2756                         cond++; (*pos)++;
2757                         ok = process_proxy_cond_multipliers(letters,
2758                                 cond, cond_end, pos, indent + 1);
2759                         cond = *cond_end;
2760                         if (ok < 0)
2761                                 break;
2762
2763                         switch(c)
2764                                 {
2765                         case '|':
2766                                 ok |= save_ok;
2767                                 break;
2768                         default:
2769                                 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2770                                         " STOPPING\n");
2771                                 EXIT(1);
2772                                 }
2773                         }
2774                         break;
2775                 default:
2776                         goto end;
2777                         }
2778                 }
2779  end:
2780         if (debug)
2781                 process_proxy_debug(indent,
2782                         "End process_proxy_cond_adders at position %d: %s, returning %d\n",
2783                         *pos, cond, ok);
2784
2785         *cond_end = cond;
2786         return ok;
2787         }
2788
2789 static int process_proxy_cond(unsigned int letters[26],
2790         const char *cond, const char **cond_end)
2791         {
2792         int pos = 1;
2793         return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
2794         }
2795
2796 static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2797         {
2798         int ok=1;
2799         struct app_verify_arg *cb_arg = arg;
2800         unsigned int letters[26]; /* only used with proxy_auth */
2801
2802         if (cb_arg->app_verify)
2803                 {
2804                 char *s = NULL,buf[256];
2805
2806                 fprintf(stderr, "In app_verify_callback, allowing cert. ");
2807                 fprintf(stderr, "Arg is: %s\n", cb_arg->string);
2808                 fprintf(stderr, "Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2809                         (void *)ctx, (void *)ctx->cert);
2810                 if (ctx->cert)
2811                         s=X509_NAME_oneline(X509_get_subject_name(ctx->cert),buf,256);
2812                 if (s != NULL)
2813                         {
2814                         fprintf(stderr,"cert depth=%d %s\n",ctx->error_depth,buf);
2815                         }
2816                 return(1);
2817                 }
2818         if (cb_arg->proxy_auth)
2819                 {
2820                 int found_any = 0, i;
2821                 char *sp;
2822
2823                 for(i = 0; i < 26; i++)
2824                         letters[i] = 0;
2825                 for(sp = cb_arg->proxy_auth; *sp; sp++)
2826                         {
2827                         int c = *sp;
2828                         if (isascii(c) && isalpha(c))
2829                                 {
2830                                 if (islower(c))
2831                                         c = toupper(c);
2832                                 letters[c - 'A'] = 1;
2833                                 }
2834                         }
2835
2836                 fprintf(stderr,
2837                         "  Initial proxy rights = ");
2838                 for(i = 0; i < 26; i++)
2839                         if (letters[i])
2840                                 {
2841                                 fprintf(stderr, "%c", i + 'A');
2842                                 found_any = 1;
2843                                 }
2844                 if (!found_any)
2845                         fprintf(stderr, "none");
2846                 fprintf(stderr, "\n");
2847
2848                 X509_STORE_CTX_set_ex_data(ctx,
2849                         get_proxy_auth_ex_data_idx(),letters);
2850                 }
2851         if (cb_arg->allow_proxy_certs)
2852                 {
2853                 X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
2854                 }
2855
2856 #ifndef OPENSSL_NO_X509_VERIFY
2857         ok = X509_verify_cert(ctx);
2858 #endif
2859
2860         if (cb_arg->proxy_auth)
2861                 {
2862                 if (ok > 0)
2863                         {
2864                         const char *cond_end = NULL;
2865
2866                         ok = process_proxy_cond(letters,
2867                                 cb_arg->proxy_cond, &cond_end);
2868
2869                         if (ok < 0)
2870                                 EXIT(3);
2871                         if (*cond_end)
2872                                 {
2873                                 fprintf(stderr, "Stopped processing condition before it's end.\n");
2874                                 ok = 0;
2875                                 }
2876                         if (!ok)
2877                                 fprintf(stderr, "Proxy rights check with condition '%s' proved invalid\n",
2878                                         cb_arg->proxy_cond);
2879                         else
2880                                 fprintf(stderr, "Proxy rights check with condition '%s' proved valid\n",
2881                                         cb_arg->proxy_cond);
2882                         }
2883                 }
2884         return(ok);
2885         }
2886
2887 #ifndef OPENSSL_NO_RSA
2888 static RSA *rsa_tmp=NULL;
2889
2890 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
2891         {
2892         BIGNUM *bn = NULL;
2893         if (rsa_tmp == NULL)
2894                 {
2895                 bn = BN_new();
2896                 rsa_tmp = RSA_new();
2897                 if(!bn || !rsa_tmp || !BN_set_word(bn, RSA_F4))
2898                         {
2899                         BIO_printf(bio_err, "Memory error...");
2900                         goto end;
2901                         }
2902                 BIO_printf(bio_err,"Generating temp (%d bit) RSA key...",keylength);
2903                 (void)BIO_flush(bio_err);
2904                 if(!RSA_generate_key_ex(rsa_tmp,keylength,bn,NULL))
2905                         {
2906                         BIO_printf(bio_err, "Error generating key.");
2907                         RSA_free(rsa_tmp);
2908                         rsa_tmp = NULL;
2909                         }
2910 end:
2911                 BIO_printf(bio_err,"\n");
2912                 (void)BIO_flush(bio_err);
2913                 }
2914         if(bn) BN_free(bn);
2915         return(rsa_tmp);
2916         }
2917
2918 static void free_tmp_rsa(void)
2919         {
2920         if (rsa_tmp != NULL)
2921                 {
2922                 RSA_free(rsa_tmp);
2923                 rsa_tmp = NULL;
2924                 }
2925         }
2926 #endif
2927
2928 #ifndef OPENSSL_NO_DH
2929 /*-
2930  * These DH parameters have been generated as follows:
2931  *    $ openssl dhparam -C -noout 512
2932  *    $ openssl dhparam -C -noout 1024
2933  *    $ openssl dhparam -C -noout -dsaparam 1024
2934  * (The third function has been renamed to avoid name conflicts.)
2935  */
2936 static DH *get_dh512()
2937         {
2938         static unsigned char dh512_p[]={
2939                 0xCB,0xC8,0xE1,0x86,0xD0,0x1F,0x94,0x17,0xA6,0x99,0xF0,0xC6,
2940                 0x1F,0x0D,0xAC,0xB6,0x25,0x3E,0x06,0x39,0xCA,0x72,0x04,0xB0,
2941                 0x6E,0xDA,0xC0,0x61,0xE6,0x7A,0x77,0x25,0xE8,0x3B,0xB9,0x5F,
2942                 0x9A,0xB6,0xB5,0xFE,0x99,0x0B,0xA1,0x93,0x4E,0x35,0x33,0xB8,
2943                 0xE1,0xF1,0x13,0x4F,0x59,0x1A,0xD2,0x57,0xC0,0x26,0x21,0x33,
2944                 0x02,0xC5,0xAE,0x23,
2945                 };
2946         static unsigned char dh512_g[]={
2947                 0x02,
2948                 };
2949         DH *dh;
2950
2951         if ((dh=DH_new()) == NULL) return(NULL);
2952         dh->p=BN_bin2bn(dh512_p,sizeof(dh512_p),NULL);
2953         dh->g=BN_bin2bn(dh512_g,sizeof(dh512_g),NULL);
2954         if ((dh->p == NULL) || (dh->g == NULL))
2955                 { DH_free(dh); return(NULL); }
2956         return(dh);
2957         }
2958
2959 static DH *get_dh1024()
2960         {
2961         static unsigned char dh1024_p[]={
2962                 0xF8,0x81,0x89,0x7D,0x14,0x24,0xC5,0xD1,0xE6,0xF7,0xBF,0x3A,
2963                 0xE4,0x90,0xF4,0xFC,0x73,0xFB,0x34,0xB5,0xFA,0x4C,0x56,0xA2,
2964                 0xEA,0xA7,0xE9,0xC0,0xC0,0xCE,0x89,0xE1,0xFA,0x63,0x3F,0xB0,
2965                 0x6B,0x32,0x66,0xF1,0xD1,0x7B,0xB0,0x00,0x8F,0xCA,0x87,0xC2,
2966                 0xAE,0x98,0x89,0x26,0x17,0xC2,0x05,0xD2,0xEC,0x08,0xD0,0x8C,
2967                 0xFF,0x17,0x52,0x8C,0xC5,0x07,0x93,0x03,0xB1,0xF6,0x2F,0xB8,
2968                 0x1C,0x52,0x47,0x27,0x1B,0xDB,0xD1,0x8D,0x9D,0x69,0x1D,0x52,
2969                 0x4B,0x32,0x81,0xAA,0x7F,0x00,0xC8,0xDC,0xE6,0xD9,0xCC,0xC1,
2970                 0x11,0x2D,0x37,0x34,0x6C,0xEA,0x02,0x97,0x4B,0x0E,0xBB,0xB1,
2971                 0x71,0x33,0x09,0x15,0xFD,0xDD,0x23,0x87,0x07,0x5E,0x89,0xAB,
2972                 0x6B,0x7C,0x5F,0xEC,0xA6,0x24,0xDC,0x53,
2973                 };
2974         static unsigned char dh1024_g[]={
2975                 0x02,
2976                 };
2977         DH *dh;
2978
2979         if ((dh=DH_new()) == NULL) return(NULL);
2980         dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
2981         dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
2982         if ((dh->p == NULL) || (dh->g == NULL))
2983                 { DH_free(dh); return(NULL); }
2984         return(dh);
2985         }
2986
2987 static DH *get_dh1024dsa()
2988         {
2989         static unsigned char dh1024_p[]={
2990                 0xC8,0x00,0xF7,0x08,0x07,0x89,0x4D,0x90,0x53,0xF3,0xD5,0x00,
2991                 0x21,0x1B,0xF7,0x31,0xA6,0xA2,0xDA,0x23,0x9A,0xC7,0x87,0x19,
2992                 0x3B,0x47,0xB6,0x8C,0x04,0x6F,0xFF,0xC6,0x9B,0xB8,0x65,0xD2,
2993                 0xC2,0x5F,0x31,0x83,0x4A,0xA7,0x5F,0x2F,0x88,0x38,0xB6,0x55,
2994                 0xCF,0xD9,0x87,0x6D,0x6F,0x9F,0xDA,0xAC,0xA6,0x48,0xAF,0xFC,
2995                 0x33,0x84,0x37,0x5B,0x82,0x4A,0x31,0x5D,0xE7,0xBD,0x52,0x97,
2996                 0xA1,0x77,0xBF,0x10,0x9E,0x37,0xEA,0x64,0xFA,0xCA,0x28,0x8D,
2997                 0x9D,0x3B,0xD2,0x6E,0x09,0x5C,0x68,0xC7,0x45,0x90,0xFD,0xBB,
2998                 0x70,0xC9,0x3A,0xBB,0xDF,0xD4,0x21,0x0F,0xC4,0x6A,0x3C,0xF6,
2999                 0x61,0xCF,0x3F,0xD6,0x13,0xF1,0x5F,0xBC,0xCF,0xBC,0x26,0x9E,
3000                 0xBC,0x0B,0xBD,0xAB,0x5D,0xC9,0x54,0x39,
3001                 };
3002         static unsigned char dh1024_g[]={
3003                 0x3B,0x40,0x86,0xE7,0xF3,0x6C,0xDE,0x67,0x1C,0xCC,0x80,0x05,
3004                 0x5A,0xDF,0xFE,0xBD,0x20,0x27,0x74,0x6C,0x24,0xC9,0x03,0xF3,
3005                 0xE1,0x8D,0xC3,0x7D,0x98,0x27,0x40,0x08,0xB8,0x8C,0x6A,0xE9,
3006                 0xBB,0x1A,0x3A,0xD6,0x86,0x83,0x5E,0x72,0x41,0xCE,0x85,0x3C,
3007                 0xD2,0xB3,0xFC,0x13,0xCE,0x37,0x81,0x9E,0x4C,0x1C,0x7B,0x65,
3008                 0xD3,0xE6,0xA6,0x00,0xF5,0x5A,0x95,0x43,0x5E,0x81,0xCF,0x60,
3009                 0xA2,0x23,0xFC,0x36,0xA7,0x5D,0x7A,0x4C,0x06,0x91,0x6E,0xF6,
3010                 0x57,0xEE,0x36,0xCB,0x06,0xEA,0xF5,0x3D,0x95,0x49,0xCB,0xA7,
3011                 0xDD,0x81,0xDF,0x80,0x09,0x4A,0x97,0x4D,0xA8,0x22,0x72,0xA1,
3012                 0x7F,0xC4,0x70,0x56,0x70,0xE8,0x20,0x10,0x18,0x8F,0x2E,0x60,
3013                 0x07,0xE7,0x68,0x1A,0x82,0x5D,0x32,0xA2,
3014                 };
3015         DH *dh;
3016
3017         if ((dh=DH_new()) == NULL) return(NULL);
3018         dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
3019         dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
3020         if ((dh->p == NULL) || (dh->g == NULL))
3021                 { DH_free(dh); return(NULL); }
3022         dh->length = 160;
3023         return(dh);
3024         }
3025 #endif
3026
3027 #ifndef OPENSSL_NO_PSK
3028 /* convert the PSK key (psk_key) in ascii to binary (psk) */
3029 static int psk_key2bn(const char *pskkey, unsigned char *psk,
3030         unsigned int max_psk_len)
3031         {
3032         int ret;
3033         BIGNUM *bn = NULL;
3034
3035         ret = BN_hex2bn(&bn, pskkey);
3036         if (!ret)
3037                 {
3038                 BIO_printf(bio_err,"Could not convert PSK key '%s' to BIGNUM\n", pskkey);
3039                 if (bn)
3040                         BN_free(bn);
3041                 return 0;
3042                 }
3043         if (BN_num_bytes(bn) > (int)max_psk_len)
3044                 {
3045                 BIO_printf(bio_err,"psk buffer of callback is too small (%d) for key (%d)\n",
3046                         max_psk_len, BN_num_bytes(bn));
3047                 BN_free(bn);
3048                 return 0;
3049                 }
3050         ret = BN_bn2bin(bn, psk);
3051         BN_free(bn);
3052         return ret;
3053         }
3054
3055 static unsigned int psk_client_callback(SSL *ssl, const char *hint, char *identity,
3056         unsigned int max_identity_len, unsigned char *psk,
3057         unsigned int max_psk_len)
3058         {
3059         int ret;
3060         unsigned int psk_len = 0;
3061
3062         ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3063         if (ret < 0)
3064                 goto out_err;
3065         if (debug)
3066                 fprintf(stderr, "client: created identity '%s' len=%d\n", identity, ret);
3067         ret = psk_key2bn(psk_key, psk, max_psk_len);
3068         if (ret < 0)
3069                 goto out_err;
3070         psk_len = ret;
3071 out_err:
3072         return psk_len;
3073         }
3074
3075 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3076         unsigned char *psk, unsigned int max_psk_len)
3077         {
3078         unsigned int psk_len=0;
3079
3080         if (strcmp(identity, "Client_identity") != 0)
3081                 {
3082                 BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3083                 return 0;
3084                 }
3085         psk_len=psk_key2bn(psk_key, psk, max_psk_len);
3086         return psk_len;
3087         }
3088 #endif
3089
3090 static int do_test_cipherlist(void)
3091         {
3092         int i = 0;
3093         const SSL_METHOD *meth;
3094         const SSL_CIPHER *ci, *tci = NULL;
3095
3096 #ifndef OPENSSL_NO_SSL2
3097         fprintf(stderr, "testing SSLv2 cipher list order: ");
3098         meth = SSLv2_method();
3099         while ((ci = meth->get_cipher(i++)) != NULL)
3100                 {
3101                 if (tci != NULL)
3102                         if (ci->id >= tci->id)
3103                                 {
3104                                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3105                                 return 0;
3106                                 }
3107                 tci = ci;
3108                 }
3109         fprintf(stderr, "ok\n");
3110 #endif
3111 #ifndef OPENSSL_NO_SSL3
3112         fprintf(stderr, "testing SSLv3 cipher list order: ");
3113         meth = SSLv3_method();
3114         tci = NULL;
3115         while ((ci = meth->get_cipher(i++)) != NULL)
3116                 {
3117                 if (tci != NULL)
3118                         if (ci->id >= tci->id)
3119                                 {
3120                                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3121                                 return 0;
3122                                 }
3123                 tci = ci;
3124                 }
3125         fprintf(stderr, "ok\n");
3126 #endif
3127 #ifndef OPENSSL_NO_TLS1
3128         fprintf(stderr, "testing TLSv1 cipher list order: ");
3129         meth = TLSv1_method();
3130         tci = NULL;
3131         while ((ci = meth->get_cipher(i++)) != NULL)
3132                 {
3133                 if (tci != NULL)
3134                         if (ci->id >= tci->id)
3135                                 {
3136                                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3137                                 return 0;
3138                                 }
3139                 tci = ci;
3140                 }
3141         fprintf(stderr, "ok\n");
3142 #endif
3143
3144         return 1;
3145         }