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