test/ssltest.c

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