ssl/ssltest.c

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