ssl/ssltest.c

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