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