test/ssltest.c

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