test/ssltest_old.c

   1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   2  * All rights reserved.
   3  *
   4  * This package is an SSL implementation written
   5  * by Eric Young (eay@cryptsoft.com).
   6  * The implementation was written so as to conform with Netscapes SSL.
   7  *
   8  * This library is free for commercial and non-commercial use as long as
   9  * the following conditions are aheared to.  The following conditions
  10  * apply to all code found in this distribution, be it the RC4, RSA,
  11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  12  * included with this distribution is covered by the same copyright terms
  13  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  14  *
  15  * Copyright remains Eric Young's, and as such any Copyright notices in
  16  * the code are not to be removed.
  17  * If this package is used in a product, Eric Young should be given attribution
  18  * as the author of the parts of the library used.
  19  * This can be in the form of a textual message at program startup or
  20  * in documentation (online or textual) provided with the package.
  21  *
  22  * Redistribution and use in source and binary forms, with or without
  23  * modification, are permitted provided that the following conditions
  24  * are met:
  25  * 1. Redistributions of source code must retain the copyright
  26  *    notice, this list of conditions and the following disclaimer.
  27  * 2. Redistributions in binary form must reproduce the above copyright
  28  *    notice, this list of conditions and the following disclaimer in the
  29  *    documentation and/or other materials provided with the distribution.
  30  * 3. All advertising materials mentioning features or use of this software
  31  *    must display the following acknowledgement:
  32  *    "This product includes cryptographic software written by
  33  *     Eric Young (eay@cryptsoft.com)"
  34  *    The word 'cryptographic' can be left out if the rouines from the library
  35  *    being used are not cryptographic related :-).
  36  * 4. If you include any Windows specific code (or a derivative thereof) from
  37  *    the apps directory (application code) you must include an acknowledgement:
  38  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  50  * SUCH DAMAGE.
  51  *
  52  * The licence and distribution terms for any publically available version or
  53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  54  * copied and put under another distribution licence
  55  * [including the GNU Public Licence.]
  56  */
  57 /* ====================================================================
  58  * Copyright (c) 1998-2000 The OpenSSL Project.  All rights reserved.
  59  *
  60  * Redistribution and use in source and binary forms, with or without
  61  * modification, are permitted provided that the following conditions
  62  * are met:
  63  *
  64  * 1. Redistributions of source code must retain the above copyright
  65  *    notice, this list of conditions and the following disclaimer.
  66  *
  67  * 2. Redistributions in binary form must reproduce the above copyright
  68  *    notice, this list of conditions and the following disclaimer in
  69  *    the documentation and/or other materials provided with the
  70  *    distribution.
  71  *
  72  * 3. All advertising materials mentioning features or use of this
  73  *    software must display the following acknowledgment:
  74  *    "This product includes software developed by the OpenSSL Project
  75  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  76  *
  77  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  78  *    endorse or promote products derived from this software without
  79  *    prior written permission. For written permission, please contact
  80  *    openssl-core@openssl.org.
  81  *
  82  * 5. Products derived from this software may not be called "OpenSSL"
  83  *    nor may "OpenSSL" appear in their names without prior written
  84  *    permission of the OpenSSL Project.
  85  *
  86  * 6. Redistributions of any form whatsoever must retain the following
  87  *    acknowledgment:
  88  *    "This product includes software developed by the OpenSSL Project
  89  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  90  *
  91  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  92  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  93  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  94  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  95  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  96  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  97  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  98  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  99  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 100  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 101  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 102  * OF THE POSSIBILITY OF SUCH DAMAGE.
 103  * ====================================================================
 104  *
 105  * This product includes cryptographic software written by Eric Young
 106  * (eay@cryptsoft.com).  This product includes software written by Tim
 107  * Hudson (tjh@cryptsoft.com).
 108  *
 109  */
 110 /* ====================================================================
 111  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
 112  * ECC cipher suite support in OpenSSL originally developed by
 113  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
 114  */
 115 /* ====================================================================
 116  * Copyright 2005 Nokia. All rights reserved.
 117  *
 118  * The portions of the attached software ("Contribution") is developed by
 119  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
 120  * license.
 121  *
 122  * The Contribution, originally written by Mika Kousa and Pasi Eronen of
 123  * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
 124  * support (see RFC 4279) to OpenSSL.
 125  *
 126  * No patent licenses or other rights except those expressly stated in
 127  * the OpenSSL open source license shall be deemed granted or received
 128  * expressly, by implication, estoppel, or otherwise.
 129  *
 130  * No assurances are provided by Nokia that the Contribution does not
 131  * infringe the patent or other intellectual property rights of any third
 132  * party or that the license provides you with all the necessary rights
 133  * to make use of the Contribution.
 134  *
 135  * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
 136  * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
 137  * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
 138  * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
 139  * OTHERWISE.
 140  */
 141
 142 /* Or gethostname won't be declared properly on Linux and GNU platforms. */
 143 #define _BSD_SOURCE 1
 144 #define _DEFAULT_SOURCE 1
 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 /*
 159  * Or isascii won't be declared properly on VMS (at least with DECompHP C).
 160  */
 161 # define _XOPEN_SOURCE 500
 162 #endif
 163
 164 #include <ctype.h>
 165
 166 #include <openssl/bio.h>
 167 #include <openssl/crypto.h>
 168 #include <openssl/evp.h>
 169 #include <openssl/x509.h>
 170 #include <openssl/x509v3.h>
 171 #include <openssl/ssl.h>
 172 #ifndef OPENSSL_NO_ENGINE
 173 # include <openssl/engine.h>
 174 #endif
 175 #include <openssl/err.h>
 176 #include <openssl/rand.h>
 177 #ifndef OPENSSL_NO_RSA
 178 # include <openssl/rsa.h>
 179 #endif
 180 #ifndef OPENSSL_NO_DSA
 181 # include <openssl/dsa.h>
 182 #endif
 183 #ifndef OPENSSL_NO_DH
 184 # include <openssl/dh.h>
 185 #endif
 186 #ifndef OPENSSL_NO_SRP
 187 # include <openssl/srp.h>
 188 #endif
 189 #include <openssl/bn.h>
 190 #ifndef OPENSSL_NO_CT
 191 # include <openssl/ct.h>
 192 #endif
 193
 194 #include "internal/threads.h"
 195 #include "../ssl/ssl_locl.h"
 196
 197 /*
 198  * Or gethostname won't be declared properly
 199  * on Compaq platforms (at least with DEC C).
 200  * Do not try to put it earlier, or IPv6 includes
 201  * get screwed...
 202  */
 203 #define _XOPEN_SOURCE_EXTENDED  1
 204
 205 #ifdef OPENSSL_SYS_WINDOWS
 206 # include <winsock.h>
 207 #else
 208 # include OPENSSL_UNISTD
 209 #endif
 210
 211 static SSL_CTX *s_ctx = NULL;
 212 static SSL_CTX *s_ctx2 = NULL;
 213
 214 /*
 215  * There is really no standard for this, so let's assign something
 216  * only for this test
 217  */
 218 #define COMP_ZLIB       1
 219
 220 static int verify_callback(int ok, X509_STORE_CTX *ctx);
 221 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg);
 222 #define APP_CALLBACK_STRING "Test Callback Argument"
 223 struct app_verify_arg {
 224     char *string;
 225     int app_verify;
 226     int allow_proxy_certs;
 227     char *proxy_auth;
 228     char *proxy_cond;
 229 };
 230
 231 #ifndef OPENSSL_NO_DH
 232 static DH *get_dh512(void);
 233 static DH *get_dh1024(void);
 234 static DH *get_dh1024dsa(void);
 235 #endif
 236
 237 static char *psk_key = NULL;    /* by default PSK is not used */
 238 #ifndef OPENSSL_NO_PSK
 239 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
 240                                         char *identity,
 241                                         unsigned int max_identity_len,
 242                                         unsigned char *psk,
 243                                         unsigned int max_psk_len);
 244 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
 245                                         unsigned char *psk,
 246                                         unsigned int max_psk_len);
 247 #endif
 248
 249 #ifndef OPENSSL_NO_SRP
 250 /* SRP client */
 251 /* This is a context that we pass to all callbacks */
 252 typedef struct srp_client_arg_st {
 253     char *srppassin;
 254     char *srplogin;
 255 } SRP_CLIENT_ARG;
 256
 257 # define PWD_STRLEN 1024
 258
 259 static char *ssl_give_srp_client_pwd_cb(SSL *s, void *arg)
 260 {
 261     SRP_CLIENT_ARG *srp_client_arg = (SRP_CLIENT_ARG *)arg;
 262     return OPENSSL_strdup((char *)srp_client_arg->srppassin);
 263 }
 264
 265 /* SRP server */
 266 /* This is a context that we pass to SRP server callbacks */
 267 typedef struct srp_server_arg_st {
 268     char *expected_user;
 269     char *pass;
 270 } SRP_SERVER_ARG;
 271
 272 static int ssl_srp_server_param_cb(SSL *s, int *ad, void *arg)
 273 {
 274     SRP_SERVER_ARG *p = (SRP_SERVER_ARG *)arg;
 275
 276     if (strcmp(p->expected_user, SSL_get_srp_username(s)) != 0) {
 277         fprintf(stderr, "User %s doesn't exist\n", SSL_get_srp_username(s));
 278         return SSL3_AL_FATAL;
 279     }
 280     if (SSL_set_srp_server_param_pw(s, p->expected_user, p->pass, "1024") < 0) {
 281         *ad = SSL_AD_INTERNAL_ERROR;
 282         return SSL3_AL_FATAL;
 283     }
 284     return SSL_ERROR_NONE;
 285 }
 286 #endif
 287
 288 static BIO *bio_err = NULL;
 289 static BIO *bio_stdout = NULL;
 290
 291 #ifndef OPENSSL_NO_NEXTPROTONEG
 292 /* Note that this code assumes that this is only a one element list: */
 293 static const char NEXT_PROTO_STRING[] = "\x09testproto";
 294 static int npn_client = 0;
 295 static int npn_server = 0;
 296 static int npn_server_reject = 0;
 297
 298 static int cb_client_npn(SSL *s, unsigned char **out, unsigned char *outlen,
 299                          const unsigned char *in, unsigned int inlen,
 300                          void *arg)
 301 {
 302     /*
 303      * This callback only returns the protocol string, rather than a length
 304      * prefixed set. We assume that NEXT_PROTO_STRING is a one element list
 305      * and remove the first byte to chop off the length prefix.
 306      */
 307     *out = (unsigned char *)NEXT_PROTO_STRING + 1;
 308     *outlen = sizeof(NEXT_PROTO_STRING) - 2;
 309     return SSL_TLSEXT_ERR_OK;
 310 }
 311
 312 static int cb_server_npn(SSL *s, const unsigned char **data,
 313                          unsigned int *len, void *arg)
 314 {
 315     *data = (const unsigned char *)NEXT_PROTO_STRING;
 316     *len = sizeof(NEXT_PROTO_STRING) - 1;
 317     return SSL_TLSEXT_ERR_OK;
 318 }
 319
 320 static int cb_server_rejects_npn(SSL *s, const unsigned char **data,
 321                                  unsigned int *len, void *arg)
 322 {
 323     return SSL_TLSEXT_ERR_NOACK;
 324 }
 325
 326 static int verify_npn(SSL *client, SSL *server)
 327 {
 328     const unsigned char *client_s;
 329     unsigned client_len;
 330     const unsigned char *server_s;
 331     unsigned server_len;
 332
 333     SSL_get0_next_proto_negotiated(client, &client_s, &client_len);
 334     SSL_get0_next_proto_negotiated(server, &server_s, &server_len);
 335
 336     if (client_len) {
 337         BIO_printf(bio_stdout, "Client NPN: ");
 338         BIO_write(bio_stdout, client_s, client_len);
 339         BIO_printf(bio_stdout, "\n");
 340     }
 341
 342     if (server_len) {
 343         BIO_printf(bio_stdout, "Server NPN: ");
 344         BIO_write(bio_stdout, server_s, server_len);
 345         BIO_printf(bio_stdout, "\n");
 346     }
 347
 348     /*
 349      * If an NPN string was returned, it must be the protocol that we
 350      * expected to negotiate.
 351      */
 352     if (client_len && (client_len != sizeof(NEXT_PROTO_STRING) - 2 ||
 353                        memcmp(client_s, NEXT_PROTO_STRING + 1, client_len)))
 354         return -1;
 355     if (server_len && (server_len != sizeof(NEXT_PROTO_STRING) - 2 ||
 356                        memcmp(server_s, NEXT_PROTO_STRING + 1, server_len)))
 357         return -1;
 358
 359     if (!npn_client && client_len)
 360         return -1;
 361     if (!npn_server && server_len)
 362         return -1;
 363     if (npn_server_reject && server_len)
 364         return -1;
 365     if (npn_client && npn_server && (!client_len || !server_len))
 366         return -1;
 367
 368     return 0;
 369 }
 370 #endif
 371
 372 static const char *alpn_client;
 373 static char *alpn_server;
 374 static char *alpn_server2;
 375 static const char *alpn_expected;
 376 static unsigned char *alpn_selected;
 377 static const char *server_min_proto;
 378 static const char *server_max_proto;
 379 static const char *client_min_proto;
 380 static const char *client_max_proto;
 381 static const char *should_negotiate;
 382 static const char *sn_client;
 383 static const char *sn_server1;
 384 static const char *sn_server2;
 385 static int sn_expect = 0;
 386 static const char *server_sess_out;
 387 static const char *server_sess_in;
 388 static const char *client_sess_out;
 389 static const char *client_sess_in;
 390 static SSL_SESSION *server_sess;
 391 static SSL_SESSION *client_sess;
 392
 393 static int servername_cb(SSL *s, int *ad, void *arg)
 394 {
 395     const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
 396     if (sn_server2 == NULL) {
 397         BIO_printf(bio_stdout, "Servername 2 is NULL\n");
 398         return SSL_TLSEXT_ERR_NOACK;
 399     }
 400
 401     if (servername) {
 402         if (s_ctx2 != NULL && sn_server2 != NULL &&
 403             !strcasecmp(servername, sn_server2)) {
 404             BIO_printf(bio_stdout, "Switching server context.\n");
 405             SSL_set_SSL_CTX(s, s_ctx2);
 406         }
 407     }
 408     return SSL_TLSEXT_ERR_OK;
 409 }
 410 static int verify_servername(SSL *client, SSL *server)
 411 {
 412     /* just need to see if sn_context is what we expect */
 413     SSL_CTX* ctx = SSL_get_SSL_CTX(server);
 414     if (sn_expect == 0)
 415         return 0;
 416     if (sn_expect == 1 && ctx == s_ctx)
 417         return 0;
 418     if (sn_expect == 2 && ctx == s_ctx2)
 419         return 0;
 420     BIO_printf(bio_stdout, "Servername: expected context %d\n", sn_expect);
 421     if (ctx == s_ctx2)
 422         BIO_printf(bio_stdout, "Servername: context is 2\n");
 423     else if (ctx == s_ctx)
 424         BIO_printf(bio_stdout, "Servername: context is 1\n");
 425     else
 426         BIO_printf(bio_stdout, "Servername: context is unknown\n");
 427     return -1;
 428 }
 429
 430
 431 /*-
 432  * next_protos_parse parses a comma separated list of strings into a string
 433  * in a format suitable for passing to SSL_CTX_set_next_protos_advertised.
 434  *   outlen: (output) set to the length of the resulting buffer on success.
 435  *   err: (maybe NULL) on failure, an error message line is written to this BIO.
 436  *   in: a NUL terminated string like "abc,def,ghi"
 437  *
 438  *   returns: a malloced buffer or NULL on failure.
 439  */
 440 static unsigned char *next_protos_parse(size_t *outlen,
 441                                         const char *in)
 442 {
 443     size_t len;
 444     unsigned char *out;
 445     size_t i, start = 0;
 446
 447     len = strlen(in);
 448     if (len >= 65535)
 449         return NULL;
 450
 451     out = OPENSSL_malloc(strlen(in) + 1);
 452     if (!out)
 453         return NULL;
 454
 455     for (i = 0; i <= len; ++i) {
 456         if (i == len || in[i] == ',') {
 457             if (i - start > 255) {
 458                 OPENSSL_free(out);
 459                 return NULL;
 460             }
 461             out[start] = i - start;
 462             start = i + 1;
 463         } else
 464             out[i + 1] = in[i];
 465     }
 466
 467     *outlen = len + 1;
 468     return out;
 469 }
 470
 471 static int cb_server_alpn(SSL *s, const unsigned char **out,
 472                           unsigned char *outlen, const unsigned char *in,
 473                           unsigned int inlen, void *arg)
 474 {
 475     unsigned char *protos;
 476     size_t protos_len;
 477     char* alpn_str = arg;
 478
 479     protos = next_protos_parse(&protos_len, alpn_str);
 480     if (protos == NULL) {
 481         fprintf(stderr, "failed to parser ALPN server protocol string: %s\n",
 482                 alpn_str);
 483         abort();
 484     }
 485
 486     if (SSL_select_next_proto
 487         ((unsigned char **)out, outlen, protos, protos_len, in,
 488          inlen) != OPENSSL_NPN_NEGOTIATED) {
 489         OPENSSL_free(protos);
 490         return SSL_TLSEXT_ERR_NOACK;
 491     }
 492
 493     /*
 494      * Make a copy of the selected protocol which will be freed in
 495      * verify_alpn.
 496      */
 497     alpn_selected = OPENSSL_malloc(*outlen);
 498     memcpy(alpn_selected, *out, *outlen);
 499     *out = alpn_selected;
 500
 501     OPENSSL_free(protos);
 502     return SSL_TLSEXT_ERR_OK;
 503 }
 504
 505 static int verify_alpn(SSL *client, SSL *server)
 506 {
 507     const unsigned char *client_proto, *server_proto;
 508     unsigned int client_proto_len = 0, server_proto_len = 0;
 509     SSL_get0_alpn_selected(client, &client_proto, &client_proto_len);
 510     SSL_get0_alpn_selected(server, &server_proto, &server_proto_len);
 511
 512     OPENSSL_free(alpn_selected);
 513     alpn_selected = NULL;
 514
 515     if (client_proto_len != server_proto_len) {
 516         BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");
 517         goto err;
 518     }
 519
 520     if (client_proto != NULL &&
 521         memcmp(client_proto, server_proto, client_proto_len) != 0) {
 522         BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");
 523         goto err;
 524     }
 525
 526     if (client_proto_len > 0 && alpn_expected == NULL) {
 527         BIO_printf(bio_stdout, "ALPN unexpectedly negotiated\n");
 528         goto err;
 529     }
 530
 531     if (alpn_expected != NULL &&
 532         (client_proto_len != strlen(alpn_expected) ||
 533          memcmp(client_proto, alpn_expected, client_proto_len) != 0)) {
 534         BIO_printf(bio_stdout,
 535                    "ALPN selected protocols not equal to expected protocol: %s\n",
 536                    alpn_expected);
 537         goto err;
 538     }
 539
 540     return 0;
 541
 542  err:
 543     BIO_printf(bio_stdout, "ALPN results: client: '");
 544     BIO_write(bio_stdout, client_proto, client_proto_len);
 545     BIO_printf(bio_stdout, "', server: '");
 546     BIO_write(bio_stdout, server_proto, server_proto_len);
 547     BIO_printf(bio_stdout, "'\n");
 548     BIO_printf(bio_stdout, "ALPN configured: client: '%s', server: '",
 549                    alpn_client);
 550     if (SSL_get_SSL_CTX(server) == s_ctx2) {
 551         BIO_printf(bio_stdout, "%s'\n",
 552                    alpn_server2);
 553     } else {
 554         BIO_printf(bio_stdout, "%s'\n",
 555                    alpn_server);
 556     }
 557     return -1;
 558 }
 559
 560 /*
 561  * WARNING : below extension types are *NOT* IETF assigned, and could
 562  * conflict if these types are reassigned and handled specially by OpenSSL
 563  * in the future
 564  */
 565 #define TACK_EXT_TYPE 62208
 566 #define CUSTOM_EXT_TYPE_0 1000
 567 #define CUSTOM_EXT_TYPE_1 1001
 568 #define CUSTOM_EXT_TYPE_2 1002
 569 #define CUSTOM_EXT_TYPE_3 1003
 570
 571 static const char custom_ext_cli_string[] = "abc";
 572 static const char custom_ext_srv_string[] = "defg";
 573
 574 /* These set from cmdline */
 575 static char *serverinfo_file = NULL;
 576 static int serverinfo_sct = 0;
 577 static int serverinfo_tack = 0;
 578
 579 /* These set based on extension callbacks */
 580 static int serverinfo_sct_seen = 0;
 581 static int serverinfo_tack_seen = 0;
 582 static int serverinfo_other_seen = 0;
 583
 584 /* This set from cmdline */
 585 static int custom_ext = 0;
 586
 587 /* This set based on extension callbacks */
 588 static int custom_ext_error = 0;
 589
 590 static int serverinfo_cli_parse_cb(SSL *s, unsigned int ext_type,
 591                                    const unsigned char *in, size_t inlen,
 592                                    int *al, void *arg)
 593 {
 594     if (ext_type == TLSEXT_TYPE_signed_certificate_timestamp)
 595         serverinfo_sct_seen++;
 596     else if (ext_type == TACK_EXT_TYPE)
 597         serverinfo_tack_seen++;
 598     else
 599         serverinfo_other_seen++;
 600     return 1;
 601 }
 602
 603 static int verify_serverinfo()
 604 {
 605     if (serverinfo_sct != serverinfo_sct_seen)
 606         return -1;
 607     if (serverinfo_tack != serverinfo_tack_seen)
 608         return -1;
 609     if (serverinfo_other_seen)
 610         return -1;
 611     return 0;
 612 }
 613
 614 /*-
 615  * Four test cases for custom extensions:
 616  * 0 - no ClientHello extension or ServerHello response
 617  * 1 - ClientHello with "abc", no response
 618  * 2 - ClientHello with "abc", empty response
 619  * 3 - ClientHello with "abc", "defg" response
 620  */
 621
 622 static int custom_ext_0_cli_add_cb(SSL *s, unsigned int ext_type,
 623                                    const unsigned char **out,
 624                                    size_t *outlen, int *al, void *arg)
 625 {
 626     if (ext_type != CUSTOM_EXT_TYPE_0)
 627         custom_ext_error = 1;
 628     return 0;                   /* Don't send an extension */
 629 }
 630
 631 static int custom_ext_0_cli_parse_cb(SSL *s, unsigned int ext_type,
 632                                      const unsigned char *in,
 633                                      size_t inlen, int *al, void *arg)
 634 {
 635     return 1;
 636 }
 637
 638 static int custom_ext_1_cli_add_cb(SSL *s, unsigned int ext_type,
 639                                    const unsigned char **out,
 640                                    size_t *outlen, int *al, void *arg)
 641 {
 642     if (ext_type != CUSTOM_EXT_TYPE_1)
 643         custom_ext_error = 1;
 644     *out = (const unsigned char *)custom_ext_cli_string;
 645     *outlen = strlen(custom_ext_cli_string);
 646     return 1;                   /* Send "abc" */
 647 }
 648
 649 static int custom_ext_1_cli_parse_cb(SSL *s, unsigned int ext_type,
 650                                      const unsigned char *in,
 651                                      size_t inlen, int *al, void *arg)
 652 {
 653     return 1;
 654 }
 655
 656 static int custom_ext_2_cli_add_cb(SSL *s, unsigned int ext_type,
 657                                    const unsigned char **out,
 658                                    size_t *outlen, int *al, void *arg)
 659 {
 660     if (ext_type != CUSTOM_EXT_TYPE_2)
 661         custom_ext_error = 1;
 662     *out = (const unsigned char *)custom_ext_cli_string;
 663     *outlen = strlen(custom_ext_cli_string);
 664     return 1;                   /* Send "abc" */
 665 }
 666
 667 static int custom_ext_2_cli_parse_cb(SSL *s, unsigned int ext_type,
 668                                      const unsigned char *in,
 669                                      size_t inlen, int *al, void *arg)
 670 {
 671     if (ext_type != CUSTOM_EXT_TYPE_2)
 672         custom_ext_error = 1;
 673     if (inlen != 0)
 674         custom_ext_error = 1;   /* Should be empty response */
 675     return 1;
 676 }
 677
 678 static int custom_ext_3_cli_add_cb(SSL *s, unsigned int ext_type,
 679                                    const unsigned char **out,
 680                                    size_t *outlen, int *al, void *arg)
 681 {
 682     if (ext_type != CUSTOM_EXT_TYPE_3)
 683         custom_ext_error = 1;
 684     *out = (const unsigned char *)custom_ext_cli_string;
 685     *outlen = strlen(custom_ext_cli_string);
 686     return 1;                   /* Send "abc" */
 687 }
 688
 689 static int custom_ext_3_cli_parse_cb(SSL *s, unsigned int ext_type,
 690                                      const unsigned char *in,
 691                                      size_t inlen, int *al, void *arg)
 692 {
 693     if (ext_type != CUSTOM_EXT_TYPE_3)
 694         custom_ext_error = 1;
 695     if (inlen != strlen(custom_ext_srv_string))
 696         custom_ext_error = 1;
 697     if (memcmp(custom_ext_srv_string, in, inlen) != 0)
 698         custom_ext_error = 1;   /* Check for "defg" */
 699     return 1;
 700 }
 701
 702 /*
 703  * custom_ext_0_cli_add_cb returns 0 - the server won't receive a callback
 704  * for this extension
 705  */
 706 static int custom_ext_0_srv_parse_cb(SSL *s, unsigned int ext_type,
 707                                      const unsigned char *in,
 708                                      size_t inlen, int *al, void *arg)
 709 {
 710     custom_ext_error = 1;
 711     return 1;
 712 }
 713
 714 /* 'add' callbacks are only called if the 'parse' callback is called */
 715 static int custom_ext_0_srv_add_cb(SSL *s, unsigned int ext_type,
 716                                    const unsigned char **out,
 717                                    size_t *outlen, int *al, void *arg)
 718 {
 719     /* Error: should not have been called */
 720     custom_ext_error = 1;
 721     return 0;                   /* Don't send an extension */
 722 }
 723
 724 static int custom_ext_1_srv_parse_cb(SSL *s, unsigned int ext_type,
 725                                      const unsigned char *in,
 726                                      size_t inlen, int *al, void *arg)
 727 {
 728     if (ext_type != CUSTOM_EXT_TYPE_1)
 729         custom_ext_error = 1;
 730     /* Check for "abc" */
 731     if (inlen != strlen(custom_ext_cli_string))
 732         custom_ext_error = 1;
 733     if (memcmp(in, custom_ext_cli_string, inlen) != 0)
 734         custom_ext_error = 1;
 735     return 1;
 736 }
 737
 738 static int custom_ext_1_srv_add_cb(SSL *s, unsigned int ext_type,
 739                                    const unsigned char **out,
 740                                    size_t *outlen, int *al, void *arg)
 741 {
 742     return 0;                   /* Don't send an extension */
 743 }
 744
 745 static int custom_ext_2_srv_parse_cb(SSL *s, unsigned int ext_type,
 746                                      const unsigned char *in,
 747                                      size_t inlen, int *al, void *arg)
 748 {
 749     if (ext_type != CUSTOM_EXT_TYPE_2)
 750         custom_ext_error = 1;
 751     /* Check for "abc" */
 752     if (inlen != strlen(custom_ext_cli_string))
 753         custom_ext_error = 1;
 754     if (memcmp(in, custom_ext_cli_string, inlen) != 0)
 755         custom_ext_error = 1;
 756     return 1;
 757 }
 758
 759 static int custom_ext_2_srv_add_cb(SSL *s, unsigned int ext_type,
 760                                    const unsigned char **out,
 761                                    size_t *outlen, int *al, void *arg)
 762 {
 763     *out = NULL;
 764     *outlen = 0;
 765     return 1;                   /* Send empty extension */
 766 }
 767
 768 static int custom_ext_3_srv_parse_cb(SSL *s, unsigned int ext_type,
 769                                      const unsigned char *in,
 770                                      size_t inlen, int *al, void *arg)
 771 {
 772     if (ext_type != CUSTOM_EXT_TYPE_3)
 773         custom_ext_error = 1;
 774     /* Check for "abc" */
 775     if (inlen != strlen(custom_ext_cli_string))
 776         custom_ext_error = 1;
 777     if (memcmp(in, custom_ext_cli_string, inlen) != 0)
 778         custom_ext_error = 1;
 779     return 1;
 780 }
 781
 782 static int custom_ext_3_srv_add_cb(SSL *s, unsigned int ext_type,
 783                                    const unsigned char **out,
 784                                    size_t *outlen, int *al, void *arg)
 785 {
 786     *out = (const unsigned char *)custom_ext_srv_string;
 787     *outlen = strlen(custom_ext_srv_string);
 788     return 1;                   /* Send "defg" */
 789 }
 790
 791 static char *cipher = NULL;
 792 static int verbose = 0;
 793 static int debug = 0;
 794 static const char rnd_seed[] =
 795     "string to make the random number generator think it has entropy";
 796
 797 int doit_localhost(SSL *s_ssl, SSL *c_ssl, int family,
 798                    long bytes, clock_t *s_time, clock_t *c_time);
 799 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long bytes, clock_t *s_time,
 800                  clock_t *c_time);
 801 int doit(SSL *s_ssl, SSL *c_ssl, long bytes);
 802 static int do_test_cipherlist(void);
 803
 804 static void sv_usage(void)
 805 {
 806     fprintf(stderr, "usage: ssltest [args ...]\n");
 807     fprintf(stderr, "\n");
 808 #ifdef OPENSSL_FIPS
 809     fprintf(stderr, "-F             - run test in FIPS mode\n");
 810 #endif
 811     fprintf(stderr, " -server_auth  - check server certificate\n");
 812     fprintf(stderr, " -client_auth  - do client authentication\n");
 813     fprintf(stderr, " -proxy        - allow proxy certificates\n");
 814     fprintf(stderr, " -proxy_auth <val> - set proxy policy rights\n");
 815     fprintf(stderr,
 816             " -proxy_cond <val> - expression to test proxy policy rights\n");
 817     fprintf(stderr, " -v            - more output\n");
 818     fprintf(stderr, " -d            - debug output\n");
 819     fprintf(stderr, " -reuse        - use session-id reuse\n");
 820     fprintf(stderr, " -num <val>    - number of connections to perform\n");
 821     fprintf(stderr,
 822             " -bytes <val>  - number of bytes to swap between client/server\n");
 823 #ifndef OPENSSL_NO_DH
 824     fprintf(stderr,
 825             " -dhe512       - use 512 bit key for DHE (to test failure)\n");
 826     fprintf(stderr,
 827             " -dhe1024      - use 1024 bit key (safe prime) for DHE (default, no-op)\n");
 828     fprintf(stderr,
 829             " -dhe1024dsa   - use 1024 bit key (with 160-bit subprime) for DHE\n");
 830     fprintf(stderr, " -no_dhe       - disable DHE\n");
 831 #endif
 832 #ifndef OPENSSL_NO_EC
 833     fprintf(stderr, " -no_ecdhe     - disable ECDHE\nTODO(openssl-team): no_ecdhe was broken by auto ecdh. Make this work again.\n");
 834 #endif
 835 #ifndef OPENSSL_NO_PSK
 836     fprintf(stderr, " -psk arg      - PSK in hex (without 0x)\n");
 837 #endif
 838 #ifndef OPENSSL_NO_SRP
 839     fprintf(stderr, " -srpuser user - SRP username to use\n");
 840     fprintf(stderr, " -srppass arg  - password for 'user'\n");
 841 #endif
 842 #ifndef OPENSSL_NO_SSL3
 843     fprintf(stderr, " -ssl3         - use SSLv3\n");
 844 #endif
 845 #ifndef OPENSSL_NO_TLS1
 846     fprintf(stderr, " -tls1         - use TLSv1\n");
 847 #endif
 848 #ifndef OPENSSL_NO_DTLS
 849     fprintf(stderr, " -dtls         - use DTLS\n");
 850 #ifndef OPENSSL_NO_DTLS1
 851     fprintf(stderr, " -dtls1        - use DTLSv1\n");
 852 #endif
 853 #ifndef OPENSSL_NO_DTLS1_2
 854     fprintf(stderr, " -dtls12       - use DTLSv1.2\n");
 855 #endif
 856 #endif
 857     fprintf(stderr, " -CApath arg   - PEM format directory of CA's\n");
 858     fprintf(stderr, " -CAfile arg   - PEM format file of CA's\n");
 859     fprintf(stderr, " -cert arg     - Server certificate file\n");
 860     fprintf(stderr,
 861             " -key arg      - Server key file (default: same as -cert)\n");
 862     fprintf(stderr, " -c_cert arg   - Client certificate file\n");
 863     fprintf(stderr,
 864             " -c_key arg    - Client key file (default: same as -c_cert)\n");
 865     fprintf(stderr, " -cipher arg   - The cipher list\n");
 866     fprintf(stderr, " -bio_pair     - Use BIO pairs\n");
 867     fprintf(stderr, " -ipv4         - Use IPv4 connection on localhost\n");
 868     fprintf(stderr, " -ipv6         - Use IPv6 connection on localhost\n");
 869     fprintf(stderr, " -f            - Test even cases that can't work\n");
 870     fprintf(stderr,
 871             " -time         - measure processor time used by client and server\n");
 872     fprintf(stderr, " -zlib         - use zlib compression\n");
 873     fprintf(stderr,
 874             " -test_cipherlist - Verifies the order of the ssl cipher lists.\n"
 875             "                    When this option is requested, the cipherlist\n"
 876             "                    tests are run instead of handshake tests.\n");
 877 #ifndef OPENSSL_NO_NEXTPROTONEG
 878     fprintf(stderr, " -npn_client - have client side offer NPN\n");
 879     fprintf(stderr, " -npn_server - have server side offer NPN\n");
 880     fprintf(stderr, " -npn_server_reject - have server reject NPN\n");
 881 #endif
 882     fprintf(stderr, " -serverinfo_file file - have server use this file\n");
 883     fprintf(stderr, " -serverinfo_sct  - have client offer and expect SCT\n");
 884     fprintf(stderr,
 885             " -serverinfo_tack - have client offer and expect TACK\n");
 886     fprintf(stderr,
 887             " -custom_ext - try various custom extension callbacks\n");
 888     fprintf(stderr, " -alpn_client <string> - have client side offer ALPN\n");
 889     fprintf(stderr, " -alpn_server <string> - have server side offer ALPN\n");
 890     fprintf(stderr, " -alpn_server1 <string> - alias for -alpn_server\n");
 891     fprintf(stderr, " -alpn_server2 <string> - have server side context 2 offer ALPN\n");
 892     fprintf(stderr,
 893             " -alpn_expected <string> - the ALPN protocol that should be negotiated\n");
 894     fprintf(stderr, " -server_min_proto <string> - Minimum version the server should support\n");
 895     fprintf(stderr, " -server_max_proto <string> - Maximum version the server should support\n");
 896     fprintf(stderr, " -client_min_proto <string> - Minimum version the client should support\n");
 897     fprintf(stderr, " -client_max_proto <string> - Maximum version the client should support\n");
 898     fprintf(stderr, " -should_negotiate <string> - The version that should be negotiated, fail-client or fail-server\n");
 899 #ifndef OPENSSL_NO_CT
 900     fprintf(stderr, " -noct         - no certificate transparency\n");
 901     fprintf(stderr, " -requestct    - request certificate transparency\n");
 902     fprintf(stderr, " -requirect    - require certificate transparency\n");
 903 #endif
 904     fprintf(stderr, " -sn_client <string>  - have client request this servername\n");
 905     fprintf(stderr, " -sn_server1 <string> - have server context 1 respond to this servername\n");
 906     fprintf(stderr, " -sn_server2 <string> - have server context 2 respond to this servername\n");
 907     fprintf(stderr, " -sn_expect1          - expected server 1\n");
 908     fprintf(stderr, " -sn_expect2          - expected server 2\n");
 909     fprintf(stderr, " -server_sess_out <file>    - Save the server session to a file\n");
 910     fprintf(stderr, " -server_sess_in <file>     - Read the server session from a file\n");
 911     fprintf(stderr, " -client_sess_out <file>    - Save the client session to a file\n");
 912     fprintf(stderr, " -client_sess_in <file>     - Read the client session from a file\n");
 913     fprintf(stderr, " -should_reuse <number>     - The expected state of reusing the session\n");
 914     fprintf(stderr, " -no_ticket    - do not issue TLS session ticket\n");
 915 }
 916
 917 static void print_key_details(BIO *out, EVP_PKEY *key)
 918 {
 919     int keyid = EVP_PKEY_id(key);
 920 #ifndef OPENSSL_NO_EC
 921     if (keyid == EVP_PKEY_EC) {
 922         EC_KEY *ec = EVP_PKEY_get1_EC_KEY(key);
 923         int nid;
 924         const char *cname;
 925         nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
 926         EC_KEY_free(ec);
 927         cname = EC_curve_nid2nist(nid);
 928         if (!cname)
 929             cname = OBJ_nid2sn(nid);
 930         BIO_printf(out, "%d bits EC (%s)", EVP_PKEY_bits(key), cname);
 931     } else
 932 #endif
 933     {
 934         const char *algname;
 935         switch (keyid) {
 936         case EVP_PKEY_RSA:
 937             algname = "RSA";
 938             break;
 939         case EVP_PKEY_DSA:
 940             algname = "DSA";
 941             break;
 942         case EVP_PKEY_DH:
 943             algname = "DH";
 944             break;
 945         default:
 946             algname = OBJ_nid2sn(keyid);
 947             break;
 948         }
 949         BIO_printf(out, "%d bits %s", EVP_PKEY_bits(key), algname);
 950     }
 951 }
 952
 953 static void print_details(SSL *c_ssl, const char *prefix)
 954 {
 955     const SSL_CIPHER *ciph;
 956     int mdnid;
 957     X509 *cert;
 958     EVP_PKEY *pkey;
 959
 960     ciph = SSL_get_current_cipher(c_ssl);
 961     BIO_printf(bio_stdout, "%s%s, cipher %s %s",
 962                prefix,
 963                SSL_get_version(c_ssl),
 964                SSL_CIPHER_get_version(ciph), SSL_CIPHER_get_name(ciph));
 965     cert = SSL_get_peer_certificate(c_ssl);
 966     if (cert != NULL) {
 967         pkey = X509_get_pubkey(cert);
 968         if (pkey != NULL) {
 969             BIO_puts(bio_stdout, ", ");
 970             print_key_details(bio_stdout, pkey);
 971             EVP_PKEY_free(pkey);
 972         }
 973         X509_free(cert);
 974     }
 975     if (SSL_get_server_tmp_key(c_ssl, &pkey)) {
 976         BIO_puts(bio_stdout, ", temp key: ");
 977         print_key_details(bio_stdout, pkey);
 978         EVP_PKEY_free(pkey);
 979     }
 980     if (SSL_get_peer_signature_nid(c_ssl, &mdnid))
 981         BIO_printf(bio_stdout, ", digest=%s", OBJ_nid2sn(mdnid));
 982     BIO_printf(bio_stdout, "\n");
 983 }
 984
 985 /*
 986  * protocol_from_string - converts a protocol version string to a number
 987  *
 988  * Returns -1 on failure or the version on success
 989  */
 990 static int protocol_from_string(const char *value)
 991 {
 992     struct protocol_versions {
 993         const char *name;
 994         int version;
 995     };
 996     static const struct protocol_versions versions[] = {
 997         {"ssl3", SSL3_VERSION},
 998         {"tls1", TLS1_VERSION},
 999         {"tls1.1", TLS1_1_VERSION},
1000         {"tls1.2", TLS1_2_VERSION},
1001         {"dtls1", DTLS1_VERSION},
1002         {"dtls1.2", DTLS1_2_VERSION}};
1003     size_t i;
1004     size_t n = OSSL_NELEM(versions);
1005
1006     for (i = 0; i < n; i++)
1007         if (strcmp(versions[i].name, value) == 0)
1008             return versions[i].version;
1009     return -1;
1010 }
1011
1012 static SSL_SESSION *read_session(const char *filename)
1013 {
1014     SSL_SESSION *sess;
1015     BIO *f = BIO_new_file(filename, "r");
1016
1017     if (f == NULL) {
1018         BIO_printf(bio_err, "Can't open session file %s\n", filename);
1019         ERR_print_errors(bio_err);
1020         return NULL;
1021     }
1022     sess = PEM_read_bio_SSL_SESSION(f, NULL, 0, NULL);
1023     if (sess == NULL) {
1024         BIO_printf(bio_err, "Can't parse session file %s\n", filename);
1025         ERR_print_errors(bio_err);
1026     }
1027     BIO_free(f);
1028     return sess;
1029 }
1030
1031 static int write_session(const char *filename, SSL_SESSION *sess)
1032 {
1033     BIO *f = BIO_new_file(filename, "w");
1034
1035     if (sess == NULL) {
1036         BIO_printf(bio_err, "No session information\n");
1037         return 0;
1038     }
1039     if (f == NULL) {
1040         BIO_printf(bio_err, "Can't open session file %s\n", filename);
1041         ERR_print_errors(bio_err);
1042         return 0;
1043     }
1044     PEM_write_bio_SSL_SESSION(f, sess);
1045     BIO_free(f);
1046     return 1;
1047 }
1048
1049 /*
1050  * set_protocol_version - Sets protocol version minimum or maximum
1051  *
1052  * Returns 0 on failure and 1 on success
1053  */
1054 static int set_protocol_version(const char *version, SSL *ssl, int setting)
1055 {
1056     if (version != NULL) {
1057         int ver = protocol_from_string(version);
1058         if (ver < 0) {
1059             BIO_printf(bio_err, "Error parsing: %s\n", version);
1060             return 0;
1061         }
1062         return SSL_ctrl(ssl, setting, ver, NULL);
1063     }
1064     return 1;
1065 }
1066
1067 int main(int argc, char *argv[])
1068 {
1069     char *CApath = NULL, *CAfile = NULL;
1070     int badop = 0;
1071     enum { BIO_MEM, BIO_PAIR, BIO_IPV4, BIO_IPV6 } bio_type = BIO_MEM;
1072     int force = 0;
1073     int dtls1 = 0, dtls12 = 0, dtls = 0, tls1 = 0, ssl3 = 0, ret = 1;
1074     int client_auth = 0;
1075     int server_auth = 0, i;
1076     struct app_verify_arg app_verify_arg =
1077         { APP_CALLBACK_STRING, 0, 0, NULL, NULL };
1078     char *p;
1079     SSL_CTX *c_ctx = NULL;
1080     const SSL_METHOD *meth = NULL;
1081     SSL *c_ssl, *s_ssl;
1082     int number = 1, reuse = 0;
1083     int should_reuse = -1;
1084     int no_ticket = 0;
1085     long bytes = 256L;
1086 #ifndef OPENSSL_NO_DH
1087     DH *dh;
1088     int dhe512 = 0, dhe1024dsa = 0;
1089 #endif
1090 #ifndef OPENSSL_NO_SRP
1091     /* client */
1092     SRP_CLIENT_ARG srp_client_arg = { NULL, NULL };
1093     /* server */
1094     SRP_SERVER_ARG srp_server_arg = { NULL, NULL };
1095 #endif
1096     int no_dhe = 0;
1097     int no_psk = 0;
1098     int print_time = 0;
1099     clock_t s_time = 0, c_time = 0;
1100 #ifndef OPENSSL_NO_COMP
1101     int n, comp = 0;
1102     COMP_METHOD *cm = NULL;
1103     STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
1104 #endif
1105     int test_cipherlist = 0;
1106 #ifdef OPENSSL_FIPS
1107     int fips_mode = 0;
1108 #endif
1109     int no_protocol;
1110     int min_version = 0, max_version = 0;
1111 #ifndef OPENSSL_NO_CT
1112     /*
1113      * Disable CT validation by default, because it will interfere with
1114      * anything using custom extension handlers to deal with SCT extensions.
1115      */
1116     ct_validation_cb ct_validation = NULL;
1117 #endif
1118     SSL_CONF_CTX *s_cctx = NULL, *c_cctx = NULL, *s_cctx2 = NULL;
1119     STACK_OF(OPENSSL_STRING) *conf_args = NULL;
1120     char *arg = NULL, *argn = NULL;
1121
1122     verbose = 0;
1123     debug = 0;
1124     cipher = 0;
1125
1126     bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
1127
1128     p = getenv("OPENSSL_DEBUG_MEMORY");
1129     if (p != NULL && strcmp(p, "on") == 0)
1130         CRYPTO_set_mem_debug(1);
1131     CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
1132
1133     RAND_seed(rnd_seed, sizeof rnd_seed);
1134
1135     bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);
1136
1137     s_cctx = SSL_CONF_CTX_new();
1138     s_cctx2 = SSL_CONF_CTX_new();
1139     c_cctx = SSL_CONF_CTX_new();
1140
1141     if (!s_cctx || !c_cctx || !s_cctx2) {
1142         ERR_print_errors(bio_err);
1143         goto end;
1144     }
1145
1146     SSL_CONF_CTX_set_flags(s_cctx,
1147                            SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_SERVER |
1148                            SSL_CONF_FLAG_CERTIFICATE |
1149                            SSL_CONF_FLAG_REQUIRE_PRIVATE);
1150     SSL_CONF_CTX_set_flags(s_cctx2,
1151                            SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_SERVER |
1152                            SSL_CONF_FLAG_CERTIFICATE |
1153                            SSL_CONF_FLAG_REQUIRE_PRIVATE);
1154     if (!SSL_CONF_CTX_set1_prefix(s_cctx, "-s_")) {
1155         ERR_print_errors(bio_err);
1156         goto end;
1157     }
1158     if (!SSL_CONF_CTX_set1_prefix(s_cctx2, "-s_")) {
1159         ERR_print_errors(bio_err);
1160         goto end;
1161     }
1162
1163     SSL_CONF_CTX_set_flags(c_cctx,
1164                            SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_CLIENT |
1165                            SSL_CONF_FLAG_CERTIFICATE |
1166                            SSL_CONF_FLAG_REQUIRE_PRIVATE);
1167     if (!SSL_CONF_CTX_set1_prefix(c_cctx, "-c_")) {
1168         ERR_print_errors(bio_err);
1169         goto end;
1170     }
1171
1172     argc--;
1173     argv++;
1174
1175     while (argc >= 1) {
1176         if (strcmp(*argv, "-F") == 0) {
1177 #ifdef OPENSSL_FIPS
1178             fips_mode = 1;
1179 #else
1180             fprintf(stderr,
1181                     "not compiled with FIPS support, so exiting without running.\n");
1182             EXIT(0);
1183 #endif
1184         } else if (strcmp(*argv, "-server_auth") == 0)
1185             server_auth = 1;
1186         else if (strcmp(*argv, "-client_auth") == 0)
1187             client_auth = 1;
1188         else if (strcmp(*argv, "-proxy_auth") == 0) {
1189             if (--argc < 1)
1190                 goto bad;
1191             app_verify_arg.proxy_auth = *(++argv);
1192         } else if (strcmp(*argv, "-proxy_cond") == 0) {
1193             if (--argc < 1)
1194                 goto bad;
1195             app_verify_arg.proxy_cond = *(++argv);
1196         } else if (strcmp(*argv, "-v") == 0)
1197             verbose = 1;
1198         else if (strcmp(*argv, "-d") == 0)
1199             debug = 1;
1200         else if (strcmp(*argv, "-reuse") == 0)
1201             reuse = 1;
1202         else if (strcmp(*argv, "-dhe512") == 0) {
1203 #ifndef OPENSSL_NO_DH
1204             dhe512 = 1;
1205 #else
1206             fprintf(stderr,
1207                     "ignoring -dhe512, since I'm compiled without DH\n");
1208 #endif
1209         } else if (strcmp(*argv, "-dhe1024dsa") == 0) {
1210 #ifndef OPENSSL_NO_DH
1211             dhe1024dsa = 1;
1212 #else
1213             fprintf(stderr,
1214                     "ignoring -dhe1024dsa, since I'm compiled without DH\n");
1215 #endif
1216         } else if (strcmp(*argv, "-no_dhe") == 0)
1217             no_dhe = 1;
1218         else if (strcmp(*argv, "-no_ecdhe") == 0)
1219             /* obsolete */;
1220         else if (strcmp(*argv, "-psk") == 0) {
1221             if (--argc < 1)
1222                 goto bad;
1223             psk_key = *(++argv);
1224 #ifndef OPENSSL_NO_PSK
1225             if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key)) {
1226                 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
1227                 goto bad;
1228             }
1229 #else
1230             no_psk = 1;
1231 #endif
1232         }
1233 #ifndef OPENSSL_NO_SRP
1234         else if (strcmp(*argv, "-srpuser") == 0) {
1235             if (--argc < 1)
1236                 goto bad;
1237             srp_server_arg.expected_user = srp_client_arg.srplogin =
1238                 *(++argv);
1239             min_version = TLS1_VERSION;
1240         } else if (strcmp(*argv, "-srppass") == 0) {
1241             if (--argc < 1)
1242                 goto bad;
1243             srp_server_arg.pass = srp_client_arg.srppassin = *(++argv);
1244             min_version = TLS1_VERSION;
1245         }
1246 #endif
1247         else if (strcmp(*argv, "-tls1") == 0) {
1248             tls1 = 1;
1249         } else if (strcmp(*argv, "-ssl3") == 0) {
1250             ssl3 = 1;
1251         } else if (strcmp(*argv, "-dtls1") == 0) {
1252             dtls1 = 1;
1253         } else if (strcmp(*argv, "-dtls12") == 0) {
1254             dtls12 = 1;
1255         } else if (strcmp(*argv, "-dtls") == 0) {
1256             dtls = 1;
1257         } else if (strncmp(*argv, "-num", 4) == 0) {
1258             if (--argc < 1)
1259                 goto bad;
1260             number = atoi(*(++argv));
1261             if (number == 0)
1262                 number = 1;
1263         } else if (strcmp(*argv, "-bytes") == 0) {
1264             if (--argc < 1)
1265                 goto bad;
1266             bytes = atol(*(++argv));
1267             if (bytes == 0L)
1268                 bytes = 1L;
1269             i = strlen(argv[0]);
1270             if (argv[0][i - 1] == 'k')
1271                 bytes *= 1024L;
1272             if (argv[0][i - 1] == 'm')
1273                 bytes *= 1024L * 1024L;
1274         } else if (strcmp(*argv, "-cipher") == 0) {
1275             if (--argc < 1)
1276                 goto bad;
1277             cipher = *(++argv);
1278         } else if (strcmp(*argv, "-CApath") == 0) {
1279             if (--argc < 1)
1280                 goto bad;
1281             CApath = *(++argv);
1282         } else if (strcmp(*argv, "-CAfile") == 0) {
1283             if (--argc < 1)
1284                 goto bad;
1285             CAfile = *(++argv);
1286         } else if (strcmp(*argv, "-bio_pair") == 0) {
1287             bio_type = BIO_PAIR;
1288         }
1289 #ifndef OPENSSL_NO_SOCK
1290         else if (strcmp(*argv, "-ipv4") == 0) {
1291             bio_type = BIO_IPV4;
1292         } else if (strcmp(*argv, "-ipv6") == 0) {
1293             bio_type = BIO_IPV6;
1294         }
1295 #endif
1296         else if (strcmp(*argv, "-f") == 0) {
1297             force = 1;
1298         } else if (strcmp(*argv, "-time") == 0) {
1299             print_time = 1;
1300         }
1301 #ifndef OPENSSL_NO_CT
1302         else if (strcmp(*argv, "-noct") == 0) {
1303             ct_validation = NULL;
1304         }
1305         else if (strcmp(*argv, "-requestct") == 0) {
1306             ct_validation = CT_verify_no_bad_scts;
1307         }
1308         else if (strcmp(*argv, "-requirect") == 0) {
1309             ct_validation = CT_verify_at_least_one_good_sct;
1310         }
1311 #endif
1312 #ifndef OPENSSL_NO_COMP
1313         else if (strcmp(*argv, "-zlib") == 0) {
1314             comp = COMP_ZLIB;
1315         }
1316 #endif
1317         else if (strcmp(*argv, "-app_verify") == 0) {
1318             app_verify_arg.app_verify = 1;
1319         } else if (strcmp(*argv, "-proxy") == 0) {
1320             app_verify_arg.allow_proxy_certs = 1;
1321         } else if (strcmp(*argv, "-test_cipherlist") == 0) {
1322             test_cipherlist = 1;
1323         }
1324 #ifndef OPENSSL_NO_NEXTPROTONEG
1325         else if (strcmp(*argv, "-npn_client") == 0) {
1326             npn_client = 1;
1327         } else if (strcmp(*argv, "-npn_server") == 0) {
1328             npn_server = 1;
1329         } else if (strcmp(*argv, "-npn_server_reject") == 0) {
1330             npn_server_reject = 1;
1331         }
1332 #endif
1333         else if (strcmp(*argv, "-serverinfo_sct") == 0) {
1334             serverinfo_sct = 1;
1335         } else if (strcmp(*argv, "-serverinfo_tack") == 0) {
1336             serverinfo_tack = 1;
1337         } else if (strcmp(*argv, "-serverinfo_file") == 0) {
1338             if (--argc < 1)
1339                 goto bad;
1340             serverinfo_file = *(++argv);
1341         } else if (strcmp(*argv, "-custom_ext") == 0) {
1342             custom_ext = 1;
1343         } else if (strcmp(*argv, "-alpn_client") == 0) {
1344             if (--argc < 1)
1345                 goto bad;
1346             alpn_client = *(++argv);
1347         } else if (strcmp(*argv, "-alpn_server") == 0 ||
1348                    strcmp(*argv, "-alpn_server1") == 0) {
1349             if (--argc < 1)
1350                 goto bad;
1351             alpn_server = *(++argv);
1352         } else if (strcmp(*argv, "-alpn_server2") == 0) {
1353             if (--argc < 1)
1354                 goto bad;
1355             alpn_server2 = *(++argv);
1356         } else if (strcmp(*argv, "-alpn_expected") == 0) {
1357             if (--argc < 1)
1358                 goto bad;
1359             alpn_expected = *(++argv);
1360         } else if (strcmp(*argv, "-server_min_proto") == 0) {
1361             if (--argc < 1)
1362                 goto bad;
1363             server_min_proto = *(++argv);
1364         } else if (strcmp(*argv, "-server_max_proto") == 0) {
1365             if (--argc < 1)
1366                 goto bad;
1367             server_max_proto = *(++argv);
1368         } else if (strcmp(*argv, "-client_min_proto") == 0) {
1369             if (--argc < 1)
1370                 goto bad;
1371             client_min_proto = *(++argv);
1372         } else if (strcmp(*argv, "-client_max_proto") == 0) {
1373             if (--argc < 1)
1374                 goto bad;
1375             client_max_proto = *(++argv);
1376         } else if (strcmp(*argv, "-should_negotiate") == 0) {
1377             if (--argc < 1)
1378                 goto bad;
1379             should_negotiate = *(++argv);
1380         } else if (strcmp(*argv, "-sn_client") == 0) {
1381             if (--argc < 1)
1382                 goto bad;
1383             sn_client = *(++argv);
1384         } else if (strcmp(*argv, "-sn_server1") == 0) {
1385             if (--argc < 1)
1386                 goto bad;
1387             sn_server1 = *(++argv);
1388         } else if (strcmp(*argv, "-sn_server2") == 0) {
1389             if (--argc < 1)
1390                 goto bad;
1391             sn_server2 = *(++argv);
1392         } else if (strcmp(*argv, "-sn_expect1") == 0) {
1393             sn_expect = 1;
1394         } else if (strcmp(*argv, "-sn_expect2") == 0) {
1395             sn_expect = 2;
1396         } else if (strcmp(*argv, "-server_sess_out") == 0) {
1397             if (--argc < 1)
1398                 goto bad;
1399             server_sess_out = *(++argv);
1400         } else if (strcmp(*argv, "-server_sess_in") == 0) {
1401             if (--argc < 1)
1402                 goto bad;
1403             server_sess_in = *(++argv);
1404         } else if (strcmp(*argv, "-client_sess_out") == 0) {
1405             if (--argc < 1)
1406                 goto bad;
1407             client_sess_out = *(++argv);
1408         } else if (strcmp(*argv, "-client_sess_in") == 0) {
1409             if (--argc < 1)
1410                 goto bad;
1411             client_sess_in = *(++argv);
1412         } else if (strcmp(*argv, "-should_reuse") == 0) {
1413             if (--argc < 1)
1414                 goto bad;
1415             should_reuse = !!atoi(*(++argv));
1416         } else if (strcmp(*argv, "-no_ticket") == 0) {
1417             no_ticket = 1;
1418         } else {
1419             int rv;
1420             arg = argv[0];
1421             argn = argv[1];
1422             /* Try to process command using SSL_CONF */
1423             rv = SSL_CONF_cmd_argv(c_cctx, &argc, &argv);
1424             /* If not processed try server */
1425             if (rv == 0)
1426                 rv = SSL_CONF_cmd_argv(s_cctx, &argc, &argv);
1427             /* Recognised: store it for later use */
1428             if (rv > 0) {
1429                 if (rv == 1)
1430                     argn = NULL;
1431                 if (!conf_args) {
1432                     conf_args = sk_OPENSSL_STRING_new_null();
1433                     if (!conf_args)
1434                         goto end;
1435                 }
1436                 if (!sk_OPENSSL_STRING_push(conf_args, arg))
1437                     goto end;
1438                 if (!sk_OPENSSL_STRING_push(conf_args, argn))
1439                     goto end;
1440                 continue;
1441             }
1442             if (rv == -3)
1443                 BIO_printf(bio_err, "Missing argument for %s\n", arg);
1444             else if (rv < 0)
1445                 BIO_printf(bio_err, "Error with command %s\n", arg);
1446             else if (rv == 0)
1447                 BIO_printf(bio_err, "unknown option %s\n", arg);
1448             badop = 1;
1449             break;
1450         }
1451         argc--;
1452         argv++;
1453     }
1454     if (badop) {
1455  bad:
1456         sv_usage();
1457         goto end;
1458     }
1459
1460     /*
1461      * test_cipherlist prevails over protocol switch: we test the cipherlist
1462      * for all enabled protocols.
1463      */
1464     if (test_cipherlist == 1) {
1465         /*
1466          * ensure that the cipher list are correctly sorted and exit
1467          */
1468         fprintf(stdout, "Testing cipherlist order only. Ignoring all "
1469                 "other options.\n");
1470         if (do_test_cipherlist() == 0)
1471             EXIT(1);
1472         ret = 0;
1473         goto end;
1474     }
1475
1476     if (ssl3 + tls1 + dtls + dtls1 + dtls12 > 1) {
1477         fprintf(stderr, "At most one of -ssl3, -tls1, -dtls, -dtls1 or -dtls12 should "
1478                 "be requested.\n");
1479         EXIT(1);
1480     }
1481
1482 #ifdef OPENSSL_NO_SSL3
1483     if (ssl3)
1484         no_protocol = 1;
1485     else
1486 #endif
1487 #ifdef OPENSSL_NO_TLS1
1488     if (tls1)
1489         no_protocol = 1;
1490     else
1491 #endif
1492 #if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1)
1493     if (dtls1)
1494         no_protocol = 1;
1495     else
1496 #endif
1497 #if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1_2)
1498     if (dtls12)
1499         no_protocol = 1;
1500     else
1501 #endif
1502         no_protocol = 0;
1503
1504     /*
1505      * Testing was requested for a compiled-out protocol (e.g. SSLv3).
1506      * Ideally, we would error out, but the generic test wrapper can't know
1507      * when to expect failure. So we do nothing and return success.
1508      */
1509     if (no_protocol) {
1510         fprintf(stderr, "Testing was requested for a disabled protocol. "
1511                 "Skipping tests.\n");
1512         ret = 0;
1513         goto end;
1514     }
1515
1516     if (!ssl3 && !tls1 && !dtls && !dtls1 && !dtls12 && number > 1 && !reuse && !force) {
1517         fprintf(stderr, "This case cannot work.  Use -f to perform "
1518                 "the test anyway (and\n-d to see what happens), "
1519                 "or add one of -ssl3, -tls1, -dtls, -dtls1, -dtls12, -reuse\n"
1520                 "to avoid protocol mismatch.\n");
1521         EXIT(1);
1522     }
1523 #ifdef OPENSSL_FIPS
1524     if (fips_mode) {
1525         if (!FIPS_mode_set(1)) {
1526             ERR_print_errors(bio_err);
1527             EXIT(1);
1528         } else
1529             fprintf(stderr, "*** IN FIPS MODE ***\n");
1530     }
1531 #endif
1532
1533     if (print_time) {
1534         if (bio_type != BIO_PAIR) {
1535             fprintf(stderr, "Using BIO pair (-bio_pair)\n");
1536             bio_type = BIO_PAIR;
1537         }
1538         if (number < 50 && !force)
1539             fprintf(stderr,
1540                     "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
1541     }
1542
1543 /*      if (cipher == NULL) cipher=getenv("SSL_CIPHER"); */
1544
1545 #ifndef OPENSSL_NO_COMP
1546     if (comp == COMP_ZLIB)
1547         cm = COMP_zlib();
1548     if (cm != NULL) {
1549         if (COMP_get_type(cm) != NID_undef) {
1550             if (SSL_COMP_add_compression_method(comp, cm) != 0) {
1551                 fprintf(stderr, "Failed to add compression method\n");
1552                 ERR_print_errors_fp(stderr);
1553             }
1554         } else {
1555             fprintf(stderr,
1556                     "Warning: %s compression not supported\n",
1557                     comp == COMP_ZLIB ? "zlib" : "unknown");
1558             ERR_print_errors_fp(stderr);
1559         }
1560     }
1561     ssl_comp_methods = SSL_COMP_get_compression_methods();
1562     n = sk_SSL_COMP_num(ssl_comp_methods);
1563     if (n) {
1564         int j;
1565         printf("Available compression methods:");
1566         for (j = 0; j < n; j++) {
1567             SSL_COMP *c = sk_SSL_COMP_value(ssl_comp_methods, j);
1568             printf("  %s:%d", c->name, c->id);
1569         }
1570         printf("\n");
1571     }
1572 #endif
1573
1574 #ifndef OPENSSL_NO_TLS
1575     meth = TLS_method();
1576     if (ssl3) {
1577         min_version = SSL3_VERSION;
1578         max_version = SSL3_VERSION;
1579     } else if (tls1) {
1580         min_version = TLS1_VERSION;
1581         max_version = TLS1_VERSION;
1582     }
1583 #endif
1584 #ifndef OPENSSL_NO_DTLS
1585     if (dtls || dtls1 || dtls12)
1586         meth = DTLS_method();
1587     if (dtls1) {
1588         min_version = DTLS1_VERSION;
1589         max_version = DTLS1_VERSION;
1590     } else if (dtls12) {
1591         min_version = DTLS1_2_VERSION;
1592         max_version = DTLS1_2_VERSION;
1593     }
1594 #endif
1595
1596     c_ctx = SSL_CTX_new(meth);
1597     s_ctx = SSL_CTX_new(meth);
1598     s_ctx2 = SSL_CTX_new(meth); /* no SSL_CTX_dup! */
1599     if ((c_ctx == NULL) || (s_ctx == NULL) || (s_ctx2 == NULL)) {
1600         ERR_print_errors(bio_err);
1601         goto end;
1602     }
1603     /*
1604      * Since we will use low security ciphersuites and keys for testing set
1605      * security level to zero by default. Tests can override this by adding
1606      * "@SECLEVEL=n" to the cipher string.
1607      */
1608     SSL_CTX_set_security_level(c_ctx, 0);
1609     SSL_CTX_set_security_level(s_ctx, 0);
1610     SSL_CTX_set_security_level(s_ctx2, 0);
1611
1612     if (no_ticket) {
1613         SSL_CTX_set_options(c_ctx, SSL_OP_NO_TICKET);
1614         SSL_CTX_set_options(s_ctx, SSL_OP_NO_TICKET);
1615     }
1616
1617     if (SSL_CTX_set_min_proto_version(c_ctx, min_version) == 0)
1618         goto end;
1619     if (SSL_CTX_set_max_proto_version(c_ctx, max_version) == 0)
1620         goto end;
1621     if (SSL_CTX_set_min_proto_version(s_ctx, min_version) == 0)
1622         goto end;
1623     if (SSL_CTX_set_max_proto_version(s_ctx, max_version) == 0)
1624         goto end;
1625
1626     if (cipher != NULL) {
1627         if (!SSL_CTX_set_cipher_list(c_ctx, cipher)
1628             || !SSL_CTX_set_cipher_list(s_ctx, cipher)
1629             || !SSL_CTX_set_cipher_list(s_ctx2, cipher)) {
1630             ERR_print_errors(bio_err);
1631             goto end;
1632         }
1633     }
1634
1635 #ifndef OPENSSL_NO_CT
1636     if (!SSL_CTX_set_ct_validation_callback(c_ctx, ct_validation, NULL)) {
1637         ERR_print_errors(bio_err);
1638         goto end;
1639     }
1640 #endif
1641
1642     /* Process SSL_CONF arguments */
1643     SSL_CONF_CTX_set_ssl_ctx(c_cctx, c_ctx);
1644     SSL_CONF_CTX_set_ssl_ctx(s_cctx, s_ctx);
1645     SSL_CONF_CTX_set_ssl_ctx(s_cctx2, s_ctx2);
1646
1647     for (i = 0; i < sk_OPENSSL_STRING_num(conf_args); i += 2) {
1648         int rv;
1649         arg = sk_OPENSSL_STRING_value(conf_args, i);
1650         argn = sk_OPENSSL_STRING_value(conf_args, i + 1);
1651         rv = SSL_CONF_cmd(c_cctx, arg, argn);
1652         /* If not recognised use server context */
1653         if (rv == -2) {
1654             rv = SSL_CONF_cmd(s_cctx2, arg, argn);
1655             if (rv > 0)
1656                 rv = SSL_CONF_cmd(s_cctx, arg, argn);
1657         }
1658         if (rv <= 0) {
1659             BIO_printf(bio_err, "Error processing %s %s\n",
1660                        arg, argn ? argn : "");
1661             ERR_print_errors(bio_err);
1662             goto end;
1663         }
1664     }
1665
1666     if (!SSL_CONF_CTX_finish(s_cctx) || !SSL_CONF_CTX_finish(c_cctx) || !SSL_CONF_CTX_finish(s_cctx2)) {
1667         BIO_puts(bio_err, "Error finishing context\n");
1668         ERR_print_errors(bio_err);
1669         goto end;
1670     }
1671 #ifndef OPENSSL_NO_DH
1672     if (!no_dhe) {
1673         if (dhe1024dsa) {
1674             dh = get_dh1024dsa();
1675         } else if (dhe512)
1676             dh = get_dh512();
1677         else
1678             dh = get_dh1024();
1679         SSL_CTX_set_tmp_dh(s_ctx, dh);
1680         SSL_CTX_set_tmp_dh(s_ctx2, dh);
1681         DH_free(dh);
1682     }
1683 #else
1684     (void)no_dhe;
1685 #endif
1686
1687     if ((!SSL_CTX_load_verify_locations(s_ctx, CAfile, CApath)) ||
1688         (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1689         (!SSL_CTX_load_verify_locations(s_ctx2, CAfile, CApath)) ||
1690         (!SSL_CTX_set_default_verify_paths(s_ctx2)) ||
1691         (!SSL_CTX_load_verify_locations(c_ctx, CAfile, CApath)) ||
1692         (!SSL_CTX_set_default_verify_paths(c_ctx))) {
1693         /* fprintf(stderr,"SSL_load_verify_locations\n"); */
1694         ERR_print_errors(bio_err);
1695         /* goto end; */
1696     }
1697
1698 #ifndef OPENSSL_NO_CT
1699     if (!SSL_CTX_set_default_ctlog_list_file(s_ctx) ||
1700         !SSL_CTX_set_default_ctlog_list_file(s_ctx2) ||
1701         !SSL_CTX_set_default_ctlog_list_file(c_ctx)) {
1702         ERR_print_errors(bio_err);
1703     }
1704 #endif
1705
1706     if (client_auth) {
1707         printf("client authentication\n");
1708         SSL_CTX_set_verify(s_ctx,
1709                            SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1710                            verify_callback);
1711         SSL_CTX_set_verify(s_ctx2,
1712                            SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1713                            verify_callback);
1714         SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback,
1715                                          &app_verify_arg);
1716         SSL_CTX_set_cert_verify_callback(s_ctx2, app_verify_callback,
1717                                          &app_verify_arg);
1718     }
1719     if (server_auth) {
1720         printf("server authentication\n");
1721         SSL_CTX_set_verify(c_ctx, SSL_VERIFY_PEER, verify_callback);
1722         SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback,
1723                                          &app_verify_arg);
1724     }
1725
1726     {
1727         int session_id_context = 0;
1728         if (!SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context,
1729                                             sizeof session_id_context) ||
1730             !SSL_CTX_set_session_id_context(s_ctx2, (void *)&session_id_context,
1731                                             sizeof session_id_context)) {
1732             ERR_print_errors(bio_err);
1733             goto end;
1734         }
1735     }
1736
1737     /* Use PSK only if PSK key is given */
1738     if (psk_key != NULL) {
1739         /*
1740          * no_psk is used to avoid putting psk command to openssl tool
1741          */
1742         if (no_psk) {
1743             /*
1744              * if PSK is not compiled in and psk key is given, do nothing and
1745              * exit successfully
1746              */
1747             ret = 0;
1748             goto end;
1749         }
1750 #ifndef OPENSSL_NO_PSK
1751         SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1752         SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1753         SSL_CTX_set_psk_server_callback(s_ctx2, psk_server_callback);
1754         if (debug)
1755             BIO_printf(bio_err, "setting PSK identity hint to s_ctx\n");
1756         if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint") ||
1757             !SSL_CTX_use_psk_identity_hint(s_ctx2, "ctx server identity_hint")) {
1758             BIO_printf(bio_err, "error setting PSK identity hint to s_ctx\n");
1759             ERR_print_errors(bio_err);
1760             goto end;
1761         }
1762 #endif
1763     }
1764 #ifndef OPENSSL_NO_SRP
1765     if (srp_client_arg.srplogin) {
1766         if (!SSL_CTX_set_srp_username(c_ctx, srp_client_arg.srplogin)) {
1767             BIO_printf(bio_err, "Unable to set SRP username\n");
1768             goto end;
1769         }
1770         SSL_CTX_set_srp_cb_arg(c_ctx, &srp_client_arg);
1771         SSL_CTX_set_srp_client_pwd_callback(c_ctx,
1772                                             ssl_give_srp_client_pwd_cb);
1773         /*
1774          * SSL_CTX_set_srp_strength(c_ctx, srp_client_arg.strength);
1775          */
1776     }
1777
1778     if (srp_server_arg.expected_user != NULL) {
1779         SSL_CTX_set_verify(s_ctx, SSL_VERIFY_NONE, verify_callback);
1780         SSL_CTX_set_verify(s_ctx2, SSL_VERIFY_NONE, verify_callback);
1781         SSL_CTX_set_srp_cb_arg(s_ctx, &srp_server_arg);
1782         SSL_CTX_set_srp_cb_arg(s_ctx2, &srp_server_arg);
1783         SSL_CTX_set_srp_username_callback(s_ctx, ssl_srp_server_param_cb);
1784         SSL_CTX_set_srp_username_callback(s_ctx2, ssl_srp_server_param_cb);
1785     }
1786 #endif
1787
1788 #ifndef OPENSSL_NO_NEXTPROTONEG
1789     if (npn_client) {
1790         SSL_CTX_set_next_proto_select_cb(c_ctx, cb_client_npn, NULL);
1791     }
1792     if (npn_server) {
1793         if (npn_server_reject) {
1794             BIO_printf(bio_err,
1795                        "Can't have both -npn_server and -npn_server_reject\n");
1796             goto end;
1797         }
1798         SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_npn, NULL);
1799         SSL_CTX_set_next_protos_advertised_cb(s_ctx2, cb_server_npn, NULL);
1800     }
1801     if (npn_server_reject) {
1802         SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_rejects_npn,
1803                                               NULL);
1804         SSL_CTX_set_next_protos_advertised_cb(s_ctx2, cb_server_rejects_npn,
1805                                               NULL);
1806     }
1807 #endif
1808
1809     if (serverinfo_sct) {
1810         if (!SSL_CTX_add_client_custom_ext(c_ctx,
1811                 TLSEXT_TYPE_signed_certificate_timestamp,
1812                 NULL, NULL, NULL,
1813                 serverinfo_cli_parse_cb, NULL)) {
1814             BIO_printf(bio_err, "Error adding SCT extension\n");
1815             goto end;
1816         }
1817     }
1818     if (serverinfo_tack) {
1819         if (!SSL_CTX_add_client_custom_ext(c_ctx, TACK_EXT_TYPE,
1820                                       NULL, NULL, NULL,
1821                                       serverinfo_cli_parse_cb, NULL)) {
1822             BIO_printf(bio_err, "Error adding TACK extension\n");
1823             goto end;
1824         }
1825     }
1826     if (serverinfo_file)
1827         if (!SSL_CTX_use_serverinfo_file(s_ctx, serverinfo_file) ||
1828             !SSL_CTX_use_serverinfo_file(s_ctx2, serverinfo_file)) {
1829             BIO_printf(bio_err, "missing serverinfo file\n");
1830             goto end;
1831         }
1832
1833     if (custom_ext) {
1834         if (!SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_0,
1835                                       custom_ext_0_cli_add_cb,
1836                                       NULL, NULL,
1837                                       custom_ext_0_cli_parse_cb, NULL)
1838             || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_1,
1839                                       custom_ext_1_cli_add_cb,
1840                                       NULL, NULL,
1841                                       custom_ext_1_cli_parse_cb, NULL)
1842             || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_2,
1843                                       custom_ext_2_cli_add_cb,
1844                                       NULL, NULL,
1845                                       custom_ext_2_cli_parse_cb, NULL)
1846             || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_3,
1847                                       custom_ext_3_cli_add_cb,
1848                                       NULL, NULL,
1849                                       custom_ext_3_cli_parse_cb, NULL)
1850             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_0,
1851                                       custom_ext_0_srv_add_cb,
1852                                       NULL, NULL,
1853                                       custom_ext_0_srv_parse_cb, NULL)
1854             || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_0,
1855                                       custom_ext_0_srv_add_cb,
1856                                       NULL, NULL,
1857                                       custom_ext_0_srv_parse_cb, NULL)
1858             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_1,
1859                                       custom_ext_1_srv_add_cb,
1860                                       NULL, NULL,
1861                                       custom_ext_1_srv_parse_cb, NULL)
1862             || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_1,
1863                                       custom_ext_1_srv_add_cb,
1864                                       NULL, NULL,
1865                                       custom_ext_1_srv_parse_cb, NULL)
1866             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_2,
1867                                       custom_ext_2_srv_add_cb,
1868                                       NULL, NULL,
1869                                       custom_ext_2_srv_parse_cb, NULL)
1870             || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_2,
1871                                       custom_ext_2_srv_add_cb,
1872                                       NULL, NULL,
1873                                       custom_ext_2_srv_parse_cb, NULL)
1874             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_3,
1875                                       custom_ext_3_srv_add_cb,
1876                                       NULL, NULL,
1877                                       custom_ext_3_srv_parse_cb, NULL)
1878             || !SSL_CTX_add_server_custom_ext(s_ctx2, CUSTOM_EXT_TYPE_3,
1879                                       custom_ext_3_srv_add_cb,
1880                                       NULL, NULL,
1881                                       custom_ext_3_srv_parse_cb, NULL)) {
1882             BIO_printf(bio_err, "Error setting custom extensions\n");
1883             goto end;
1884         }
1885     }
1886
1887     if (alpn_server)
1888         SSL_CTX_set_alpn_select_cb(s_ctx, cb_server_alpn, alpn_server);
1889     if (alpn_server2)
1890         SSL_CTX_set_alpn_select_cb(s_ctx2, cb_server_alpn, alpn_server2);
1891
1892     if (alpn_client) {
1893         size_t alpn_len;
1894         unsigned char *alpn = next_protos_parse(&alpn_len, alpn_client);
1895
1896         if (alpn == NULL) {
1897             BIO_printf(bio_err, "Error parsing -alpn_client argument\n");
1898             goto end;
1899         }
1900         /* Returns 0 on success!! */
1901         if (SSL_CTX_set_alpn_protos(c_ctx, alpn, alpn_len)) {
1902             BIO_printf(bio_err, "Error setting ALPN\n");
1903             OPENSSL_free(alpn);
1904             goto end;
1905         }
1906         OPENSSL_free(alpn);
1907     }
1908
1909     if (server_sess_in != NULL) {
1910         server_sess = read_session(server_sess_in);
1911         if (server_sess == NULL)
1912             goto end;
1913     }
1914     if (client_sess_in != NULL) {
1915         client_sess = read_session(client_sess_in);
1916         if (client_sess == NULL)
1917             goto end;
1918     }
1919
1920     if (server_sess_out != NULL || server_sess_in != NULL) {
1921         char *keys;
1922         long size;
1923
1924         /* Use a fixed key so that we can decrypt the ticket. */
1925         size = SSL_CTX_set_tlsext_ticket_keys(s_ctx, NULL, 0);
1926         keys = OPENSSL_zalloc(size);
1927         SSL_CTX_set_tlsext_ticket_keys(s_ctx, keys, size);
1928         OPENSSL_free(keys);
1929     }
1930
1931     if (sn_server1 != NULL || sn_server2 != NULL)
1932         SSL_CTX_set_tlsext_servername_callback(s_ctx, servername_cb);
1933
1934     c_ssl = SSL_new(c_ctx);
1935     s_ssl = SSL_new(s_ctx);
1936
1937     if (sn_client)
1938         SSL_set_tlsext_host_name(c_ssl, sn_client);
1939
1940     if (!set_protocol_version(server_min_proto, s_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1941         goto end;
1942     if (!set_protocol_version(server_max_proto, s_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1943         goto end;
1944     if (!set_protocol_version(client_min_proto, c_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1945         goto end;
1946     if (!set_protocol_version(client_max_proto, c_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1947         goto end;
1948
1949     if (server_sess) {
1950         if (SSL_CTX_add_session(s_ctx, server_sess) == 0) {
1951             BIO_printf(bio_err, "Can't add server session\n");
1952             ERR_print_errors(bio_err);
1953             goto end;
1954         }
1955     }
1956
1957     BIO_printf(bio_stdout, "Doing handshakes=%d bytes=%ld\n", number, bytes);
1958     for (i = 0; i < number; i++) {
1959         if (!reuse) {
1960             if (!SSL_set_session(c_ssl, NULL)) {
1961                 BIO_printf(bio_err, "Failed to set session\n");
1962                 goto end;
1963             }
1964         }
1965         if (client_sess_in != NULL) {
1966             if (SSL_set_session(c_ssl, client_sess) == 0) {
1967                 BIO_printf(bio_err, "Can't set client session\n");
1968                 ERR_print_errors(bio_err);
1969                 goto end;
1970             }
1971         }
1972         switch (bio_type) {
1973         case BIO_MEM:
1974             ret = doit(s_ssl, c_ssl, bytes);
1975             break;
1976         case BIO_PAIR:
1977             ret = doit_biopair(s_ssl, c_ssl, bytes, &s_time, &c_time);
1978             break;
1979 #ifndef OPENSSL_NO_SOCK
1980         case BIO_IPV4:
1981             ret = doit_localhost(s_ssl, c_ssl, BIO_FAMILY_IPV4,
1982                                  bytes, &s_time, &c_time);
1983             break;
1984         case BIO_IPV6:
1985             ret = doit_localhost(s_ssl, c_ssl, BIO_FAMILY_IPV6,
1986                                  bytes, &s_time, &c_time);
1987             break;
1988 #else
1989         case BIO_IPV4:
1990         case BIO_IPV6:
1991             ret = 1;
1992             goto err;
1993 #endif
1994         }
1995         if (ret)  break;
1996     }
1997
1998     if (should_negotiate && ret == 0 &&
1999         strcmp(should_negotiate, "fail-server") != 0 &&
2000         strcmp(should_negotiate, "fail-client") != 0) {
2001         int version = protocol_from_string(should_negotiate);
2002         if (version < 0) {
2003             BIO_printf(bio_err, "Error parsing: %s\n", should_negotiate);
2004             ret = 1;
2005             goto err;
2006         }
2007         if (SSL_version(c_ssl) != version) {
2008             BIO_printf(bio_err, "Unxpected version negotiated. "
2009                 "Expected: %s, got %s\n", should_negotiate, SSL_get_version(c_ssl));
2010             ret = 1;
2011             goto err;
2012         }
2013     }
2014
2015     if (should_reuse != -1) {
2016         if (SSL_session_reused(s_ssl) != should_reuse ||
2017             SSL_session_reused(c_ssl) != should_reuse) {
2018             BIO_printf(bio_err, "Unexpected session reuse state. "
2019                 "Expected: %d, server: %d, client: %d\n", should_reuse,
2020                 SSL_session_reused(s_ssl), SSL_session_reused(c_ssl));
2021             ret = 1;
2022             goto err;
2023         }
2024     }
2025
2026     if (server_sess_out != NULL) {
2027         if (write_session(server_sess_out, SSL_get_session(s_ssl)) == 0) {
2028             ret = 1;
2029             goto err;
2030         }
2031     }
2032     if (client_sess_out != NULL) {
2033         if (write_session(client_sess_out, SSL_get_session(c_ssl)) == 0) {
2034             ret = 1;
2035             goto err;
2036         }
2037     }
2038
2039     if (!verbose) {
2040         print_details(c_ssl, "");
2041     }
2042     if (print_time) {
2043 #ifdef CLOCKS_PER_SEC
2044         /*
2045          * "To determine the time in seconds, the value returned by the clock
2046          * function should be divided by the value of the macro
2047          * CLOCKS_PER_SEC." -- ISO/IEC 9899
2048          */
2049         BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
2050                    "Approximate total client time: %6.2f s\n",
2051                    (double)s_time / CLOCKS_PER_SEC,
2052                    (double)c_time / CLOCKS_PER_SEC);
2053 #else
2054         BIO_printf(bio_stdout,
2055                    "Approximate total server time: %6.2f units\n"
2056                    "Approximate total client time: %6.2f units\n",
2057                    (double)s_time, (double)c_time);
2058 #endif
2059     }
2060
2061  err:
2062     SSL_free(s_ssl);
2063     SSL_free(c_ssl);
2064
2065  end:
2066     SSL_CTX_free(s_ctx);
2067     SSL_CTX_free(s_ctx2);
2068     SSL_CTX_free(c_ctx);
2069     SSL_CONF_CTX_free(s_cctx);
2070     SSL_CONF_CTX_free(s_cctx2);
2071     SSL_CONF_CTX_free(c_cctx);
2072     sk_OPENSSL_STRING_free(conf_args);
2073
2074     BIO_free(bio_stdout);
2075
2076     SSL_SESSION_free(server_sess);
2077     SSL_SESSION_free(client_sess);
2078
2079 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
2080     if (CRYPTO_mem_leaks(bio_err) <= 0)
2081         ret = 1;
2082 #endif
2083     BIO_free(bio_err);
2084     EXIT(ret);
2085 }
2086
2087 #ifndef OPENSSL_NO_SOCK
2088 int doit_localhost(SSL *s_ssl, SSL *c_ssl, int family, long count,
2089                    clock_t *s_time, clock_t *c_time)
2090 {
2091     long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
2092     BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
2093     BIO *acpt = NULL, *server = NULL, *client = NULL;
2094     char addr_str[40];
2095     int ret = 1;
2096     int err_in_client = 0;
2097     int err_in_server = 0;
2098
2099     acpt = BIO_new_accept("0");
2100     if (acpt == NULL)
2101         goto err;
2102     BIO_set_accept_ip_family(acpt, family);
2103     BIO_set_bind_mode(acpt, BIO_SOCK_NONBLOCK | BIO_SOCK_REUSEADDR);
2104     if (BIO_do_accept(acpt) <= 0)
2105         goto err;
2106
2107     BIO_snprintf(addr_str, sizeof(addr_str), ":%s", BIO_get_accept_port(acpt));
2108
2109     client = BIO_new_connect(addr_str);
2110     BIO_set_conn_ip_family(client, family);
2111     if (!client)
2112         goto err;
2113
2114     if (BIO_set_nbio(client, 1) <= 0)
2115         goto err;
2116     if (BIO_set_nbio(acpt, 1) <= 0)
2117         goto err;
2118
2119     {
2120         int st_connect = 0, st_accept = 0;
2121
2122         while(!st_connect || !st_accept) {
2123             if (!st_connect) {
2124                 if (BIO_do_connect(client) <= 0) {
2125                     if (!BIO_should_retry(client))
2126                         goto err;
2127                 } else {
2128                     st_connect = 1;
2129                 }
2130             }
2131             if (!st_accept) {
2132                 if (BIO_do_accept(acpt) <= 0) {
2133                     if (!BIO_should_retry(acpt))
2134                         goto err;
2135                 } else {
2136                     st_accept = 1;
2137                 }
2138             }
2139         }
2140     }
2141     /* We're not interested in accepting further connects */
2142     server = BIO_pop(acpt);
2143     BIO_free_all(acpt);
2144     acpt = NULL;
2145
2146     s_ssl_bio = BIO_new(BIO_f_ssl());
2147     if (!s_ssl_bio)
2148         goto err;
2149
2150     c_ssl_bio = BIO_new(BIO_f_ssl());
2151     if (!c_ssl_bio)
2152         goto err;
2153
2154     SSL_set_connect_state(c_ssl);
2155     SSL_set_bio(c_ssl, client, client);
2156     (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
2157
2158     SSL_set_accept_state(s_ssl);
2159     SSL_set_bio(s_ssl, server, server);
2160     (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
2161
2162     do {
2163         /*-
2164          * c_ssl_bio:          SSL filter BIO
2165          *
2166          * client:             I/O for SSL library
2167          *
2168          *
2169          * server:             I/O for SSL library
2170          *
2171          * s_ssl_bio:          SSL filter BIO
2172          */
2173
2174         /*
2175          * We have non-blocking behaviour throughout this test program, but
2176          * can be sure that there is *some* progress in each iteration; so we
2177          * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
2178          * we just try everything in each iteration
2179          */
2180
2181         {
2182             /* CLIENT */
2183
2184             char cbuf[1024 * 8];
2185             int i, r;
2186             clock_t c_clock = clock();
2187
2188             memset(cbuf, 0, sizeof(cbuf));
2189
2190             if (debug)
2191                 if (SSL_in_init(c_ssl))
2192                     printf("client waiting in SSL_connect - %s\n",
2193                            SSL_state_string_long(c_ssl));
2194
2195             if (cw_num > 0) {
2196                 /* Write to server. */
2197
2198                 if (cw_num > (long)sizeof cbuf)
2199                     i = sizeof cbuf;
2200                 else
2201                     i = (int)cw_num;
2202                 r = BIO_write(c_ssl_bio, cbuf, i);
2203                 if (r < 0) {
2204                     if (!BIO_should_retry(c_ssl_bio)) {
2205                         fprintf(stderr, "ERROR in CLIENT\n");
2206                         err_in_client = 1;
2207                         goto err;
2208                     }
2209                     /*
2210                      * BIO_should_retry(...) can just be ignored here. The
2211                      * library expects us to call BIO_write with the same
2212                      * arguments again, and that's what we will do in the
2213                      * next iteration.
2214                      */
2215                 } else if (r == 0) {
2216                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2217                     goto err;
2218                 } else {
2219                     if (debug)
2220                         printf("client wrote %d\n", r);
2221                     cw_num -= r;
2222                 }
2223             }
2224
2225             if (cr_num > 0) {
2226                 /* Read from server. */
2227
2228                 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
2229                 if (r < 0) {
2230                     if (!BIO_should_retry(c_ssl_bio)) {
2231                         fprintf(stderr, "ERROR in CLIENT\n");
2232                         err_in_client = 1;
2233                         goto err;
2234                     }
2235                     /*
2236                      * Again, "BIO_should_retry" can be ignored.
2237                      */
2238                 } else if (r == 0) {
2239                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2240                     goto err;
2241                 } else {
2242                     if (debug)
2243                         printf("client read %d\n", r);
2244                     cr_num -= r;
2245                 }
2246             }
2247
2248             /*
2249              * c_time and s_time increments will typically be very small
2250              * (depending on machine speed and clock tick intervals), but
2251              * sampling over a large number of connections should result in
2252              * fairly accurate figures.  We cannot guarantee a lot, however
2253              * -- if each connection lasts for exactly one clock tick, it
2254              * will be counted only for the client or only for the server or
2255              * even not at all.
2256              */
2257             *c_time += (clock() - c_clock);
2258         }
2259
2260         {
2261             /* SERVER */
2262
2263             char sbuf[1024 * 8];
2264             int i, r;
2265             clock_t s_clock = clock();
2266
2267             memset(sbuf, 0, sizeof(sbuf));
2268
2269             if (debug)
2270                 if (SSL_in_init(s_ssl))
2271                     printf("server waiting in SSL_accept - %s\n",
2272                            SSL_state_string_long(s_ssl));
2273
2274             if (sw_num > 0) {
2275                 /* Write to client. */
2276
2277                 if (sw_num > (long)sizeof sbuf)
2278                     i = sizeof sbuf;
2279                 else
2280                     i = (int)sw_num;
2281                 r = BIO_write(s_ssl_bio, sbuf, i);
2282                 if (r < 0) {
2283                     if (!BIO_should_retry(s_ssl_bio)) {
2284                         fprintf(stderr, "ERROR in SERVER\n");
2285                         err_in_server = 1;
2286                         goto err;
2287                     }
2288                     /* Ignore "BIO_should_retry". */
2289                 } else if (r == 0) {
2290                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2291                     goto err;
2292                 } else {
2293                     if (debug)
2294                         printf("server wrote %d\n", r);
2295                     sw_num -= r;
2296                 }
2297             }
2298
2299             if (sr_num > 0) {
2300                 /* Read from client. */
2301
2302                 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2303                 if (r < 0) {
2304                     if (!BIO_should_retry(s_ssl_bio)) {
2305                         fprintf(stderr, "ERROR in SERVER\n");
2306                         err_in_server = 1;
2307                         goto err;
2308                     }
2309                     /* blah, blah */
2310                 } else if (r == 0) {
2311                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2312                     goto err;
2313                 } else {
2314                     if (debug)
2315                         printf("server read %d\n", r);
2316                     sr_num -= r;
2317                 }
2318             }
2319
2320             *s_time += (clock() - s_clock);
2321         }
2322     }
2323     while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2324
2325     if (verbose)
2326         print_details(c_ssl, "DONE via TCP connect: ");
2327 # ifndef OPENSSL_NO_NEXTPROTONEG
2328     if (verify_npn(c_ssl, s_ssl) < 0) {
2329         ret = 1;
2330         goto end;
2331     }
2332 # endif
2333     if (verify_serverinfo() < 0) {
2334         fprintf(stderr, "Server info verify error\n");
2335         ret = 1;
2336         goto err;
2337     }
2338     if (verify_alpn(c_ssl, s_ssl) < 0) {
2339         ret = 1;
2340         goto err;
2341     }
2342     if (verify_servername(c_ssl, s_ssl) < 0) {
2343         ret = 1;
2344         goto err;
2345     }
2346
2347     if (custom_ext_error) {
2348         fprintf(stderr, "Custom extension error\n");
2349         ret = 1;
2350         goto err;
2351     }
2352
2353  end:
2354     ret = 0;
2355
2356  err:
2357     ERR_print_errors(bio_err);
2358
2359     BIO_free_all(acpt);
2360     BIO_free(server);
2361     BIO_free(client);
2362     BIO_free(s_ssl_bio);
2363     BIO_free(c_ssl_bio);
2364
2365     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2366         ret = (err_in_client != 0) ? 0 : 1;
2367     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2368         ret = (err_in_server != 0) ? 0 : 1;
2369
2370     return ret;
2371 }
2372 #endif
2373
2374 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
2375                  clock_t *s_time, clock_t *c_time)
2376 {
2377     long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
2378     BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
2379     BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
2380     int ret = 1;
2381     int err_in_client = 0;
2382     int err_in_server = 0;
2383
2384     size_t bufsiz = 256;        /* small buffer for testing */
2385
2386     if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
2387         goto err;
2388     if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
2389         goto err;
2390
2391     s_ssl_bio = BIO_new(BIO_f_ssl());
2392     if (!s_ssl_bio)
2393         goto err;
2394
2395     c_ssl_bio = BIO_new(BIO_f_ssl());
2396     if (!c_ssl_bio)
2397         goto err;
2398
2399     SSL_set_connect_state(c_ssl);
2400     SSL_set_bio(c_ssl, client, client);
2401     (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
2402
2403     SSL_set_accept_state(s_ssl);
2404     SSL_set_bio(s_ssl, server, server);
2405     (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
2406
2407     do {
2408         /*-
2409          * c_ssl_bio:          SSL filter BIO
2410          *
2411          * client:             pseudo-I/O for SSL library
2412          *
2413          * client_io:          client's SSL communication; usually to be
2414          *                     relayed over some I/O facility, but in this
2415          *                     test program, we're the server, too:
2416          *
2417          * server_io:          server's SSL communication
2418          *
2419          * server:             pseudo-I/O for SSL library
2420          *
2421          * s_ssl_bio:          SSL filter BIO
2422          *
2423          * The client and the server each employ a "BIO pair":
2424          * client + client_io, server + server_io.
2425          * BIO pairs are symmetric.  A BIO pair behaves similar
2426          * to a non-blocking socketpair (but both endpoints must
2427          * be handled by the same thread).
2428          * [Here we could connect client and server to the ends
2429          * of a single BIO pair, but then this code would be less
2430          * suitable as an example for BIO pairs in general.]
2431          *
2432          * Useful functions for querying the state of BIO pair endpoints:
2433          *
2434          * BIO_ctrl_pending(bio)              number of bytes we can read now
2435          * BIO_ctrl_get_read_request(bio)     number of bytes needed to fulfil
2436          *                                      other side's read attempt
2437          * BIO_ctrl_get_write_guarantee(bio)   number of bytes we can write now
2438          *
2439          * ..._read_request is never more than ..._write_guarantee;
2440          * it depends on the application which one you should use.
2441          */
2442
2443         /*
2444          * We have non-blocking behaviour throughout this test program, but
2445          * can be sure that there is *some* progress in each iteration; so we
2446          * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
2447          * we just try everything in each iteration
2448          */
2449
2450         {
2451             /* CLIENT */
2452
2453             char cbuf[1024 * 8];
2454             int i, r;
2455             clock_t c_clock = clock();
2456
2457             memset(cbuf, 0, sizeof(cbuf));
2458
2459             if (debug)
2460                 if (SSL_in_init(c_ssl))
2461                     printf("client waiting in SSL_connect - %s\n",
2462                            SSL_state_string_long(c_ssl));
2463
2464             if (cw_num > 0) {
2465                 /* Write to server. */
2466
2467                 if (cw_num > (long)sizeof cbuf)
2468                     i = sizeof cbuf;
2469                 else
2470                     i = (int)cw_num;
2471                 r = BIO_write(c_ssl_bio, cbuf, i);
2472                 if (r < 0) {
2473                     if (!BIO_should_retry(c_ssl_bio)) {
2474                         fprintf(stderr, "ERROR in CLIENT\n");
2475                         err_in_client = 1;
2476                         goto err;
2477                     }
2478                     /*
2479                      * BIO_should_retry(...) can just be ignored here. The
2480                      * library expects us to call BIO_write with the same
2481                      * arguments again, and that's what we will do in the
2482                      * next iteration.
2483                      */
2484                 } else if (r == 0) {
2485                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2486                     goto err;
2487                 } else {
2488                     if (debug)
2489                         printf("client wrote %d\n", r);
2490                     cw_num -= r;
2491                 }
2492             }
2493
2494             if (cr_num > 0) {
2495                 /* Read from server. */
2496
2497                 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
2498                 if (r < 0) {
2499                     if (!BIO_should_retry(c_ssl_bio)) {
2500                         fprintf(stderr, "ERROR in CLIENT\n");
2501                         err_in_client = 1;
2502                         goto err;
2503                     }
2504                     /*
2505                      * Again, "BIO_should_retry" can be ignored.
2506                      */
2507                 } else if (r == 0) {
2508                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2509                     goto err;
2510                 } else {
2511                     if (debug)
2512                         printf("client read %d\n", r);
2513                     cr_num -= r;
2514                 }
2515             }
2516
2517             /*
2518              * c_time and s_time increments will typically be very small
2519              * (depending on machine speed and clock tick intervals), but
2520              * sampling over a large number of connections should result in
2521              * fairly accurate figures.  We cannot guarantee a lot, however
2522              * -- if each connection lasts for exactly one clock tick, it
2523              * will be counted only for the client or only for the server or
2524              * even not at all.
2525              */
2526             *c_time += (clock() - c_clock);
2527         }
2528
2529         {
2530             /* SERVER */
2531
2532             char sbuf[1024 * 8];
2533             int i, r;
2534             clock_t s_clock = clock();
2535
2536             memset(sbuf, 0, sizeof(sbuf));
2537
2538             if (debug)
2539                 if (SSL_in_init(s_ssl))
2540                     printf("server waiting in SSL_accept - %s\n",
2541                            SSL_state_string_long(s_ssl));
2542
2543             if (sw_num > 0) {
2544                 /* Write to client. */
2545
2546                 if (sw_num > (long)sizeof sbuf)
2547                     i = sizeof sbuf;
2548                 else
2549                     i = (int)sw_num;
2550                 r = BIO_write(s_ssl_bio, sbuf, i);
2551                 if (r < 0) {
2552                     if (!BIO_should_retry(s_ssl_bio)) {
2553                         fprintf(stderr, "ERROR in SERVER\n");
2554                         err_in_server = 1;
2555                         goto err;
2556                     }
2557                     /* Ignore "BIO_should_retry". */
2558                 } else if (r == 0) {
2559                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2560                     goto err;
2561                 } else {
2562                     if (debug)
2563                         printf("server wrote %d\n", r);
2564                     sw_num -= r;
2565                 }
2566             }
2567
2568             if (sr_num > 0) {
2569                 /* Read from client. */
2570
2571                 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2572                 if (r < 0) {
2573                     if (!BIO_should_retry(s_ssl_bio)) {
2574                         fprintf(stderr, "ERROR in SERVER\n");
2575                         err_in_server = 1;
2576                         goto err;
2577                     }
2578                     /* blah, blah */
2579                 } else if (r == 0) {
2580                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2581                     goto err;
2582                 } else {
2583                     if (debug)
2584                         printf("server read %d\n", r);
2585                     sr_num -= r;
2586                 }
2587             }
2588
2589             *s_time += (clock() - s_clock);
2590         }
2591
2592         {
2593             /* "I/O" BETWEEN CLIENT AND SERVER. */
2594
2595             size_t r1, r2;
2596             BIO *io1 = server_io, *io2 = client_io;
2597             /*
2598              * we use the non-copying interface for io1 and the standard
2599              * BIO_write/BIO_read interface for io2
2600              */
2601
2602             static int prev_progress = 1;
2603             int progress = 0;
2604
2605             /* io1 to io2 */
2606             do {
2607                 size_t num;
2608                 int r;
2609
2610                 r1 = BIO_ctrl_pending(io1);
2611                 r2 = BIO_ctrl_get_write_guarantee(io2);
2612
2613                 num = r1;
2614                 if (r2 < num)
2615                     num = r2;
2616                 if (num) {
2617                     char *dataptr;
2618
2619                     if (INT_MAX < num) /* yeah, right */
2620                         num = INT_MAX;
2621
2622                     r = BIO_nread(io1, &dataptr, (int)num);
2623                     assert(r > 0);
2624                     assert(r <= (int)num);
2625                     /*
2626                      * possibly r < num (non-contiguous data)
2627                      */
2628                     num = r;
2629                     r = BIO_write(io2, dataptr, (int)num);
2630                     if (r != (int)num) { /* can't happen */
2631                         fprintf(stderr, "ERROR: BIO_write could not write "
2632                                 "BIO_ctrl_get_write_guarantee() bytes");
2633                         goto err;
2634                     }
2635                     progress = 1;
2636
2637                     if (debug)
2638                         printf((io1 == client_io) ?
2639                                "C->S relaying: %d bytes\n" :
2640                                "S->C relaying: %d bytes\n", (int)num);
2641                 }
2642             }
2643             while (r1 && r2);
2644
2645             /* io2 to io1 */
2646             {
2647                 size_t num;
2648                 int r;
2649
2650                 r1 = BIO_ctrl_pending(io2);
2651                 r2 = BIO_ctrl_get_read_request(io1);
2652                 /*
2653                  * here we could use ..._get_write_guarantee instead of
2654                  * ..._get_read_request, but by using the latter we test
2655                  * restartability of the SSL implementation more thoroughly
2656                  */
2657                 num = r1;
2658                 if (r2 < num)
2659                     num = r2;
2660                 if (num) {
2661                     char *dataptr;
2662
2663                     if (INT_MAX < num)
2664                         num = INT_MAX;
2665
2666                     if (num > 1)
2667                         --num;  /* test restartability even more thoroughly */
2668
2669                     r = BIO_nwrite0(io1, &dataptr);
2670                     assert(r > 0);
2671                     if (r < (int)num)
2672                         num = r;
2673                     r = BIO_read(io2, dataptr, (int)num);
2674                     if (r != (int)num) { /* can't happen */
2675                         fprintf(stderr, "ERROR: BIO_read could not read "
2676                                 "BIO_ctrl_pending() bytes");
2677                         goto err;
2678                     }
2679                     progress = 1;
2680                     r = BIO_nwrite(io1, &dataptr, (int)num);
2681                     if (r != (int)num) { /* can't happen */
2682                         fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
2683                                 "BIO_nwrite0() bytes");
2684                         goto err;
2685                     }
2686
2687                     if (debug)
2688                         printf((io2 == client_io) ?
2689                                "C->S relaying: %d bytes\n" :
2690                                "S->C relaying: %d bytes\n", (int)num);
2691                 }
2692             }                   /* no loop, BIO_ctrl_get_read_request now
2693                                  * returns 0 anyway */
2694
2695             if (!progress && !prev_progress)
2696                 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0) {
2697                     fprintf(stderr, "ERROR: got stuck\n");
2698                     fprintf(stderr, " ERROR.\n");
2699                     goto err;
2700                 }
2701             prev_progress = progress;
2702         }
2703     }
2704     while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2705
2706     if (verbose)
2707         print_details(c_ssl, "DONE via BIO pair: ");
2708 #ifndef OPENSSL_NO_NEXTPROTONEG
2709     if (verify_npn(c_ssl, s_ssl) < 0) {
2710         ret = 1;
2711         goto end;
2712     }
2713 #endif
2714     if (verify_serverinfo() < 0) {
2715         fprintf(stderr, "Server info verify error\n");
2716         ret = 1;
2717         goto err;
2718     }
2719     if (verify_alpn(c_ssl, s_ssl) < 0) {
2720         ret = 1;
2721         goto err;
2722     }
2723     if (verify_servername(c_ssl, s_ssl) < 0) {
2724         ret = 1;
2725         goto err;
2726     }
2727
2728     if (custom_ext_error) {
2729         fprintf(stderr, "Custom extension error\n");
2730         ret = 1;
2731         goto err;
2732     }
2733
2734  end:
2735     ret = 0;
2736
2737  err:
2738     ERR_print_errors(bio_err);
2739
2740     BIO_free(server);
2741     BIO_free(server_io);
2742     BIO_free(client);
2743     BIO_free(client_io);
2744     BIO_free(s_ssl_bio);
2745     BIO_free(c_ssl_bio);
2746
2747     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2748         ret = (err_in_client != 0) ? 0 : 1;
2749     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2750         ret = (err_in_server != 0) ? 0 : 1;
2751
2752     return ret;
2753 }
2754
2755 #define W_READ  1
2756 #define W_WRITE 2
2757 #define C_DONE  1
2758 #define S_DONE  2
2759
2760 int doit(SSL *s_ssl, SSL *c_ssl, long count)
2761 {
2762     char *cbuf = NULL, *sbuf = NULL;
2763     long bufsiz;
2764     long cw_num = count, cr_num = count;
2765     long sw_num = count, sr_num = count;
2766     int ret = 1;
2767     BIO *c_to_s = NULL;
2768     BIO *s_to_c = NULL;
2769     BIO *c_bio = NULL;
2770     BIO *s_bio = NULL;
2771     int c_r, c_w, s_r, s_w;
2772     int i, j;
2773     int done = 0;
2774     int c_write, s_write;
2775     int do_server = 0, do_client = 0;
2776     int max_frag = 5 * 1024;
2777     int err_in_client = 0;
2778     int err_in_server = 0;
2779
2780     bufsiz = count > 40 * 1024 ? 40 * 1024 : count;
2781
2782     if ((cbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2783         goto err;
2784     if ((sbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2785         goto err;
2786
2787     c_to_s = BIO_new(BIO_s_mem());
2788     s_to_c = BIO_new(BIO_s_mem());
2789     if ((s_to_c == NULL) || (c_to_s == NULL)) {
2790         ERR_print_errors(bio_err);
2791         goto err;
2792     }
2793
2794     c_bio = BIO_new(BIO_f_ssl());
2795     s_bio = BIO_new(BIO_f_ssl());
2796     if ((c_bio == NULL) || (s_bio == NULL)) {
2797         ERR_print_errors(bio_err);
2798         goto err;
2799     }
2800
2801     SSL_set_connect_state(c_ssl);
2802     SSL_set_bio(c_ssl, s_to_c, c_to_s);
2803     SSL_set_max_send_fragment(c_ssl, max_frag);
2804     BIO_set_ssl(c_bio, c_ssl, BIO_NOCLOSE);
2805
2806     SSL_set_accept_state(s_ssl);
2807     SSL_set_bio(s_ssl, c_to_s, s_to_c);
2808     SSL_set_max_send_fragment(s_ssl, max_frag);
2809     BIO_set_ssl(s_bio, s_ssl, BIO_NOCLOSE);
2810
2811     c_r = 0;
2812     s_r = 1;
2813     c_w = 1;
2814     s_w = 0;
2815     c_write = 1, s_write = 0;
2816
2817     /* We can always do writes */
2818     for (;;) {
2819         do_server = 0;
2820         do_client = 0;
2821
2822         i = (int)BIO_pending(s_bio);
2823         if ((i && s_r) || s_w)
2824             do_server = 1;
2825
2826         i = (int)BIO_pending(c_bio);
2827         if ((i && c_r) || c_w)
2828             do_client = 1;
2829
2830         if (do_server && debug) {
2831             if (SSL_in_init(s_ssl))
2832                 printf("server waiting in SSL_accept - %s\n",
2833                        SSL_state_string_long(s_ssl));
2834 /*-
2835             else if (s_write)
2836                 printf("server:SSL_write()\n");
2837             else
2838                 printf("server:SSL_read()\n"); */
2839         }
2840
2841         if (do_client && debug) {
2842             if (SSL_in_init(c_ssl))
2843                 printf("client waiting in SSL_connect - %s\n",
2844                        SSL_state_string_long(c_ssl));
2845 /*-
2846             else if (c_write)
2847                 printf("client:SSL_write()\n");
2848             else
2849                 printf("client:SSL_read()\n"); */
2850         }
2851
2852         if (!do_client && !do_server) {
2853             fprintf(stdout, "ERROR IN STARTUP\n");
2854             ERR_print_errors(bio_err);
2855             goto err;
2856         }
2857         if (do_client && !(done & C_DONE)) {
2858             if (c_write) {
2859                 j = (cw_num > bufsiz) ? (int)bufsiz : (int)cw_num;
2860                 i = BIO_write(c_bio, cbuf, j);
2861                 if (i < 0) {
2862                     c_r = 0;
2863                     c_w = 0;
2864                     if (BIO_should_retry(c_bio)) {
2865                         if (BIO_should_read(c_bio))
2866                             c_r = 1;
2867                         if (BIO_should_write(c_bio))
2868                             c_w = 1;
2869                     } else {
2870                         fprintf(stderr, "ERROR in CLIENT\n");
2871                         err_in_client = 1;
2872                         ERR_print_errors(bio_err);
2873                         goto err;
2874                     }
2875                 } else if (i == 0) {
2876                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2877                     goto err;
2878                 } else {
2879                     if (debug)
2880                         printf("client wrote %d\n", i);
2881                     /* ok */
2882                     s_r = 1;
2883                     c_write = 0;
2884                     cw_num -= i;
2885                     if (max_frag > 1029)
2886                         SSL_set_max_send_fragment(c_ssl, max_frag -= 5);
2887                 }
2888             } else {
2889                 i = BIO_read(c_bio, cbuf, bufsiz);
2890                 if (i < 0) {
2891                     c_r = 0;
2892                     c_w = 0;
2893                     if (BIO_should_retry(c_bio)) {
2894                         if (BIO_should_read(c_bio))
2895                             c_r = 1;
2896                         if (BIO_should_write(c_bio))
2897                             c_w = 1;
2898                     } else {
2899                         fprintf(stderr, "ERROR in CLIENT\n");
2900                         err_in_client = 1;
2901                         ERR_print_errors(bio_err);
2902                         goto err;
2903                     }
2904                 } else if (i == 0) {
2905                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2906                     goto err;
2907                 } else {
2908                     if (debug)
2909                         printf("client read %d\n", i);
2910                     cr_num -= i;
2911                     if (sw_num > 0) {
2912                         s_write = 1;
2913                         s_w = 1;
2914                     }
2915                     if (cr_num <= 0) {
2916                         s_write = 1;
2917                         s_w = 1;
2918                         done = S_DONE | C_DONE;
2919                     }
2920                 }
2921             }
2922         }
2923
2924         if (do_server && !(done & S_DONE)) {
2925             if (!s_write) {
2926                 i = BIO_read(s_bio, sbuf, bufsiz);
2927                 if (i < 0) {
2928                     s_r = 0;
2929                     s_w = 0;
2930                     if (BIO_should_retry(s_bio)) {
2931                         if (BIO_should_read(s_bio))
2932                             s_r = 1;
2933                         if (BIO_should_write(s_bio))
2934                             s_w = 1;
2935                     } else {
2936                         fprintf(stderr, "ERROR in SERVER\n");
2937                         err_in_server = 1;
2938                         ERR_print_errors(bio_err);
2939                         goto err;
2940                     }
2941                 } else if (i == 0) {
2942                     ERR_print_errors(bio_err);
2943                     fprintf(stderr,
2944                             "SSL SERVER STARTUP FAILED in SSL_read\n");
2945                     goto err;
2946                 } else {
2947                     if (debug)
2948                         printf("server read %d\n", i);
2949                     sr_num -= i;
2950                     if (cw_num > 0) {
2951                         c_write = 1;
2952                         c_w = 1;
2953                     }
2954                     if (sr_num <= 0) {
2955                         s_write = 1;
2956                         s_w = 1;
2957                         c_write = 0;
2958                     }
2959                 }
2960             } else {
2961                 j = (sw_num > bufsiz) ? (int)bufsiz : (int)sw_num;
2962                 i = BIO_write(s_bio, sbuf, j);
2963                 if (i < 0) {
2964                     s_r = 0;
2965                     s_w = 0;
2966                     if (BIO_should_retry(s_bio)) {
2967                         if (BIO_should_read(s_bio))
2968                             s_r = 1;
2969                         if (BIO_should_write(s_bio))
2970                             s_w = 1;
2971                     } else {
2972                         fprintf(stderr, "ERROR in SERVER\n");
2973                         err_in_server = 1;
2974                         ERR_print_errors(bio_err);
2975                         goto err;
2976                     }
2977                 } else if (i == 0) {
2978                     ERR_print_errors(bio_err);
2979                     fprintf(stderr,
2980                             "SSL SERVER STARTUP FAILED in SSL_write\n");
2981                     goto err;
2982                 } else {
2983                     if (debug)
2984                         printf("server wrote %d\n", i);
2985                     sw_num -= i;
2986                     s_write = 0;
2987                     c_r = 1;
2988                     if (sw_num <= 0)
2989                         done |= S_DONE;
2990                     if (max_frag > 1029)
2991                         SSL_set_max_send_fragment(s_ssl, max_frag -= 5);
2992                 }
2993             }
2994         }
2995
2996         if ((done & S_DONE) && (done & C_DONE))
2997             break;
2998     }
2999
3000     if (verbose)
3001         print_details(c_ssl, "DONE: ");
3002 #ifndef OPENSSL_NO_NEXTPROTONEG
3003     if (verify_npn(c_ssl, s_ssl) < 0) {
3004         ret = 1;
3005         goto err;
3006     }
3007 #endif
3008     if (verify_serverinfo() < 0) {
3009         fprintf(stderr, "Server info verify error\n");
3010         ret = 1;
3011         goto err;
3012     }
3013     if (custom_ext_error) {
3014         fprintf(stderr, "Custom extension error\n");
3015         ret = 1;
3016         goto err;
3017     }
3018     ret = 0;
3019  err:
3020     /*
3021      * We have to set the BIO's to NULL otherwise they will be
3022      * OPENSSL_free()ed twice.  Once when th s_ssl is SSL_free()ed and again
3023      * when c_ssl is SSL_free()ed. This is a hack required because s_ssl and
3024      * c_ssl are sharing the same BIO structure and SSL_set_bio() and
3025      * SSL_free() automatically BIO_free non NULL entries. You should not
3026      * normally do this or be required to do this
3027      */
3028     if (s_ssl != NULL) {
3029         s_ssl->rbio = NULL;
3030         s_ssl->wbio = NULL;
3031     }
3032     if (c_ssl != NULL) {
3033         c_ssl->rbio = NULL;
3034         c_ssl->wbio = NULL;
3035     }
3036
3037     BIO_free(c_to_s);
3038     BIO_free(s_to_c);
3039     BIO_free_all(c_bio);
3040     BIO_free_all(s_bio);
3041     OPENSSL_free(cbuf);
3042     OPENSSL_free(sbuf);
3043
3044     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
3045         ret = (err_in_client != 0) ? 0 : 1;
3046     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
3047         ret = (err_in_server != 0) ? 0 : 1;
3048
3049     return (ret);
3050 }
3051
3052 static CRYPTO_ONCE proxy_auth_ex_data_once = CRYPTO_ONCE_STATIC_INIT;
3053 static volatile int proxy_auth_ex_data_idx = -1;
3054
3055 static void do_get_proxy_auth_ex_data_idx(void)
3056 {
3057     proxy_auth_ex_data_idx = X509_STORE_CTX_get_ex_new_index(0,
3058                                                 "SSLtest for verify callback",
3059                                                 NULL, NULL, NULL);
3060 }
3061
3062 static int get_proxy_auth_ex_data_idx(void)
3063 {
3064     CRYPTO_THREAD_run_once(&proxy_auth_ex_data_once,
3065                            do_get_proxy_auth_ex_data_idx);
3066     return proxy_auth_ex_data_idx;
3067 }
3068
3069 static int verify_callback(int ok, X509_STORE_CTX *ctx)
3070 {
3071     char *s, buf[256];
3072
3073     s = X509_NAME_oneline(X509_get_subject_name(ctx->current_cert), buf,
3074                           sizeof buf);
3075     if (s != NULL) {
3076         if (ok)
3077             printf("depth=%d %s\n", ctx->error_depth, buf);
3078         else {
3079             fprintf(stderr, "depth=%d error=%d %s\n",
3080                     ctx->error_depth, ctx->error, buf);
3081         }
3082     }
3083
3084     if (ok == 0) {
3085         switch (ctx->error) {
3086         default:
3087             fprintf(stderr, "Error string: %s\n",
3088                     X509_verify_cert_error_string(ctx->error));
3089             break;
3090         case X509_V_ERR_CERT_NOT_YET_VALID:
3091         case X509_V_ERR_CERT_HAS_EXPIRED:
3092         case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
3093             ok = 1;
3094         }
3095     }
3096
3097     if (ok == 1) {
3098         X509 *xs = ctx->current_cert;
3099         if (X509_get_extension_flags(xs) & EXFLAG_PROXY) {
3100             unsigned int *letters = X509_STORE_CTX_get_ex_data(ctx,
3101                                                                get_proxy_auth_ex_data_idx
3102                                                                ());
3103
3104             if (letters) {
3105                 int found_any = 0;
3106                 int i;
3107                 PROXY_CERT_INFO_EXTENSION *pci =
3108                     X509_get_ext_d2i(xs, NID_proxyCertInfo,
3109                                      NULL, NULL);
3110
3111                 switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage)) {
3112                 case NID_Independent:
3113                     /*
3114                      * Completely meaningless in this program, as there's no
3115                      * way to grant explicit rights to a specific PrC.
3116                      * Basically, using id-ppl-Independent is the perfect way
3117                      * to grant no rights at all.
3118                      */
3119                     fprintf(stderr, "  Independent proxy certificate");
3120                     for (i = 0; i < 26; i++)
3121                         letters[i] = 0;
3122                     break;
3123                 case NID_id_ppl_inheritAll:
3124                     /*
3125                      * This is basically a NOP, we simply let the current
3126                      * rights stand as they are.
3127                      */
3128                     fprintf(stderr, "  Proxy certificate inherits all");
3129                     break;
3130                 default:
3131                     s = (char *)
3132                         pci->proxyPolicy->policy->data;
3133                     i = pci->proxyPolicy->policy->length;
3134
3135                     /*
3136                      * The algorithm works as follows: it is assumed that
3137                      * previous iterations or the initial granted rights has
3138                      * already set some elements of `letters'.  What we need
3139                      * to do is to clear those that weren't granted by the
3140                      * current PrC as well.  The easiest way to do this is to
3141                      * add 1 to all the elements whose letters are given with
3142                      * the current policy. That way, all elements that are
3143                      * set by the current policy and were already set by
3144                      * earlier policies and through the original grant of
3145                      * rights will get the value 2 or higher. The last thing
3146                      * to do is to sweep through `letters' and keep the
3147                      * elements having the value 2 as set, and clear all the
3148                      * others.
3149                      */
3150
3151                     printf("  Certificate proxy rights = %*.*s", i,
3152                             i, s);
3153                     while (i-- > 0) {
3154                         int c = *s++;
3155                         if (isascii(c) && isalpha(c)) {
3156                             if (islower(c))
3157                                 c = toupper(c);
3158                             letters[c - 'A']++;
3159                         }
3160                     }
3161                     for (i = 0; i < 26; i++)
3162                         if (letters[i] < 2)
3163                             letters[i] = 0;
3164                         else
3165                             letters[i] = 1;
3166                 }
3167
3168                 found_any = 0;
3169                 printf(", resulting proxy rights = ");
3170                 for (i = 0; i < 26; i++)
3171                     if (letters[i]) {
3172                         printf("%c", i + 'A');
3173                         found_any = 1;
3174                     }
3175                 if (!found_any)
3176                     printf("none");
3177                 printf("\n");
3178
3179                 PROXY_CERT_INFO_EXTENSION_free(pci);
3180             }
3181         }
3182     }
3183
3184     return (ok);
3185 }
3186
3187 static void process_proxy_debug(int indent, const char *format, ...)
3188 {
3189     /* That's 80 > */
3190     static const char indentation[] =
3191         ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
3192         ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
3193     char my_format[256];
3194     va_list args;
3195
3196     BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
3197                  indent, indent, indentation, format);
3198
3199     va_start(args, format);
3200     vfprintf(stderr, my_format, args);
3201     va_end(args);
3202 }
3203
3204 /*-
3205  * Priority levels:
3206  *  0   [!]var, ()
3207  *  1   & ^
3208  *  2   |
3209  */
3210 static int process_proxy_cond_adders(unsigned int letters[26],
3211                                      const char *cond, const char **cond_end,
3212                                      int *pos, int indent);
3213 static int process_proxy_cond_val(unsigned int letters[26], const char *cond,
3214                                   const char **cond_end, int *pos, int indent)
3215 {
3216     int c;
3217     int ok = 1;
3218     int negate = 0;
3219
3220     while (isspace((int)*cond)) {
3221         cond++;
3222         (*pos)++;
3223     }
3224     c = *cond;
3225
3226     if (debug)
3227         process_proxy_debug(indent,
3228                             "Start process_proxy_cond_val at position %d: %s\n",
3229                             *pos, cond);
3230
3231     while (c == '!') {
3232         negate = !negate;
3233         cond++;
3234         (*pos)++;
3235         while (isspace((int)*cond)) {
3236             cond++;
3237             (*pos)++;
3238         }
3239         c = *cond;
3240     }
3241
3242     if (c == '(') {
3243         cond++;
3244         (*pos)++;
3245         ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
3246                                        indent + 1);
3247         cond = *cond_end;
3248         if (ok < 0)
3249             goto end;
3250         while (isspace((int)*cond)) {
3251             cond++;
3252             (*pos)++;
3253         }
3254         c = *cond;
3255         if (c != ')') {
3256             fprintf(stderr,
3257                     "Weird condition character in position %d: "
3258                     "%c\n", *pos, c);
3259             ok = -1;
3260             goto end;
3261         }
3262         cond++;
3263         (*pos)++;
3264     } else if (isascii(c) && isalpha(c)) {
3265         if (islower(c))
3266             c = toupper(c);
3267         ok = letters[c - 'A'];
3268         cond++;
3269         (*pos)++;
3270     } else {
3271         fprintf(stderr,
3272                 "Weird condition character in position %d: " "%c\n", *pos, c);
3273         ok = -1;
3274         goto end;
3275     }
3276  end:
3277     *cond_end = cond;
3278     if (ok >= 0 && negate)
3279         ok = !ok;
3280
3281     if (debug)
3282         process_proxy_debug(indent,
3283                             "End process_proxy_cond_val at position %d: %s, returning %d\n",
3284                             *pos, cond, ok);
3285
3286     return ok;
3287 }
3288
3289 static int process_proxy_cond_multipliers(unsigned int letters[26],
3290                                           const char *cond,
3291                                           const char **cond_end, int *pos,
3292                                           int indent)
3293 {
3294     int ok;
3295     char c;
3296
3297     if (debug)
3298         process_proxy_debug(indent,
3299                             "Start process_proxy_cond_multipliers at position %d: %s\n",
3300                             *pos, cond);
3301
3302     ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
3303     cond = *cond_end;
3304     if (ok < 0)
3305         goto end;
3306
3307     while (ok >= 0) {
3308         while (isspace((int)*cond)) {
3309             cond++;
3310             (*pos)++;
3311         }
3312         c = *cond;
3313
3314         switch (c) {
3315         case '&':
3316         case '^':
3317             {
3318                 int save_ok = ok;
3319
3320                 cond++;
3321                 (*pos)++;
3322                 ok = process_proxy_cond_val(letters,
3323                                             cond, cond_end, pos, indent + 1);
3324                 cond = *cond_end;
3325                 if (ok < 0)
3326                     break;
3327
3328                 switch (c) {
3329                 case '&':
3330                     ok &= save_ok;
3331                     break;
3332                 case '^':
3333                     ok ^= save_ok;
3334                     break;
3335                 default:
3336                     fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
3337                             " STOPPING\n");
3338                     EXIT(1);
3339                 }
3340             }
3341             break;
3342         default:
3343             goto end;
3344         }
3345     }
3346  end:
3347     if (debug)
3348         process_proxy_debug(indent,
3349                             "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
3350                             *pos, cond, ok);
3351
3352     *cond_end = cond;
3353     return ok;
3354 }
3355
3356 static int process_proxy_cond_adders(unsigned int letters[26],
3357                                      const char *cond, const char **cond_end,
3358                                      int *pos, int indent)
3359 {
3360     int ok;
3361     char c;
3362
3363     if (debug)
3364         process_proxy_debug(indent,
3365                             "Start process_proxy_cond_adders at position %d: %s\n",
3366                             *pos, cond);
3367
3368     ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
3369                                         indent + 1);
3370     cond = *cond_end;
3371     if (ok < 0)
3372         goto end;
3373
3374     while (ok >= 0) {
3375         while (isspace((int)*cond)) {
3376             cond++;
3377             (*pos)++;
3378         }
3379         c = *cond;
3380
3381         switch (c) {
3382         case '|':
3383             {
3384                 int save_ok = ok;
3385
3386                 cond++;
3387                 (*pos)++;
3388                 ok = process_proxy_cond_multipliers(letters,
3389                                                     cond, cond_end, pos,
3390                                                     indent + 1);
3391                 cond = *cond_end;
3392                 if (ok < 0)
3393                     break;
3394
3395                 switch (c) {
3396                 case '|':
3397                     ok |= save_ok;
3398                     break;
3399                 default:
3400                     fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
3401                             " STOPPING\n");
3402                     EXIT(1);
3403                 }
3404             }
3405             break;
3406         default:
3407             goto end;
3408         }
3409     }
3410  end:
3411     if (debug)
3412         process_proxy_debug(indent,
3413                             "End process_proxy_cond_adders at position %d: %s, returning %d\n",
3414                             *pos, cond, ok);
3415
3416     *cond_end = cond;
3417     return ok;
3418 }
3419
3420 static int process_proxy_cond(unsigned int letters[26],
3421                               const char *cond, const char **cond_end)
3422 {
3423     int pos = 1;
3424     return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
3425 }
3426
3427 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg)
3428 {
3429     int ok = 1;
3430     struct app_verify_arg *cb_arg = arg;
3431     unsigned int letters[26];   /* only used with proxy_auth */
3432
3433     if (cb_arg->app_verify) {
3434         char *s = NULL, buf[256];
3435
3436         printf("In app_verify_callback, allowing cert. ");
3437         printf("Arg is: %s\n", cb_arg->string);
3438         printf("Finished printing do we have a context? 0x%p a cert? 0x%p\n",
3439                 (void *)ctx, (void *)ctx->cert);
3440         if (ctx->cert)
3441             s = X509_NAME_oneline(X509_get_subject_name(ctx->cert), buf, 256);
3442         if (s != NULL) {
3443             printf("cert depth=%d %s\n", ctx->error_depth, buf);
3444         }
3445         return (1);
3446     }
3447     if (cb_arg->proxy_auth) {
3448         int found_any = 0, i;
3449         char *sp;
3450
3451         for (i = 0; i < 26; i++)
3452             letters[i] = 0;
3453         for (sp = cb_arg->proxy_auth; *sp; sp++) {
3454             int c = *sp;
3455             if (isascii(c) && isalpha(c)) {
3456                 if (islower(c))
3457                     c = toupper(c);
3458                 letters[c - 'A'] = 1;
3459             }
3460         }
3461
3462         printf("  Initial proxy rights = ");
3463         for (i = 0; i < 26; i++)
3464             if (letters[i]) {
3465                 printf("%c", i + 'A');
3466                 found_any = 1;
3467             }
3468         if (!found_any)
3469             printf("none");
3470         printf("\n");
3471
3472         X509_STORE_CTX_set_ex_data(ctx,
3473                                    get_proxy_auth_ex_data_idx(), letters);
3474     }
3475     if (cb_arg->allow_proxy_certs) {
3476         X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
3477     }
3478     ok = X509_verify_cert(ctx);
3479
3480     if (cb_arg->proxy_auth) {
3481         if (ok > 0) {
3482             const char *cond_end = NULL;
3483
3484             ok = process_proxy_cond(letters, cb_arg->proxy_cond, &cond_end);
3485
3486             if (ok < 0)
3487                 EXIT(3);
3488             if (*cond_end) {
3489                 fprintf(stderr,
3490                         "Stopped processing condition before it's end.\n");
3491                 ok = 0;
3492             }
3493             if (!ok)
3494                 fprintf(stderr,
3495                         "Proxy rights check with condition '%s' invalid\n",
3496                         cb_arg->proxy_cond);
3497             else
3498                 printf("Proxy rights check with condition '%s' ok\n",
3499                         cb_arg->proxy_cond);
3500         }
3501     }
3502     return (ok);
3503 }
3504
3505 #ifndef OPENSSL_NO_DH
3506 /*-
3507  * These DH parameters have been generated as follows:
3508  *    $ openssl dhparam -C -noout 512
3509  *    $ openssl dhparam -C -noout 1024
3510  *    $ openssl dhparam -C -noout -dsaparam 1024
3511  * (The third function has been renamed to avoid name conflicts.)
3512  */
3513 static DH *get_dh512()
3514 {
3515     static unsigned char dh512_p[] = {
3516         0xCB, 0xC8, 0xE1, 0x86, 0xD0, 0x1F, 0x94, 0x17, 0xA6, 0x99, 0xF0,
3517         0xC6,
3518         0x1F, 0x0D, 0xAC, 0xB6, 0x25, 0x3E, 0x06, 0x39, 0xCA, 0x72, 0x04,
3519         0xB0,
3520         0x6E, 0xDA, 0xC0, 0x61, 0xE6, 0x7A, 0x77, 0x25, 0xE8, 0x3B, 0xB9,
3521         0x5F,
3522         0x9A, 0xB6, 0xB5, 0xFE, 0x99, 0x0B, 0xA1, 0x93, 0x4E, 0x35, 0x33,
3523         0xB8,
3524         0xE1, 0xF1, 0x13, 0x4F, 0x59, 0x1A, 0xD2, 0x57, 0xC0, 0x26, 0x21,
3525         0x33,
3526         0x02, 0xC5, 0xAE, 0x23,
3527     };
3528     static unsigned char dh512_g[] = {
3529         0x02,
3530     };
3531     DH *dh;
3532
3533     if ((dh = DH_new()) == NULL)
3534         return (NULL);
3535     dh->p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
3536     dh->g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
3537     if ((dh->p == NULL) || (dh->g == NULL)) {
3538         DH_free(dh);
3539         return (NULL);
3540     }
3541     return (dh);
3542 }
3543
3544 static DH *get_dh1024()
3545 {
3546     static unsigned char dh1024_p[] = {
3547         0xF8, 0x81, 0x89, 0x7D, 0x14, 0x24, 0xC5, 0xD1, 0xE6, 0xF7, 0xBF,
3548         0x3A,
3549         0xE4, 0x90, 0xF4, 0xFC, 0x73, 0xFB, 0x34, 0xB5, 0xFA, 0x4C, 0x56,
3550         0xA2,
3551         0xEA, 0xA7, 0xE9, 0xC0, 0xC0, 0xCE, 0x89, 0xE1, 0xFA, 0x63, 0x3F,
3552         0xB0,
3553         0x6B, 0x32, 0x66, 0xF1, 0xD1, 0x7B, 0xB0, 0x00, 0x8F, 0xCA, 0x87,
3554         0xC2,
3555         0xAE, 0x98, 0x89, 0x26, 0x17, 0xC2, 0x05, 0xD2, 0xEC, 0x08, 0xD0,
3556         0x8C,
3557         0xFF, 0x17, 0x52, 0x8C, 0xC5, 0x07, 0x93, 0x03, 0xB1, 0xF6, 0x2F,
3558         0xB8,
3559         0x1C, 0x52, 0x47, 0x27, 0x1B, 0xDB, 0xD1, 0x8D, 0x9D, 0x69, 0x1D,
3560         0x52,
3561         0x4B, 0x32, 0x81, 0xAA, 0x7F, 0x00, 0xC8, 0xDC, 0xE6, 0xD9, 0xCC,
3562         0xC1,
3563         0x11, 0x2D, 0x37, 0x34, 0x6C, 0xEA, 0x02, 0x97, 0x4B, 0x0E, 0xBB,
3564         0xB1,
3565         0x71, 0x33, 0x09, 0x15, 0xFD, 0xDD, 0x23, 0x87, 0x07, 0x5E, 0x89,
3566         0xAB,
3567         0x6B, 0x7C, 0x5F, 0xEC, 0xA6, 0x24, 0xDC, 0x53,
3568     };
3569     static unsigned char dh1024_g[] = {
3570         0x02,
3571     };
3572     DH *dh;
3573
3574     if ((dh = DH_new()) == NULL)
3575         return (NULL);
3576     dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
3577     dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
3578     if ((dh->p == NULL) || (dh->g == NULL)) {
3579         DH_free(dh);
3580         return (NULL);
3581     }
3582     return (dh);
3583 }
3584
3585 static DH *get_dh1024dsa()
3586 {
3587     static unsigned char dh1024_p[] = {
3588         0xC8, 0x00, 0xF7, 0x08, 0x07, 0x89, 0x4D, 0x90, 0x53, 0xF3, 0xD5,
3589         0x00,
3590         0x21, 0x1B, 0xF7, 0x31, 0xA6, 0xA2, 0xDA, 0x23, 0x9A, 0xC7, 0x87,
3591         0x19,
3592         0x3B, 0x47, 0xB6, 0x8C, 0x04, 0x6F, 0xFF, 0xC6, 0x9B, 0xB8, 0x65,
3593         0xD2,
3594         0xC2, 0x5F, 0x31, 0x83, 0x4A, 0xA7, 0x5F, 0x2F, 0x88, 0x38, 0xB6,
3595         0x55,
3596         0xCF, 0xD9, 0x87, 0x6D, 0x6F, 0x9F, 0xDA, 0xAC, 0xA6, 0x48, 0xAF,
3597         0xFC,
3598         0x33, 0x84, 0x37, 0x5B, 0x82, 0x4A, 0x31, 0x5D, 0xE7, 0xBD, 0x52,
3599         0x97,
3600         0xA1, 0x77, 0xBF, 0x10, 0x9E, 0x37, 0xEA, 0x64, 0xFA, 0xCA, 0x28,
3601         0x8D,
3602         0x9D, 0x3B, 0xD2, 0x6E, 0x09, 0x5C, 0x68, 0xC7, 0x45, 0x90, 0xFD,
3603         0xBB,
3604         0x70, 0xC9, 0x3A, 0xBB, 0xDF, 0xD4, 0x21, 0x0F, 0xC4, 0x6A, 0x3C,
3605         0xF6,
3606         0x61, 0xCF, 0x3F, 0xD6, 0x13, 0xF1, 0x5F, 0xBC, 0xCF, 0xBC, 0x26,
3607         0x9E,
3608         0xBC, 0x0B, 0xBD, 0xAB, 0x5D, 0xC9, 0x54, 0x39,
3609     };
3610     static unsigned char dh1024_g[] = {
3611         0x3B, 0x40, 0x86, 0xE7, 0xF3, 0x6C, 0xDE, 0x67, 0x1C, 0xCC, 0x80,
3612         0x05,
3613         0x5A, 0xDF, 0xFE, 0xBD, 0x20, 0x27, 0x74, 0x6C, 0x24, 0xC9, 0x03,
3614         0xF3,
3615         0xE1, 0x8D, 0xC3, 0x7D, 0x98, 0x27, 0x40, 0x08, 0xB8, 0x8C, 0x6A,
3616         0xE9,
3617         0xBB, 0x1A, 0x3A, 0xD6, 0x86, 0x83, 0x5E, 0x72, 0x41, 0xCE, 0x85,
3618         0x3C,
3619         0xD2, 0xB3, 0xFC, 0x13, 0xCE, 0x37, 0x81, 0x9E, 0x4C, 0x1C, 0x7B,
3620         0x65,
3621         0xD3, 0xE6, 0xA6, 0x00, 0xF5, 0x5A, 0x95, 0x43, 0x5E, 0x81, 0xCF,
3622         0x60,
3623         0xA2, 0x23, 0xFC, 0x36, 0xA7, 0x5D, 0x7A, 0x4C, 0x06, 0x91, 0x6E,
3624         0xF6,
3625         0x57, 0xEE, 0x36, 0xCB, 0x06, 0xEA, 0xF5, 0x3D, 0x95, 0x49, 0xCB,
3626         0xA7,
3627         0xDD, 0x81, 0xDF, 0x80, 0x09, 0x4A, 0x97, 0x4D, 0xA8, 0x22, 0x72,
3628         0xA1,
3629         0x7F, 0xC4, 0x70, 0x56, 0x70, 0xE8, 0x20, 0x10, 0x18, 0x8F, 0x2E,
3630         0x60,
3631         0x07, 0xE7, 0x68, 0x1A, 0x82, 0x5D, 0x32, 0xA2,
3632     };
3633     DH *dh;
3634
3635     if ((dh = DH_new()) == NULL)
3636         return (NULL);
3637     dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
3638     dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
3639     if ((dh->p == NULL) || (dh->g == NULL)) {
3640         DH_free(dh);
3641         return (NULL);
3642     }
3643     dh->length = 160;
3644     return (dh);
3645 }
3646 #endif
3647
3648 #ifndef OPENSSL_NO_PSK
3649 /* convert the PSK key (psk_key) in ascii to binary (psk) */
3650 static int psk_key2bn(const char *pskkey, unsigned char *psk,
3651                       unsigned int max_psk_len)
3652 {
3653     int ret;
3654     BIGNUM *bn = NULL;
3655
3656     ret = BN_hex2bn(&bn, pskkey);
3657     if (!ret) {
3658         BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
3659                    pskkey);
3660         BN_free(bn);
3661         return 0;
3662     }
3663     if (BN_num_bytes(bn) > (int)max_psk_len) {
3664         BIO_printf(bio_err,
3665                    "psk buffer of callback is too small (%d) for key (%d)\n",
3666                    max_psk_len, BN_num_bytes(bn));
3667         BN_free(bn);
3668         return 0;
3669     }
3670     ret = BN_bn2bin(bn, psk);
3671     BN_free(bn);
3672     return ret;
3673 }
3674
3675 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
3676                                         char *identity,
3677                                         unsigned int max_identity_len,
3678                                         unsigned char *psk,
3679                                         unsigned int max_psk_len)
3680 {
3681     int ret;
3682     unsigned int psk_len = 0;
3683
3684     ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3685     if (ret < 0)
3686         goto out_err;
3687     if (debug)
3688         fprintf(stderr, "client: created identity '%s' len=%d\n", identity,
3689                 ret);
3690     ret = psk_key2bn(psk_key, psk, max_psk_len);
3691     if (ret < 0)
3692         goto out_err;
3693     psk_len = ret;
3694  out_err:
3695     return psk_len;
3696 }
3697
3698 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3699                                         unsigned char *psk,
3700                                         unsigned int max_psk_len)
3701 {
3702     unsigned int psk_len = 0;
3703
3704     if (strcmp(identity, "Client_identity") != 0) {
3705         BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3706         return 0;
3707     }
3708     psk_len = psk_key2bn(psk_key, psk, max_psk_len);
3709     return psk_len;
3710 }
3711 #endif
3712
3713 static int do_test_cipherlist(void)
3714 {
3715 #ifndef OPENSSL_NO_TLS
3716     int i = 0;
3717     const SSL_METHOD *meth;
3718     const SSL_CIPHER *ci, *tci = NULL;
3719
3720     /*
3721      * This is required because ssltest "cheats" and uses internal headers to
3722      * call functions, thus avoiding auto-init
3723      */
3724     OPENSSL_init_crypto(0, NULL);
3725     OPENSSL_init_ssl(0, NULL);
3726
3727     meth = TLS_method();
3728     tci = NULL;
3729     while ((ci = meth->get_cipher(i++)) != NULL) {
3730         if (tci != NULL)
3731             if (ci->id >= tci->id) {
3732                 fprintf(stderr, "testing SSLv3 cipher list order: ");
3733                 fprintf(stderr, "failed %x vs. %x\n", ci->id, tci->id);
3734                 return 0;
3735             }
3736         tci = ci;
3737     }
3738 #endif
3739
3740     return 1;
3741 }