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