test/ssltest.c

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