ssl/ssltest.c

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