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         char *cbuf=NULL,*sbuf=NULL;
2180         long bufsiz;
2181         long cw_num=count,cr_num=count;
2182         long sw_num=count,sr_num=count;
2183         int ret=1;
2184         BIO *c_to_s=NULL;
2185         BIO *s_to_c=NULL;
2186         BIO *c_bio=NULL;
2187         BIO *s_bio=NULL;
2188         int c_r,c_w,s_r,s_w;
2189         int i,j;
2190         int done=0;
2191         int c_write,s_write;
2192         int do_server=0,do_client=0;
2193         int max_frag = 5*1024;
2194
2195         bufsiz = count>40*1024 ? 40*1024 : count;
2196
2197         if ((cbuf = OPENSSL_malloc(bufsiz))==NULL) goto err;
2198         if ((sbuf = OPENSSL_malloc(bufsiz))==NULL) goto err;
2199
2200         memset(cbuf,0,bufsiz);
2201         memset(sbuf,0,bufsiz);
2202
2203         c_to_s=BIO_new(BIO_s_mem());
2204         s_to_c=BIO_new(BIO_s_mem());
2205         if ((s_to_c == NULL) || (c_to_s == NULL))
2206                 {
2207                 ERR_print_errors(bio_err);
2208                 goto err;
2209                 }
2210
2211         c_bio=BIO_new(BIO_f_ssl());
2212         s_bio=BIO_new(BIO_f_ssl());
2213         if ((c_bio == NULL) || (s_bio == NULL))
2214                 {
2215                 ERR_print_errors(bio_err);
2216                 goto err;
2217                 }
2218
2219         SSL_set_connect_state(c_ssl);
2220         SSL_set_bio(c_ssl,s_to_c,c_to_s);
2221         SSL_set_max_send_fragment(c_ssl,max_frag);
2222         BIO_set_ssl(c_bio,c_ssl,BIO_NOCLOSE);
2223
2224         SSL_set_accept_state(s_ssl);
2225         SSL_set_bio(s_ssl,c_to_s,s_to_c);
2226         SSL_set_max_send_fragment(s_ssl,max_frag);
2227         BIO_set_ssl(s_bio,s_ssl,BIO_NOCLOSE);
2228
2229         c_r=0; s_r=1;
2230         c_w=1; s_w=0;
2231         c_write=1,s_write=0;
2232
2233         /* We can always do writes */
2234         for (;;)
2235                 {
2236                 do_server=0;
2237                 do_client=0;
2238
2239                 i=(int)BIO_pending(s_bio);
2240                 if ((i && s_r) || s_w) do_server=1;
2241
2242                 i=(int)BIO_pending(c_bio);
2243                 if ((i && c_r) || c_w) do_client=1;
2244
2245                 if (do_server && debug)
2246                         {
2247                         if (SSL_in_init(s_ssl))
2248                                 printf("server waiting in SSL_accept - %s\n",
2249                                         SSL_state_string_long(s_ssl));
2250 /*                      else if (s_write)
2251                                 printf("server:SSL_write()\n");
2252                         else
2253                                 printf("server:SSL_read()\n"); */
2254                         }
2255
2256                 if (do_client && debug)
2257                         {
2258                         if (SSL_in_init(c_ssl))
2259                                 printf("client waiting in SSL_connect - %s\n",
2260                                         SSL_state_string_long(c_ssl));
2261 /*                      else if (c_write)
2262                                 printf("client:SSL_write()\n");
2263                         else
2264                                 printf("client:SSL_read()\n"); */
2265                         }
2266
2267                 if (!do_client && !do_server)
2268                         {
2269                         fprintf(stdout,"ERROR IN STARTUP\n");
2270                         ERR_print_errors(bio_err);
2271                         break;
2272                         }
2273                 if (do_client && !(done & C_DONE))
2274                         {
2275                         if (c_write)
2276                                 {
2277                                 j = (cw_num > bufsiz) ?
2278                                         (int)bufsiz : (int)cw_num;
2279                                 i=BIO_write(c_bio,cbuf,j);
2280                                 if (i < 0)
2281                                         {
2282                                         c_r=0;
2283                                         c_w=0;
2284                                         if (BIO_should_retry(c_bio))
2285                                                 {
2286                                                 if (BIO_should_read(c_bio))
2287                                                         c_r=1;
2288                                                 if (BIO_should_write(c_bio))
2289                                                         c_w=1;
2290                                                 }
2291                                         else
2292                                                 {
2293                                                 fprintf(stderr,"ERROR in CLIENT\n");
2294                                                 ERR_print_errors(bio_err);
2295                                                 goto err;
2296                                                 }
2297                                         }
2298                                 else if (i == 0)
2299                                         {
2300                                         fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
2301                                         goto err;
2302                                         }
2303                                 else
2304                                         {
2305                                         if (debug)
2306                                                 printf("client wrote %d\n",i);
2307                                         /* ok */
2308                                         s_r=1;
2309                                         c_write=0;
2310                                         cw_num-=i;
2311                                         if (max_frag>1029)
2312                                                 SSL_set_max_send_fragment(c_ssl,max_frag-=5);
2313                                         }
2314                                 }
2315                         else
2316                                 {
2317                                 i=BIO_read(c_bio,cbuf,bufsiz);
2318                                 if (i < 0)
2319                                         {
2320                                         c_r=0;
2321                                         c_w=0;
2322                                         if (BIO_should_retry(c_bio))
2323                                                 {
2324                                                 if (BIO_should_read(c_bio))
2325                                                         c_r=1;
2326                                                 if (BIO_should_write(c_bio))
2327                                                         c_w=1;
2328                                                 }
2329                                         else
2330                                                 {
2331                                                 fprintf(stderr,"ERROR in CLIENT\n");
2332                                                 ERR_print_errors(bio_err);
2333                                                 goto err;
2334                                                 }
2335                                         }
2336                                 else if (i == 0)
2337                                         {
2338                                         fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
2339                                         goto err;
2340                                         }
2341                                 else
2342                                         {
2343                                         if (debug)
2344                                                 printf("client read %d\n",i);
2345                                         cr_num-=i;
2346                                         if (sw_num > 0)
2347                                                 {
2348                                                 s_write=1;
2349                                                 s_w=1;
2350                                                 }
2351                                         if (cr_num <= 0)
2352                                                 {
2353                                                 s_write=1;
2354                                                 s_w=1;
2355                                                 done=S_DONE|C_DONE;
2356                                                 }
2357                                         }
2358                                 }
2359                         }
2360
2361                 if (do_server && !(done & S_DONE))
2362                         {
2363                         if (!s_write)
2364                                 {
2365                                 i=BIO_read(s_bio,sbuf,bufsiz);
2366                                 if (i < 0)
2367                                         {
2368                                         s_r=0;
2369                                         s_w=0;
2370                                         if (BIO_should_retry(s_bio))
2371                                                 {
2372                                                 if (BIO_should_read(s_bio))
2373                                                         s_r=1;
2374                                                 if (BIO_should_write(s_bio))
2375                                                         s_w=1;
2376                                                 }
2377                                         else
2378                                                 {
2379                                                 fprintf(stderr,"ERROR in SERVER\n");
2380                                                 ERR_print_errors(bio_err);
2381                                                 goto err;
2382                                                 }
2383                                         }
2384                                 else if (i == 0)
2385                                         {
2386                                         ERR_print_errors(bio_err);
2387                                         fprintf(stderr,"SSL SERVER STARTUP FAILED in SSL_read\n");
2388                                         goto err;
2389                                         }
2390                                 else
2391                                         {
2392                                         if (debug)
2393                                                 printf("server read %d\n",i);
2394                                         sr_num-=i;
2395                                         if (cw_num > 0)
2396                                                 {
2397                                                 c_write=1;
2398                                                 c_w=1;
2399                                                 }
2400                                         if (sr_num <= 0)
2401                                                 {
2402                                                 s_write=1;
2403                                                 s_w=1;
2404                                                 c_write=0;
2405                                                 }
2406                                         }
2407                                 }
2408                         else
2409                                 {
2410                                 j = (sw_num > bufsiz) ?
2411                                         (int)bufsiz : (int)sw_num;
2412                                 i=BIO_write(s_bio,sbuf,j);
2413                                 if (i < 0)
2414                                         {
2415                                         s_r=0;
2416                                         s_w=0;
2417                                         if (BIO_should_retry(s_bio))
2418                                                 {
2419                                                 if (BIO_should_read(s_bio))
2420                                                         s_r=1;
2421                                                 if (BIO_should_write(s_bio))
2422                                                         s_w=1;
2423                                                 }
2424                                         else
2425                                                 {
2426                                                 fprintf(stderr,"ERROR in SERVER\n");
2427                                                 ERR_print_errors(bio_err);
2428                                                 goto err;
2429                                                 }
2430                                         }
2431                                 else if (i == 0)
2432                                         {
2433                                         ERR_print_errors(bio_err);
2434                                         fprintf(stderr,"SSL SERVER STARTUP FAILED in SSL_write\n");
2435                                         goto err;
2436                                         }
2437                                 else
2438                                         {
2439                                         if (debug)
2440                                                 printf("server wrote %d\n",i);
2441                                         sw_num-=i;
2442                                         s_write=0;
2443                                         c_r=1;
2444                                         if (sw_num <= 0)
2445                                                 done|=S_DONE;
2446                                         if (max_frag>1029)
2447                                                 SSL_set_max_send_fragment(s_ssl,max_frag-=5);
2448                                         }
2449                                 }
2450                         }
2451
2452                 if ((done & S_DONE) && (done & C_DONE)) break;
2453                 }
2454
2455         if (verbose)
2456                 print_details(c_ssl, "DONE: ");
2457         if (suppdata_error < 0)
2458                 {
2459                 ret = 1;
2460                 goto err;
2461                 }
2462         if (verify_serverinfo() < 0)
2463                 {
2464                 ret = 1;
2465                 goto err;
2466                 }
2467         if (custom_ext_error)
2468                 {
2469                 ret = 1;
2470                 goto err;
2471                 }
2472         ret=0;
2473 err:
2474         /* We have to set the BIO's to NULL otherwise they will be
2475          * OPENSSL_free()ed twice.  Once when th s_ssl is SSL_free()ed and
2476          * again when c_ssl is SSL_free()ed.
2477          * This is a hack required because s_ssl and c_ssl are sharing the same
2478          * BIO structure and SSL_set_bio() and SSL_free() automatically
2479          * BIO_free non NULL entries.
2480          * You should not normally do this or be required to do this */
2481         if (s_ssl != NULL)
2482                 {
2483                 s_ssl->rbio=NULL;
2484                 s_ssl->wbio=NULL;
2485                 }
2486         if (c_ssl != NULL)
2487                 {
2488                 c_ssl->rbio=NULL;
2489                 c_ssl->wbio=NULL;
2490                 }
2491
2492         if (c_to_s != NULL) BIO_free(c_to_s);
2493         if (s_to_c != NULL) BIO_free(s_to_c);
2494         if (c_bio != NULL) BIO_free_all(c_bio);
2495         if (s_bio != NULL) BIO_free_all(s_bio);
2496
2497         if (cbuf) OPENSSL_free(cbuf);
2498         if (sbuf) OPENSSL_free(sbuf);
2499
2500         return(ret);
2501         }
2502
2503 static int get_proxy_auth_ex_data_idx(void)
2504         {
2505         static volatile int idx = -1;
2506         if (idx < 0)
2507                 {
2508                 CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
2509                 if (idx < 0)
2510                         {
2511                         idx = X509_STORE_CTX_get_ex_new_index(0,
2512                                 "SSLtest for verify callback", NULL,NULL,NULL);
2513                         }
2514                 CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
2515                 }
2516         return idx;
2517         }
2518
2519 static int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx)
2520         {
2521         char *s,buf[256];
2522
2523         s=X509_NAME_oneline(X509_get_subject_name(ctx->current_cert),buf,
2524                             sizeof buf);
2525         if (s != NULL)
2526                 {
2527                 if (ok)
2528                         fprintf(stderr,"depth=%d %s\n",
2529                                 ctx->error_depth,buf);
2530                 else
2531                         {
2532                         fprintf(stderr,"depth=%d error=%d %s\n",
2533                                 ctx->error_depth,ctx->error,buf);
2534                         }
2535                 }
2536
2537         if (ok == 0)
2538                 {
2539                 fprintf(stderr,"Error string: %s\n",
2540                         X509_verify_cert_error_string(ctx->error));
2541                 switch (ctx->error)
2542                         {
2543                 case X509_V_ERR_CERT_NOT_YET_VALID:
2544                 case X509_V_ERR_CERT_HAS_EXPIRED:
2545                 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2546                         fprintf(stderr,"  ... ignored.\n");
2547                         ok=1;
2548                         }
2549                 }
2550
2551         if (ok == 1)
2552                 {
2553                 X509 *xs = ctx->current_cert;
2554 #if 0
2555                 X509 *xi = ctx->current_issuer;
2556 #endif
2557
2558                 if (xs->ex_flags & EXFLAG_PROXY)
2559                         {
2560                         unsigned int *letters =
2561                                 X509_STORE_CTX_get_ex_data(ctx,
2562                                         get_proxy_auth_ex_data_idx());
2563
2564                         if (letters)
2565                                 {
2566                                 int found_any = 0;
2567                                 int i;
2568                                 PROXY_CERT_INFO_EXTENSION *pci =
2569                                         X509_get_ext_d2i(xs, NID_proxyCertInfo,
2570                                                 NULL, NULL);
2571
2572                                 switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage))
2573                                         {
2574                                 case NID_Independent:
2575                                         /* Completely meaningless in this
2576                                            program, as there's no way to
2577                                            grant explicit rights to a
2578                                            specific PrC.  Basically, using
2579                                            id-ppl-Independent is the perfect
2580                                            way to grant no rights at all. */
2581                                         fprintf(stderr, "  Independent proxy certificate");
2582                                         for (i = 0; i < 26; i++)
2583                                                 letters[i] = 0;
2584                                         break;
2585                                 case NID_id_ppl_inheritAll:
2586                                         /* This is basically a NOP, we
2587                                            simply let the current rights
2588                                            stand as they are. */
2589                                         fprintf(stderr, "  Proxy certificate inherits all");
2590                                         break;
2591                                 default:
2592                                         s = (char *)
2593                                                 pci->proxyPolicy->policy->data;
2594                                         i = pci->proxyPolicy->policy->length;
2595
2596                                         /* The algorithm works as follows:
2597                                            it is assumed that previous
2598                                            iterations or the initial granted
2599                                            rights has already set some elements
2600                                            of `letters'.  What we need to do is
2601                                            to clear those that weren't granted
2602                                            by the current PrC as well.  The
2603                                            easiest way to do this is to add 1
2604                                            to all the elements whose letters
2605                                            are given with the current policy.
2606                                            That way, all elements that are set
2607                                            by the current policy and were
2608                                            already set by earlier policies and
2609                                            through the original grant of rights
2610                                            will get the value 2 or higher.
2611                                            The last thing to do is to sweep
2612                                            through `letters' and keep the
2613                                            elements having the value 2 as set,
2614                                            and clear all the others. */
2615
2616                                         fprintf(stderr, "  Certificate proxy rights = %*.*s", i, i, s);
2617                                         while(i-- > 0)
2618                                                 {
2619                                                 int c = *s++;
2620                                                 if (isascii(c) && isalpha(c))
2621                                                         {
2622                                                         if (islower(c))
2623                                                                 c = toupper(c);
2624                                                         letters[c - 'A']++;
2625                                                         }
2626                                                 }
2627                                         for (i = 0; i < 26; i++)
2628                                                 if (letters[i] < 2)
2629                                                         letters[i] = 0;
2630                                                 else
2631                                                         letters[i] = 1;
2632                                         }
2633
2634                                 found_any = 0;
2635                                 fprintf(stderr,
2636                                         ", resulting proxy rights = ");
2637                                 for(i = 0; i < 26; i++)
2638                                         if (letters[i])
2639                                                 {
2640                                                 fprintf(stderr, "%c", i + 'A');
2641                                                 found_any = 1;
2642                                                 }
2643                                 if (!found_any)
2644                                         fprintf(stderr, "none");
2645                                 fprintf(stderr, "\n");
2646
2647                                 PROXY_CERT_INFO_EXTENSION_free(pci);
2648                                 }
2649                         }
2650                 }
2651
2652         return(ok);
2653         }
2654
2655 static void process_proxy_debug(int indent, const char *format, ...)
2656         {
2657         static const char indentation[] =
2658                 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
2659                 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"; /* That's 80 > */
2660         char my_format[256];
2661         va_list args;
2662
2663         BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
2664                 indent, indent, indentation, format);
2665
2666         va_start(args, format);
2667         vfprintf(stderr, my_format, args);
2668         va_end(args);
2669         }
2670 /* Priority levels:
2671    0    [!]var, ()
2672    1    & ^
2673    2    |
2674 */
2675 static int process_proxy_cond_adders(unsigned int letters[26],
2676         const char *cond, const char **cond_end, int *pos, int indent);
2677 static int process_proxy_cond_val(unsigned int letters[26],
2678         const char *cond, const char **cond_end, int *pos, int indent)
2679         {
2680         int c;
2681         int ok = 1;
2682         int negate = 0;
2683
2684         while(isspace((int)*cond))
2685                 {
2686                 cond++; (*pos)++;
2687                 }
2688         c = *cond;
2689
2690         if (debug)
2691                 process_proxy_debug(indent,
2692                         "Start process_proxy_cond_val at position %d: %s\n",
2693                         *pos, cond);
2694
2695         while(c == '!')
2696                 {
2697                 negate = !negate;
2698                 cond++; (*pos)++;
2699                 while(isspace((int)*cond))
2700                         {
2701                         cond++; (*pos)++;
2702                         }
2703                 c = *cond;
2704                 }
2705
2706         if (c == '(')
2707                 {
2708                 cond++; (*pos)++;
2709                 ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
2710                         indent + 1);
2711                 cond = *cond_end;
2712                 if (ok < 0)
2713                         goto end;
2714                 while(isspace((int)*cond))
2715                         {
2716                         cond++; (*pos)++;
2717                         }
2718                 c = *cond;
2719                 if (c != ')')
2720                         {
2721                         fprintf(stderr,
2722                                 "Weird condition character in position %d: "
2723                                 "%c\n", *pos, c);
2724                         ok = -1;
2725                         goto end;
2726                         }
2727                 cond++; (*pos)++;
2728                 }
2729         else if (isascii(c) && isalpha(c))
2730                 {
2731                 if (islower(c))
2732                         c = toupper(c);
2733                 ok = letters[c - 'A'];
2734                 cond++; (*pos)++;
2735                 }
2736         else
2737                 {
2738                 fprintf(stderr,
2739                         "Weird condition character in position %d: "
2740                         "%c\n", *pos, c);
2741                 ok = -1;
2742                 goto end;
2743                 }
2744  end:
2745         *cond_end = cond;
2746         if (ok >= 0 && negate)
2747                 ok = !ok;
2748
2749         if (debug)
2750                 process_proxy_debug(indent,
2751                         "End process_proxy_cond_val at position %d: %s, returning %d\n",
2752                         *pos, cond, ok);
2753
2754         return ok;
2755         }
2756 static int process_proxy_cond_multipliers(unsigned int letters[26],
2757         const char *cond, const char **cond_end, int *pos, int indent)
2758         {
2759         int ok;
2760         char c;
2761
2762         if (debug)
2763                 process_proxy_debug(indent,
2764                         "Start process_proxy_cond_multipliers at position %d: %s\n",
2765                         *pos, cond);
2766
2767         ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
2768         cond = *cond_end;
2769         if (ok < 0)
2770                 goto end;
2771
2772         while(ok >= 0)
2773                 {
2774                 while(isspace((int)*cond))
2775                         {
2776                         cond++; (*pos)++;
2777                         }
2778                 c = *cond;
2779
2780                 switch(c)
2781                         {
2782                 case '&':
2783                 case '^':
2784                         {
2785                         int save_ok = ok;
2786
2787                         cond++; (*pos)++;
2788                         ok = process_proxy_cond_val(letters,
2789                                 cond, cond_end, pos, indent + 1);
2790                         cond = *cond_end;
2791                         if (ok < 0)
2792                                 break;
2793
2794                         switch(c)
2795                                 {
2796                         case '&':
2797                                 ok &= save_ok;
2798                                 break;
2799                         case '^':
2800                                 ok ^= save_ok;
2801                                 break;
2802                         default:
2803                                 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2804                                         " STOPPING\n");
2805                                 EXIT(1);
2806                                 }
2807                         }
2808                         break;
2809                 default:
2810                         goto end;
2811                         }
2812                 }
2813  end:
2814         if (debug)
2815                 process_proxy_debug(indent,
2816                         "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
2817                         *pos, cond, ok);
2818
2819         *cond_end = cond;
2820         return ok;
2821         }
2822 static int process_proxy_cond_adders(unsigned int letters[26],
2823         const char *cond, const char **cond_end, int *pos, int indent)
2824         {
2825         int ok;
2826         char c;
2827
2828         if (debug)
2829                 process_proxy_debug(indent,
2830                         "Start process_proxy_cond_adders at position %d: %s\n",
2831                         *pos, cond);
2832
2833         ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
2834                 indent + 1);
2835         cond = *cond_end;
2836         if (ok < 0)
2837                 goto end;
2838
2839         while(ok >= 0)
2840                 {
2841                 while(isspace((int)*cond))
2842                         {
2843                         cond++; (*pos)++;
2844                         }
2845                 c = *cond;
2846
2847                 switch(c)
2848                         {
2849                 case '|':
2850                         {
2851                         int save_ok = ok;
2852
2853                         cond++; (*pos)++;
2854                         ok = process_proxy_cond_multipliers(letters,
2855                                 cond, cond_end, pos, indent + 1);
2856                         cond = *cond_end;
2857                         if (ok < 0)
2858                                 break;
2859
2860                         switch(c)
2861                                 {
2862                         case '|':
2863                                 ok |= save_ok;
2864                                 break;
2865                         default:
2866                                 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2867                                         " STOPPING\n");
2868                                 EXIT(1);
2869                                 }
2870                         }
2871                         break;
2872                 default:
2873                         goto end;
2874                         }
2875                 }
2876  end:
2877         if (debug)
2878                 process_proxy_debug(indent,
2879                         "End process_proxy_cond_adders at position %d: %s, returning %d\n",
2880                         *pos, cond, ok);
2881
2882         *cond_end = cond;
2883         return ok;
2884         }
2885
2886 static int process_proxy_cond(unsigned int letters[26],
2887         const char *cond, const char **cond_end)
2888         {
2889         int pos = 1;
2890         return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
2891         }
2892
2893 static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2894         {
2895         int ok=1;
2896         struct app_verify_arg *cb_arg = arg;
2897         unsigned int letters[26]; /* only used with proxy_auth */
2898
2899         if (cb_arg->app_verify)
2900                 {
2901                 char *s = NULL,buf[256];
2902
2903                 fprintf(stderr, "In app_verify_callback, allowing cert. ");
2904                 fprintf(stderr, "Arg is: %s\n", cb_arg->string);
2905                 fprintf(stderr, "Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2906                         (void *)ctx, (void *)ctx->cert);
2907                 if (ctx->cert)
2908                         s=X509_NAME_oneline(X509_get_subject_name(ctx->cert),buf,256);
2909                 if (s != NULL)
2910                         {
2911                         fprintf(stderr,"cert depth=%d %s\n",ctx->error_depth,buf);
2912                         }
2913                 return(1);
2914                 }
2915         if (cb_arg->proxy_auth)
2916                 {
2917                 int found_any = 0, i;
2918                 char *sp;
2919
2920                 for(i = 0; i < 26; i++)
2921                         letters[i] = 0;
2922                 for(sp = cb_arg->proxy_auth; *sp; sp++)
2923                         {
2924                         int c = *sp;
2925                         if (isascii(c) && isalpha(c))
2926                                 {
2927                                 if (islower(c))
2928                                         c = toupper(c);
2929                                 letters[c - 'A'] = 1;
2930                                 }
2931                         }
2932
2933                 fprintf(stderr,
2934                         "  Initial proxy rights = ");
2935                 for(i = 0; i < 26; i++)
2936                         if (letters[i])
2937                                 {
2938                                 fprintf(stderr, "%c", i + 'A');
2939                                 found_any = 1;
2940                                 }
2941                 if (!found_any)
2942                         fprintf(stderr, "none");
2943                 fprintf(stderr, "\n");
2944
2945                 X509_STORE_CTX_set_ex_data(ctx,
2946                         get_proxy_auth_ex_data_idx(),letters);
2947                 }
2948         if (cb_arg->allow_proxy_certs)
2949                 {
2950                 X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
2951                 }
2952
2953 #ifndef OPENSSL_NO_X509_VERIFY
2954         ok = X509_verify_cert(ctx);
2955 #endif
2956
2957         if (cb_arg->proxy_auth)
2958                 {
2959                 if (ok > 0)
2960                         {
2961                         const char *cond_end = NULL;
2962
2963                         ok = process_proxy_cond(letters,
2964                                 cb_arg->proxy_cond, &cond_end);
2965
2966                         if (ok < 0)
2967                                 EXIT(3);
2968                         if (*cond_end)
2969                                 {
2970                                 fprintf(stderr, "Stopped processing condition before it's end.\n");
2971                                 ok = 0;
2972                                 }
2973                         if (!ok)
2974                                 fprintf(stderr, "Proxy rights check with condition '%s' proved invalid\n",
2975                                         cb_arg->proxy_cond);
2976                         else
2977                                 fprintf(stderr, "Proxy rights check with condition '%s' proved valid\n",
2978                                         cb_arg->proxy_cond);
2979                         }
2980                 }
2981         return(ok);
2982         }
2983
2984 #ifndef OPENSSL_NO_RSA
2985 static RSA *rsa_tmp=NULL;
2986
2987 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
2988         {
2989         BIGNUM *bn = NULL;
2990         if (rsa_tmp == NULL)
2991                 {
2992                 bn = BN_new();
2993                 rsa_tmp = RSA_new();
2994                 if(!bn || !rsa_tmp || !BN_set_word(bn, RSA_F4))
2995                         {
2996                         BIO_printf(bio_err, "Memory error...");
2997                         goto end;
2998                         }
2999                 BIO_printf(bio_err,"Generating temp (%d bit) RSA key...",keylength);
3000                 (void)BIO_flush(bio_err);
3001                 if(!RSA_generate_key_ex(rsa_tmp,keylength,bn,NULL))
3002                         {
3003                         BIO_printf(bio_err, "Error generating key.");
3004                         RSA_free(rsa_tmp);
3005                         rsa_tmp = NULL;
3006                         }
3007 end:
3008                 BIO_printf(bio_err,"\n");
3009                 (void)BIO_flush(bio_err);
3010                 }
3011         if(bn) BN_free(bn);
3012         return(rsa_tmp);
3013         }
3014
3015 static void free_tmp_rsa(void)
3016         {
3017         if (rsa_tmp != NULL)
3018                 {
3019                 RSA_free(rsa_tmp);
3020                 rsa_tmp = NULL;
3021                 }
3022         }
3023 #endif
3024
3025 #ifndef OPENSSL_NO_DH
3026 /* These DH parameters have been generated as follows:
3027  *    $ openssl dhparam -C -noout 512
3028  *    $ openssl dhparam -C -noout 1024
3029  *    $ openssl dhparam -C -noout -dsaparam 1024
3030  * (The third function has been renamed to avoid name conflicts.)
3031  */
3032 static DH *get_dh512()
3033         {
3034         static unsigned char dh512_p[]={
3035                 0xCB,0xC8,0xE1,0x86,0xD0,0x1F,0x94,0x17,0xA6,0x99,0xF0,0xC6,
3036                 0x1F,0x0D,0xAC,0xB6,0x25,0x3E,0x06,0x39,0xCA,0x72,0x04,0xB0,
3037                 0x6E,0xDA,0xC0,0x61,0xE6,0x7A,0x77,0x25,0xE8,0x3B,0xB9,0x5F,
3038                 0x9A,0xB6,0xB5,0xFE,0x99,0x0B,0xA1,0x93,0x4E,0x35,0x33,0xB8,
3039                 0xE1,0xF1,0x13,0x4F,0x59,0x1A,0xD2,0x57,0xC0,0x26,0x21,0x33,
3040                 0x02,0xC5,0xAE,0x23,
3041                 };
3042         static unsigned char dh512_g[]={
3043                 0x02,
3044                 };
3045         DH *dh;
3046
3047         if ((dh=DH_new()) == NULL) return(NULL);
3048         dh->p=BN_bin2bn(dh512_p,sizeof(dh512_p),NULL);
3049         dh->g=BN_bin2bn(dh512_g,sizeof(dh512_g),NULL);
3050         if ((dh->p == NULL) || (dh->g == NULL))
3051                 { DH_free(dh); return(NULL); }
3052         return(dh);
3053         }
3054
3055 static DH *get_dh1024()
3056         {
3057         static unsigned char dh1024_p[]={
3058                 0xF8,0x81,0x89,0x7D,0x14,0x24,0xC5,0xD1,0xE6,0xF7,0xBF,0x3A,
3059                 0xE4,0x90,0xF4,0xFC,0x73,0xFB,0x34,0xB5,0xFA,0x4C,0x56,0xA2,
3060                 0xEA,0xA7,0xE9,0xC0,0xC0,0xCE,0x89,0xE1,0xFA,0x63,0x3F,0xB0,
3061                 0x6B,0x32,0x66,0xF1,0xD1,0x7B,0xB0,0x00,0x8F,0xCA,0x87,0xC2,
3062                 0xAE,0x98,0x89,0x26,0x17,0xC2,0x05,0xD2,0xEC,0x08,0xD0,0x8C,
3063                 0xFF,0x17,0x52,0x8C,0xC5,0x07,0x93,0x03,0xB1,0xF6,0x2F,0xB8,
3064                 0x1C,0x52,0x47,0x27,0x1B,0xDB,0xD1,0x8D,0x9D,0x69,0x1D,0x52,
3065                 0x4B,0x32,0x81,0xAA,0x7F,0x00,0xC8,0xDC,0xE6,0xD9,0xCC,0xC1,
3066                 0x11,0x2D,0x37,0x34,0x6C,0xEA,0x02,0x97,0x4B,0x0E,0xBB,0xB1,
3067                 0x71,0x33,0x09,0x15,0xFD,0xDD,0x23,0x87,0x07,0x5E,0x89,0xAB,
3068                 0x6B,0x7C,0x5F,0xEC,0xA6,0x24,0xDC,0x53,
3069                 };
3070         static unsigned char dh1024_g[]={
3071                 0x02,
3072                 };
3073         DH *dh;
3074
3075         if ((dh=DH_new()) == NULL) return(NULL);
3076         dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
3077         dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
3078         if ((dh->p == NULL) || (dh->g == NULL))
3079                 { DH_free(dh); return(NULL); }
3080         return(dh);
3081         }
3082
3083 static DH *get_dh1024dsa()
3084         {
3085         static unsigned char dh1024_p[]={
3086                 0xC8,0x00,0xF7,0x08,0x07,0x89,0x4D,0x90,0x53,0xF3,0xD5,0x00,
3087                 0x21,0x1B,0xF7,0x31,0xA6,0xA2,0xDA,0x23,0x9A,0xC7,0x87,0x19,
3088                 0x3B,0x47,0xB6,0x8C,0x04,0x6F,0xFF,0xC6,0x9B,0xB8,0x65,0xD2,
3089                 0xC2,0x5F,0x31,0x83,0x4A,0xA7,0x5F,0x2F,0x88,0x38,0xB6,0x55,
3090                 0xCF,0xD9,0x87,0x6D,0x6F,0x9F,0xDA,0xAC,0xA6,0x48,0xAF,0xFC,
3091                 0x33,0x84,0x37,0x5B,0x82,0x4A,0x31,0x5D,0xE7,0xBD,0x52,0x97,
3092                 0xA1,0x77,0xBF,0x10,0x9E,0x37,0xEA,0x64,0xFA,0xCA,0x28,0x8D,
3093                 0x9D,0x3B,0xD2,0x6E,0x09,0x5C,0x68,0xC7,0x45,0x90,0xFD,0xBB,
3094                 0x70,0xC9,0x3A,0xBB,0xDF,0xD4,0x21,0x0F,0xC4,0x6A,0x3C,0xF6,
3095                 0x61,0xCF,0x3F,0xD6,0x13,0xF1,0x5F,0xBC,0xCF,0xBC,0x26,0x9E,
3096                 0xBC,0x0B,0xBD,0xAB,0x5D,0xC9,0x54,0x39,
3097                 };
3098         static unsigned char dh1024_g[]={
3099                 0x3B,0x40,0x86,0xE7,0xF3,0x6C,0xDE,0x67,0x1C,0xCC,0x80,0x05,
3100                 0x5A,0xDF,0xFE,0xBD,0x20,0x27,0x74,0x6C,0x24,0xC9,0x03,0xF3,
3101                 0xE1,0x8D,0xC3,0x7D,0x98,0x27,0x40,0x08,0xB8,0x8C,0x6A,0xE9,
3102                 0xBB,0x1A,0x3A,0xD6,0x86,0x83,0x5E,0x72,0x41,0xCE,0x85,0x3C,
3103                 0xD2,0xB3,0xFC,0x13,0xCE,0x37,0x81,0x9E,0x4C,0x1C,0x7B,0x65,
3104                 0xD3,0xE6,0xA6,0x00,0xF5,0x5A,0x95,0x43,0x5E,0x81,0xCF,0x60,
3105                 0xA2,0x23,0xFC,0x36,0xA7,0x5D,0x7A,0x4C,0x06,0x91,0x6E,0xF6,
3106                 0x57,0xEE,0x36,0xCB,0x06,0xEA,0xF5,0x3D,0x95,0x49,0xCB,0xA7,
3107                 0xDD,0x81,0xDF,0x80,0x09,0x4A,0x97,0x4D,0xA8,0x22,0x72,0xA1,
3108                 0x7F,0xC4,0x70,0x56,0x70,0xE8,0x20,0x10,0x18,0x8F,0x2E,0x60,
3109                 0x07,0xE7,0x68,0x1A,0x82,0x5D,0x32,0xA2,
3110                 };
3111         DH *dh;
3112
3113         if ((dh=DH_new()) == NULL) return(NULL);
3114         dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
3115         dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
3116         if ((dh->p == NULL) || (dh->g == NULL))
3117                 { DH_free(dh); return(NULL); }
3118         dh->length = 160;
3119         return(dh);
3120         }
3121 #endif
3122
3123 #ifndef OPENSSL_NO_PSK
3124 /* convert the PSK key (psk_key) in ascii to binary (psk) */
3125 static int psk_key2bn(const char *pskkey, unsigned char *psk,
3126         unsigned int max_psk_len)
3127         {
3128         int ret;
3129         BIGNUM *bn = NULL;
3130
3131         ret = BN_hex2bn(&bn, pskkey);
3132         if (!ret)
3133                 {
3134                 BIO_printf(bio_err,"Could not convert PSK key '%s' to BIGNUM\n", pskkey);
3135                 if (bn)
3136                         BN_free(bn);
3137                 return 0;
3138                 }
3139         if (BN_num_bytes(bn) > (int)max_psk_len)
3140                 {
3141                 BIO_printf(bio_err,"psk buffer of callback is too small (%d) for key (%d)\n",
3142                         max_psk_len, BN_num_bytes(bn));
3143                 BN_free(bn);
3144                 return 0;
3145                 }
3146         ret = BN_bn2bin(bn, psk);
3147         BN_free(bn);
3148         return ret;
3149         }
3150
3151 static unsigned int psk_client_callback(SSL *ssl, const char *hint, char *identity,
3152         unsigned int max_identity_len, unsigned char *psk,
3153         unsigned int max_psk_len)
3154         {
3155         int ret;
3156         unsigned int psk_len = 0;
3157
3158         ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3159         if (ret < 0)
3160                 goto out_err;
3161         if (debug)
3162                 fprintf(stderr, "client: created identity '%s' len=%d\n", identity, ret);
3163         ret = psk_key2bn(psk_key, psk, max_psk_len);
3164         if (ret < 0)
3165                 goto out_err;
3166         psk_len = ret;
3167 out_err:
3168         return psk_len;
3169         }
3170
3171 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3172         unsigned char *psk, unsigned int max_psk_len)
3173         {
3174         unsigned int psk_len=0;
3175
3176         if (strcmp(identity, "Client_identity") != 0)
3177                 {
3178                 BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3179                 return 0;
3180                 }
3181         psk_len=psk_key2bn(psk_key, psk, max_psk_len);
3182         return psk_len;
3183         }
3184 #endif
3185
3186 static int do_test_cipherlist(void)
3187         {
3188         int i = 0;
3189         const SSL_METHOD *meth;
3190         const SSL_CIPHER *ci, *tci = NULL;
3191
3192 #ifndef OPENSSL_NO_SSL2
3193         fprintf(stderr, "testing SSLv2 cipher list order: ");
3194         meth = SSLv2_method();
3195         while ((ci = meth->get_cipher(i++)) != NULL)
3196                 {
3197                 if (tci != NULL)
3198                         if (ci->id >= tci->id)
3199                                 {
3200                                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3201                                 return 0;
3202                                 }
3203                 tci = ci;
3204                 }
3205         fprintf(stderr, "ok\n");
3206 #endif
3207 #ifndef OPENSSL_NO_SSL3
3208         fprintf(stderr, "testing SSLv3 cipher list order: ");
3209         meth = SSLv3_method();
3210         tci = NULL;
3211         while ((ci = meth->get_cipher(i++)) != NULL)
3212                 {
3213                 if (tci != NULL)
3214                         if (ci->id >= tci->id)
3215                                 {
3216                                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3217                                 return 0;
3218                                 }
3219                 tci = ci;
3220                 }
3221         fprintf(stderr, "ok\n");
3222 #endif
3223 #ifndef OPENSSL_NO_TLS1
3224         fprintf(stderr, "testing TLSv1 cipher list order: ");
3225         meth = TLSv1_method();
3226         tci = NULL;
3227         while ((ci = meth->get_cipher(i++)) != NULL)
3228                 {
3229                 if (tci != NULL)
3230                         if (ci->id >= tci->id)
3231                                 {
3232                                 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3233                                 return 0;
3234                                 }
3235                 tci = ci;
3236                 }
3237         fprintf(stderr, "ok\n");
3238 #endif
3239
3240         return 1;
3241         }