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
 780     fprintf(stderr, " -ssl3         - use SSLv3\n");
 781 #endif
 782 #ifndef OPENSSL_NO_TLS1
 783     fprintf(stderr, " -tls1         - use TLSv1\n");
 784 #endif
 785 #ifndef OPENSSL_NO_DTLS
 786     fprintf(stderr, " -dtls        - use DTLS\n");
 787 #ifndef OPENSSL_NO_DTLS1
 788     fprintf(stderr, " -dtls1        - use DTLSv1\n");
 789 #endif
 790 #ifndef OPENSSL_NO_DTLS1_2
 791     fprintf(stderr, " -dtls12       - use DTLSv1.2\n");
 792 #endif
 793 #endif
 794     fprintf(stderr, " -CApath arg   - PEM format directory of CA's\n");
 795     fprintf(stderr, " -CAfile arg   - PEM format file of CA's\n");
 796     fprintf(stderr, " -cert arg     - Server certificate file\n");
 797     fprintf(stderr,
 798             " -key arg      - Server key file (default: same as -cert)\n");
 799     fprintf(stderr, " -c_cert arg   - Client certificate file\n");
 800     fprintf(stderr,
 801             " -c_key arg    - Client key file (default: same as -c_cert)\n");
 802     fprintf(stderr, " -cipher arg   - The cipher list\n");
 803     fprintf(stderr, " -bio_pair     - Use BIO pairs\n");
 804     fprintf(stderr, " -f            - Test even cases that can't work\n");
 805     fprintf(stderr,
 806             " -time         - measure processor time used by client and server\n");
 807     fprintf(stderr, " -zlib         - use zlib compression\n");
 808 #ifndef OPENSSL_NO_EC
 809     fprintf(stderr,
 810             " -named_curve arg  - Elliptic curve name to use for ephemeral ECDH keys.\n"
 811             "                 Use \"openssl ecparam -list_curves\" for all names\n"
 812             "                 (default is sect163r2).\n");
 813 #endif
 814     fprintf(stderr,
 815             " -test_cipherlist - Verifies the order of the ssl cipher lists.\n"
 816             "                    When this option is requested, the cipherlist\n"
 817             "                    tests are run instead of handshake tests.\n");
 818 #ifndef OPENSSL_NO_NEXTPROTONEG
 819     fprintf(stderr, " -npn_client - have client side offer NPN\n");
 820     fprintf(stderr, " -npn_server - have server side offer NPN\n");
 821     fprintf(stderr, " -npn_server_reject - have server reject NPN\n");
 822 #endif
 823     fprintf(stderr, " -serverinfo_file file - have server use this file\n");
 824     fprintf(stderr, " -serverinfo_sct  - have client offer and expect SCT\n");
 825     fprintf(stderr,
 826             " -serverinfo_tack - have client offer and expect TACK\n");
 827     fprintf(stderr,
 828             " -custom_ext - try various custom extension callbacks\n");
 829     fprintf(stderr, " -alpn_client <string> - have client side offer ALPN\n");
 830     fprintf(stderr, " -alpn_server <string> - have server side offer ALPN\n");
 831     fprintf(stderr,
 832             " -alpn_expected <string> - the ALPN protocol that should be negotiated\n");
 833     fprintf(stderr, " -server_min_proto <string> - Minimum version the server should support\n");
 834     fprintf(stderr, " -server_max_proto <string> - Maximum version the server should support\n");
 835     fprintf(stderr, " -client_min_proto <string> - Minimum version the client should support\n");
 836     fprintf(stderr, " -client_max_proto <string> - Maximum version the client should support\n");
 837     fprintf(stderr, " -should_negotiate <string> - The version that should be negotiated, fail-client or fail-server\n");
 838 }
 839
 840 static void print_key_details(BIO *out, EVP_PKEY *key)
 841 {
 842     int keyid = EVP_PKEY_id(key);
 843 #ifndef OPENSSL_NO_EC
 844     if (keyid == EVP_PKEY_EC) {
 845         EC_KEY *ec = EVP_PKEY_get1_EC_KEY(key);
 846         int nid;
 847         const char *cname;
 848         nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
 849         EC_KEY_free(ec);
 850         cname = EC_curve_nid2nist(nid);
 851         if (!cname)
 852             cname = OBJ_nid2sn(nid);
 853         BIO_printf(out, "%d bits EC (%s)", EVP_PKEY_bits(key), cname);
 854     } else
 855 #endif
 856     {
 857         const char *algname;
 858         switch (keyid) {
 859         case EVP_PKEY_RSA:
 860             algname = "RSA";
 861             break;
 862         case EVP_PKEY_DSA:
 863             algname = "DSA";
 864             break;
 865         case EVP_PKEY_DH:
 866             algname = "DH";
 867             break;
 868         default:
 869             algname = OBJ_nid2sn(keyid);
 870             break;
 871         }
 872         BIO_printf(out, "%d bits %s", EVP_PKEY_bits(key), algname);
 873     }
 874 }
 875
 876 static void print_details(SSL *c_ssl, const char *prefix)
 877 {
 878     const SSL_CIPHER *ciph;
 879     int mdnid;
 880     X509 *cert;
 881     EVP_PKEY *pkey;
 882
 883     ciph = SSL_get_current_cipher(c_ssl);
 884     BIO_printf(bio_stdout, "%s%s, cipher %s %s",
 885                prefix,
 886                SSL_get_version(c_ssl),
 887                SSL_CIPHER_get_version(ciph), SSL_CIPHER_get_name(ciph));
 888     cert = SSL_get_peer_certificate(c_ssl);
 889     if (cert != NULL) {
 890         pkey = X509_get_pubkey(cert);
 891         if (pkey != NULL) {
 892             BIO_puts(bio_stdout, ", ");
 893             print_key_details(bio_stdout, pkey);
 894             EVP_PKEY_free(pkey);
 895         }
 896         X509_free(cert);
 897     }
 898     if (SSL_get_server_tmp_key(c_ssl, &pkey)) {
 899         BIO_puts(bio_stdout, ", temp key: ");
 900         print_key_details(bio_stdout, pkey);
 901         EVP_PKEY_free(pkey);
 902     }
 903     if (SSL_get_peer_signature_nid(c_ssl, &mdnid))
 904         BIO_printf(bio_stdout, ", digest=%s", OBJ_nid2sn(mdnid));
 905     BIO_printf(bio_stdout, "\n");
 906 }
 907
 908 static void lock_dbg_cb(int mode, int type, const char *file, int line)
 909 {
 910     static int modes[CRYPTO_NUM_LOCKS]; /* = {0, 0, ... } */
 911     const char *errstr = NULL;
 912     int rw;
 913
 914     rw = mode & (CRYPTO_READ | CRYPTO_WRITE);
 915     if (!((rw == CRYPTO_READ) || (rw == CRYPTO_WRITE))) {
 916         errstr = "invalid mode";
 917         goto err;
 918     }
 919
 920     if (type < 0 || type >= CRYPTO_NUM_LOCKS) {
 921         errstr = "type out of bounds";
 922         goto err;
 923     }
 924
 925     if (mode & CRYPTO_LOCK) {
 926         if (modes[type]) {
 927             errstr = "already locked";
 928             /*
 929              * must not happen in a single-threaded program (would deadlock)
 930              */
 931             goto err;
 932         }
 933
 934         modes[type] = rw;
 935     } else if (mode & CRYPTO_UNLOCK) {
 936         if (!modes[type]) {
 937             errstr = "not locked";
 938             goto err;
 939         }
 940
 941         if (modes[type] != rw) {
 942             errstr = (rw == CRYPTO_READ) ?
 943                 "CRYPTO_r_unlock on write lock" :
 944                 "CRYPTO_w_unlock on read lock";
 945         }
 946
 947         modes[type] = 0;
 948     } else {
 949         errstr = "invalid mode";
 950         goto err;
 951     }
 952
 953  err:
 954     if (errstr) {
 955         /* we cannot use bio_err here */
 956         fprintf(stderr,
 957                 "openssl (lock_dbg_cb): %s (mode=%d, type=%d) at %s:%d\n",
 958                 errstr, mode, type, file, line);
 959     }
 960 }
 961
 962 /*
 963  * protocol_from_string - converts a protocol version string to a number
 964  *
 965  * Returns -1 on failure or the version on success
 966  */
 967 static int protocol_from_string(const char *value)
 968 {
 969     struct protocol_versions {
 970         const char *name;
 971         int version;
 972     };
 973     static const struct protocol_versions versions[] = {
 974         {"ssl3", SSL3_VERSION},
 975         {"tls1", TLS1_VERSION},
 976         {"tls1.1", TLS1_1_VERSION},
 977         {"tls1.2", TLS1_2_VERSION},
 978         {"dtls1", DTLS1_VERSION},
 979         {"dtls1.2", DTLS1_2_VERSION}};
 980     size_t i;
 981     size_t n = OSSL_NELEM(versions);
 982
 983     for (i = 0; i < n; i++)
 984         if (strcmp(versions[i].name, value) == 0)
 985             return versions[i].version;
 986     return -1;
 987 }
 988
 989 /*
 990  * set_protocol_version - Sets protocol version minimum or maximum
 991  *
 992  * Returns 0 on failure and 1 on success
 993  */
 994 static int set_protocol_version(const char *version, SSL *ssl, int setting)
 995 {
 996     if (version != NULL) {
 997         int ver = protocol_from_string(version);
 998         if (ver < 0) {
 999             BIO_printf(bio_err, "Error parsing: %s\n", version);
1000             return 0;
1001         }
1002         return SSL_ctrl(ssl, setting, ver, NULL);
1003     }
1004     return 1;
1005 }
1006
1007 int main(int argc, char *argv[])
1008 {
1009     char *CApath = NULL, *CAfile = NULL;
1010     int badop = 0;
1011     int bio_pair = 0;
1012     int force = 0;
1013     int dtls1 = 0, dtls12 = 0, dtls = 0, tls1 = 0, ssl3 = 0, ret = 1;
1014     int client_auth = 0;
1015     int server_auth = 0, i;
1016     struct app_verify_arg app_verify_arg =
1017         { APP_CALLBACK_STRING, 0, 0, NULL, NULL };
1018     char *p;
1019 #ifndef OPENSSL_NO_EC
1020     char *named_curve = NULL;
1021 #endif
1022     SSL_CTX *s_ctx = NULL;
1023     SSL_CTX *c_ctx = NULL;
1024     const SSL_METHOD *meth = NULL;
1025     SSL *c_ssl, *s_ssl;
1026     int number = 1, reuse = 0;
1027     long bytes = 256L;
1028 #ifndef OPENSSL_NO_DH
1029     DH *dh;
1030     int dhe512 = 0, dhe1024dsa = 0;
1031 #endif
1032 #ifndef OPENSSL_NO_EC
1033     EC_KEY *ecdh = NULL;
1034 #endif
1035 #ifndef OPENSSL_NO_SRP
1036     /* client */
1037     SRP_CLIENT_ARG srp_client_arg = { NULL, NULL };
1038     /* server */
1039     SRP_SERVER_ARG srp_server_arg = { NULL, NULL };
1040 #endif
1041     int no_dhe = 0;
1042     int no_ecdhe = 0;
1043     int no_psk = 0;
1044     int print_time = 0;
1045     clock_t s_time = 0, c_time = 0;
1046 #ifndef OPENSSL_NO_COMP
1047     int n, comp = 0;
1048     COMP_METHOD *cm = NULL;
1049     STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
1050 #endif
1051     int test_cipherlist = 0;
1052 #ifdef OPENSSL_FIPS
1053     int fips_mode = 0;
1054 #endif
1055     int no_protocol;
1056
1057     SSL_CONF_CTX *s_cctx = NULL, *c_cctx = NULL;
1058     STACK_OF(OPENSSL_STRING) *conf_args = NULL;
1059     char *arg = NULL, *argn = NULL;
1060
1061     verbose = 0;
1062     debug = 0;
1063     cipher = 0;
1064
1065     bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
1066
1067     CRYPTO_set_locking_callback(lock_dbg_cb);
1068
1069     p = getenv("OPENSSL_DEBUG_MEMORY");
1070     if (p != NULL && strcmp(p, "on") == 0)
1071         CRYPTO_set_mem_debug(1);
1072     CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
1073
1074     RAND_seed(rnd_seed, sizeof rnd_seed);
1075
1076     bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);
1077
1078     s_cctx = SSL_CONF_CTX_new();
1079     c_cctx = SSL_CONF_CTX_new();
1080
1081     if (!s_cctx || !c_cctx) {
1082         ERR_print_errors(bio_err);
1083         goto end;
1084     }
1085
1086     SSL_CONF_CTX_set_flags(s_cctx,
1087                            SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_SERVER |
1088                            SSL_CONF_FLAG_CERTIFICATE |
1089                            SSL_CONF_FLAG_REQUIRE_PRIVATE);
1090     if (!SSL_CONF_CTX_set1_prefix(s_cctx, "-s_")) {
1091         ERR_print_errors(bio_err);
1092         goto end;
1093     }
1094
1095     SSL_CONF_CTX_set_flags(c_cctx,
1096                            SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_CLIENT |
1097                            SSL_CONF_FLAG_CERTIFICATE |
1098                            SSL_CONF_FLAG_REQUIRE_PRIVATE);
1099     if (!SSL_CONF_CTX_set1_prefix(c_cctx, "-c_")) {
1100         ERR_print_errors(bio_err);
1101         goto end;
1102     }
1103
1104     argc--;
1105     argv++;
1106
1107     while (argc >= 1) {
1108         if (strcmp(*argv, "-F") == 0) {
1109 #ifdef OPENSSL_FIPS
1110             fips_mode = 1;
1111 #else
1112             fprintf(stderr,
1113                     "not compiled with FIPS support, so exiting without running.\n");
1114             EXIT(0);
1115 #endif
1116         } else if (strcmp(*argv, "-server_auth") == 0)
1117             server_auth = 1;
1118         else if (strcmp(*argv, "-client_auth") == 0)
1119             client_auth = 1;
1120         else if (strcmp(*argv, "-proxy_auth") == 0) {
1121             if (--argc < 1)
1122                 goto bad;
1123             app_verify_arg.proxy_auth = *(++argv);
1124         } else if (strcmp(*argv, "-proxy_cond") == 0) {
1125             if (--argc < 1)
1126                 goto bad;
1127             app_verify_arg.proxy_cond = *(++argv);
1128         } else if (strcmp(*argv, "-v") == 0)
1129             verbose = 1;
1130         else if (strcmp(*argv, "-d") == 0)
1131             debug = 1;
1132         else if (strcmp(*argv, "-reuse") == 0)
1133             reuse = 1;
1134         else if (strcmp(*argv, "-dhe512") == 0) {
1135 #ifndef OPENSSL_NO_DH
1136             dhe512 = 1;
1137 #else
1138             fprintf(stderr,
1139                     "ignoring -dhe512, since I'm compiled without DH\n");
1140 #endif
1141         } else if (strcmp(*argv, "-dhe1024dsa") == 0) {
1142 #ifndef OPENSSL_NO_DH
1143             dhe1024dsa = 1;
1144 #else
1145             fprintf(stderr,
1146                     "ignoring -dhe1024dsa, since I'm compiled without DH\n");
1147 #endif
1148         } else if (strcmp(*argv, "-no_dhe") == 0)
1149             no_dhe = 1;
1150         else if (strcmp(*argv, "-no_ecdhe") == 0)
1151             no_ecdhe = 1;
1152         else if (strcmp(*argv, "-psk") == 0) {
1153             if (--argc < 1)
1154                 goto bad;
1155             psk_key = *(++argv);
1156 #ifndef OPENSSL_NO_PSK
1157             if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key)) {
1158                 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
1159                 goto bad;
1160             }
1161 #else
1162             no_psk = 1;
1163 #endif
1164         }
1165 #ifndef OPENSSL_NO_SRP
1166         else if (strcmp(*argv, "-srpuser") == 0) {
1167             if (--argc < 1)
1168                 goto bad;
1169             srp_server_arg.expected_user = srp_client_arg.srplogin =
1170                 *(++argv);
1171             tls1 = 1;
1172         } else if (strcmp(*argv, "-srppass") == 0) {
1173             if (--argc < 1)
1174                 goto bad;
1175             srp_server_arg.pass = srp_client_arg.srppassin = *(++argv);
1176             tls1 = 1;
1177         }
1178 #endif
1179         else if (strcmp(*argv, "-tls1") == 0) {
1180             tls1 = 1;
1181         } else if (strcmp(*argv, "-ssl3") == 0) {
1182             ssl3 = 1;
1183         } else if (strcmp(*argv, "-dtls1") == 0) {
1184             dtls1 = 1;
1185         } else if (strcmp(*argv, "-dtls12") == 0) {
1186             dtls12 = 1;
1187         } else if (strcmp(*argv, "-dtls") == 0) {
1188             dtls = 1;
1189         } else if (strncmp(*argv, "-num", 4) == 0) {
1190             if (--argc < 1)
1191                 goto bad;
1192             number = atoi(*(++argv));
1193             if (number == 0)
1194                 number = 1;
1195         } else if (strcmp(*argv, "-bytes") == 0) {
1196             if (--argc < 1)
1197                 goto bad;
1198             bytes = atol(*(++argv));
1199             if (bytes == 0L)
1200                 bytes = 1L;
1201             i = strlen(argv[0]);
1202             if (argv[0][i - 1] == 'k')
1203                 bytes *= 1024L;
1204             if (argv[0][i - 1] == 'm')
1205                 bytes *= 1024L * 1024L;
1206         } else if (strcmp(*argv, "-cipher") == 0) {
1207             if (--argc < 1)
1208                 goto bad;
1209             cipher = *(++argv);
1210         } else if (strcmp(*argv, "-CApath") == 0) {
1211             if (--argc < 1)
1212                 goto bad;
1213             CApath = *(++argv);
1214         } else if (strcmp(*argv, "-CAfile") == 0) {
1215             if (--argc < 1)
1216                 goto bad;
1217             CAfile = *(++argv);
1218         } else if (strcmp(*argv, "-bio_pair") == 0) {
1219             bio_pair = 1;
1220         } else if (strcmp(*argv, "-f") == 0) {
1221             force = 1;
1222         } else if (strcmp(*argv, "-time") == 0) {
1223             print_time = 1;
1224         }
1225 #ifndef OPENSSL_NO_COMP
1226         else if (strcmp(*argv, "-zlib") == 0) {
1227             comp = COMP_ZLIB;
1228         }
1229 #endif
1230         else if (strcmp(*argv, "-named_curve") == 0) {
1231             if (--argc < 1)
1232                 goto bad;
1233 #ifndef OPENSSL_NO_EC
1234             named_curve = *(++argv);
1235 #else
1236             fprintf(stderr,
1237                     "ignoring -named_curve, since I'm compiled without ECDH\n");
1238             ++argv;
1239 #endif
1240         } else if (strcmp(*argv, "-app_verify") == 0) {
1241             app_verify_arg.app_verify = 1;
1242         } else if (strcmp(*argv, "-proxy") == 0) {
1243             app_verify_arg.allow_proxy_certs = 1;
1244         } else if (strcmp(*argv, "-test_cipherlist") == 0) {
1245             test_cipherlist = 1;
1246         }
1247 #ifndef OPENSSL_NO_NEXTPROTONEG
1248         else if (strcmp(*argv, "-npn_client") == 0) {
1249             npn_client = 1;
1250         } else if (strcmp(*argv, "-npn_server") == 0) {
1251             npn_server = 1;
1252         } else if (strcmp(*argv, "-npn_server_reject") == 0) {
1253             npn_server_reject = 1;
1254         }
1255 #endif
1256         else if (strcmp(*argv, "-serverinfo_sct") == 0) {
1257             serverinfo_sct = 1;
1258         } else if (strcmp(*argv, "-serverinfo_tack") == 0) {
1259             serverinfo_tack = 1;
1260         } else if (strcmp(*argv, "-serverinfo_file") == 0) {
1261             if (--argc < 1)
1262                 goto bad;
1263             serverinfo_file = *(++argv);
1264         } else if (strcmp(*argv, "-custom_ext") == 0) {
1265             custom_ext = 1;
1266         } else if (strcmp(*argv, "-alpn_client") == 0) {
1267             if (--argc < 1)
1268                 goto bad;
1269             alpn_client = *(++argv);
1270         } else if (strcmp(*argv, "-alpn_server") == 0) {
1271             if (--argc < 1)
1272                 goto bad;
1273             alpn_server = *(++argv);
1274         } else if (strcmp(*argv, "-alpn_expected") == 0) {
1275             if (--argc < 1)
1276                 goto bad;
1277             alpn_expected = *(++argv);
1278         } else if (strcmp(*argv, "-server_min_proto") == 0) {
1279             if (--argc < 1)
1280                 goto bad;
1281             server_min_proto = *(++argv);
1282         } else if (strcmp(*argv, "-server_max_proto") == 0) {
1283             if (--argc < 1)
1284                 goto bad;
1285             server_max_proto = *(++argv);
1286         } else if (strcmp(*argv, "-client_min_proto") == 0) {
1287             if (--argc < 1)
1288                 goto bad;
1289             client_min_proto = *(++argv);
1290         } else if (strcmp(*argv, "-client_max_proto") == 0) {
1291             if (--argc < 1)
1292                 goto bad;
1293             client_max_proto = *(++argv);
1294         } else if (strcmp(*argv, "-should_negotiate") == 0) {
1295             if (--argc < 1)
1296                 goto bad;
1297             should_negotiate = *(++argv);
1298         } else {
1299             int rv;
1300             arg = argv[0];
1301             argn = argv[1];
1302             /* Try to process command using SSL_CONF */
1303             rv = SSL_CONF_cmd_argv(c_cctx, &argc, &argv);
1304             /* If not processed try server */
1305             if (rv == 0)
1306                 rv = SSL_CONF_cmd_argv(s_cctx, &argc, &argv);
1307             /* Recognised: store it for later use */
1308             if (rv > 0) {
1309                 if (rv == 1)
1310                     argn = NULL;
1311                 if (!conf_args) {
1312                     conf_args = sk_OPENSSL_STRING_new_null();
1313                     if (!conf_args)
1314                         goto end;
1315                 }
1316                 if (!sk_OPENSSL_STRING_push(conf_args, arg))
1317                     goto end;
1318                 if (!sk_OPENSSL_STRING_push(conf_args, argn))
1319                     goto end;
1320                 continue;
1321             }
1322             if (rv == -3)
1323                 BIO_printf(bio_err, "Missing argument for %s\n", arg);
1324             else if (rv < 0)
1325                 BIO_printf(bio_err, "Error with command %s\n", arg);
1326             else if (rv == 0)
1327                 BIO_printf(bio_err, "unknown option %s\n", arg);
1328             badop = 1;
1329             break;
1330         }
1331         argc--;
1332         argv++;
1333     }
1334     if (badop) {
1335  bad:
1336         sv_usage();
1337         goto end;
1338     }
1339
1340     /*
1341      * test_cipherlist prevails over protocol switch: we test the cipherlist
1342      * for all enabled protocols.
1343      */
1344     if (test_cipherlist == 1) {
1345         /*
1346          * ensure that the cipher list are correctly sorted and exit
1347          */
1348         fprintf(stdout, "Testing cipherlist order only. Ignoring all "
1349                 "other options.\n");
1350         if (do_test_cipherlist() == 0)
1351             EXIT(1);
1352         ret = 0;
1353         goto end;
1354     }
1355
1356     if (ssl3 + tls1 + dtls + dtls1 + dtls12 > 1) {
1357         fprintf(stderr, "At most one of -ssl3, -tls1, -dtls, -dtls1 or -dtls12 should "
1358                 "be requested.\n");
1359         EXIT(1);
1360     }
1361
1362 #ifdef OPENSSL_NO_SSL3
1363     if (ssl3)
1364         no_protocol = 1;
1365     else
1366 #endif
1367 #ifdef OPENSSL_NO_TLS1
1368     if (tls1)
1369         no_protocol = 1;
1370     else
1371 #endif
1372 #if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1)
1373     if (dtls1)
1374         no_protocol = 1;
1375     else
1376 #endif
1377 #if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1_2)
1378     if (dtls12)
1379         no_protocol = 1;
1380     else
1381 #endif
1382         no_protocol = 0;
1383
1384     /*
1385      * Testing was requested for a compiled-out protocol (e.g. SSLv3).
1386      * Ideally, we would error out, but the generic test wrapper can't know
1387      * when to expect failure. So we do nothing and return success.
1388      */
1389     if (no_protocol) {
1390         fprintf(stderr, "Testing was requested for a disabled protocol. "
1391                 "Skipping tests.\n");
1392         ret = 0;
1393         goto end;
1394     }
1395
1396     if (!ssl3 && !tls1 && !dtls && !dtls1 && !dtls12 && number > 1 && !reuse && !force) {
1397         fprintf(stderr, "This case cannot work.  Use -f to perform "
1398                 "the test anyway (and\n-d to see what happens), "
1399                 "or add one of -ssl3, -tls1, -dtls, -dtls1, -dtls12, -reuse\n"
1400                 "to avoid protocol mismatch.\n");
1401         EXIT(1);
1402     }
1403 #ifdef OPENSSL_FIPS
1404     if (fips_mode) {
1405         if (!FIPS_mode_set(1)) {
1406             ERR_load_crypto_strings();
1407             ERR_print_errors(bio_err);
1408             EXIT(1);
1409         } else
1410             fprintf(stderr, "*** IN FIPS MODE ***\n");
1411     }
1412 #endif
1413
1414     if (print_time) {
1415         if (!bio_pair) {
1416             fprintf(stderr, "Using BIO pair (-bio_pair)\n");
1417             bio_pair = 1;
1418         }
1419         if (number < 50 && !force)
1420             fprintf(stderr,
1421                     "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
1422     }
1423
1424 /*      if (cipher == NULL) cipher=getenv("SSL_CIPHER"); */
1425
1426     SSL_library_init();
1427     SSL_load_error_strings();
1428
1429 #ifndef OPENSSL_NO_COMP
1430     if (comp == COMP_ZLIB)
1431         cm = COMP_zlib();
1432     if (cm != NULL) {
1433         if (COMP_get_type(cm) != NID_undef) {
1434             if (SSL_COMP_add_compression_method(comp, cm) != 0) {
1435                 fprintf(stderr, "Failed to add compression method\n");
1436                 ERR_print_errors_fp(stderr);
1437             }
1438         } else {
1439             fprintf(stderr,
1440                     "Warning: %s compression not supported\n",
1441                     comp == COMP_ZLIB ? "zlib" : "unknown");
1442             ERR_print_errors_fp(stderr);
1443         }
1444     }
1445     ssl_comp_methods = SSL_COMP_get_compression_methods();
1446     n = sk_SSL_COMP_num(ssl_comp_methods);
1447     if (n) {
1448         int j;
1449         printf("Available compression methods:");
1450         for (j = 0; j < n; j++) {
1451             SSL_COMP *c = sk_SSL_COMP_value(ssl_comp_methods, j);
1452             printf("  %s:%d", c->name, c->id);
1453         }
1454         printf("\n");
1455     }
1456 #endif
1457
1458     /*
1459      * At this point, ssl3/tls1 is only set if the protocol is available.
1460      * (Otherwise we exit early.) However the compiler doesn't know this, so
1461      * we ifdef.
1462      */
1463 #ifndef OPENSSL_NO_DTLS
1464 #ifndef OPENSSL_NO_DTLS1
1465     if (dtls1)
1466         meth = DTLSv1_method();
1467     else
1468 #endif
1469 #ifndef OPENSSL_NO_DTLS1_2
1470     if (dtls12)
1471         meth = DTLSv1_2_method();
1472     else
1473 #endif
1474     if (dtls)
1475         meth = DTLS_method();
1476     else
1477 #endif
1478 #ifndef OPENSSL_NO_SSL3
1479     if (ssl3)
1480         meth = SSLv3_method();
1481     else
1482 #endif
1483 #ifndef OPENSSL_NO_TLS1
1484     if (tls1)
1485         meth = TLSv1_method();
1486     else
1487 #endif
1488         meth = TLS_method();
1489
1490     c_ctx = SSL_CTX_new(meth);
1491     s_ctx = SSL_CTX_new(meth);
1492     if ((c_ctx == NULL) || (s_ctx == NULL)) {
1493         ERR_print_errors(bio_err);
1494         goto end;
1495     }
1496     /*
1497      * Since we will use low security ciphersuites and keys for testing set
1498      * security level to zero by default. Tests can override this by adding
1499      * "@SECLEVEL=n" to the cipher string.
1500      */
1501     SSL_CTX_set_security_level(c_ctx, 0);
1502     SSL_CTX_set_security_level(s_ctx, 0);
1503
1504     if (cipher != NULL) {
1505         if (!SSL_CTX_set_cipher_list(c_ctx, cipher)
1506            || !SSL_CTX_set_cipher_list(s_ctx, cipher)) {
1507             ERR_print_errors(bio_err);
1508             goto end;
1509         }
1510     }
1511
1512     /* Process SSL_CONF arguments */
1513     SSL_CONF_CTX_set_ssl_ctx(c_cctx, c_ctx);
1514     SSL_CONF_CTX_set_ssl_ctx(s_cctx, s_ctx);
1515
1516     for (i = 0; i < sk_OPENSSL_STRING_num(conf_args); i += 2) {
1517         int rv;
1518         arg = sk_OPENSSL_STRING_value(conf_args, i);
1519         argn = sk_OPENSSL_STRING_value(conf_args, i + 1);
1520         rv = SSL_CONF_cmd(c_cctx, arg, argn);
1521         /* If not recognised use server context */
1522         if (rv == -2)
1523             rv = SSL_CONF_cmd(s_cctx, arg, argn);
1524         if (rv <= 0) {
1525             BIO_printf(bio_err, "Error processing %s %s\n",
1526                        arg, argn ? argn : "");
1527             ERR_print_errors(bio_err);
1528             goto end;
1529         }
1530     }
1531
1532     if (!SSL_CONF_CTX_finish(s_cctx) || !SSL_CONF_CTX_finish(c_cctx)) {
1533         BIO_puts(bio_err, "Error finishing context\n");
1534         ERR_print_errors(bio_err);
1535         goto end;
1536     }
1537 #ifndef OPENSSL_NO_DH
1538     if (!no_dhe) {
1539         if (dhe1024dsa) {
1540             /*
1541              * use SSL_OP_SINGLE_DH_USE to avoid small subgroup attacks
1542              */
1543             SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_DH_USE);
1544             dh = get_dh1024dsa();
1545         } else if (dhe512)
1546             dh = get_dh512();
1547         else
1548             dh = get_dh1024();
1549         SSL_CTX_set_tmp_dh(s_ctx, dh);
1550         DH_free(dh);
1551     }
1552 #else
1553     (void)no_dhe;
1554 #endif
1555
1556 #ifndef OPENSSL_NO_EC
1557     if (!no_ecdhe) {
1558         int nid;
1559
1560         if (named_curve != NULL) {
1561             nid = OBJ_sn2nid(named_curve);
1562             if (nid == 0) {
1563                 BIO_printf(bio_err, "unknown curve name (%s)\n", named_curve);
1564                 goto end;
1565             }
1566         } else {
1567             nid = NID_X9_62_prime256v1;
1568         }
1569
1570         ecdh = EC_KEY_new_by_curve_name(nid);
1571         if (ecdh == NULL) {
1572             BIO_printf(bio_err, "unable to create curve\n");
1573             goto end;
1574         }
1575
1576         SSL_CTX_set_tmp_ecdh(s_ctx, ecdh);
1577         SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_ECDH_USE);
1578         EC_KEY_free(ecdh);
1579     }
1580 #else
1581     (void)no_ecdhe;
1582 #endif
1583
1584     if ((!SSL_CTX_load_verify_locations(s_ctx, CAfile, CApath)) ||
1585         (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1586         (!SSL_CTX_load_verify_locations(c_ctx, CAfile, CApath)) ||
1587         (!SSL_CTX_set_default_verify_paths(c_ctx))) {
1588         /* fprintf(stderr,"SSL_load_verify_locations\n"); */
1589         ERR_print_errors(bio_err);
1590         /* goto end; */
1591     }
1592
1593     if (client_auth) {
1594         printf("client authentication\n");
1595         SSL_CTX_set_verify(s_ctx,
1596                            SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1597                            verify_callback);
1598         SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback,
1599                                          &app_verify_arg);
1600     }
1601     if (server_auth) {
1602         printf("server authentication\n");
1603         SSL_CTX_set_verify(c_ctx, SSL_VERIFY_PEER, verify_callback);
1604         SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback,
1605                                          &app_verify_arg);
1606     }
1607
1608     {
1609         int session_id_context = 0;
1610         if (!SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context,
1611                                        sizeof session_id_context)) {
1612             ERR_print_errors(bio_err);
1613             goto end;
1614         }
1615     }
1616
1617     /* Use PSK only if PSK key is given */
1618     if (psk_key != NULL) {
1619         /*
1620          * no_psk is used to avoid putting psk command to openssl tool
1621          */
1622         if (no_psk) {
1623             /*
1624              * if PSK is not compiled in and psk key is given, do nothing and
1625              * exit successfully
1626              */
1627             ret = 0;
1628             goto end;
1629         }
1630 #ifndef OPENSSL_NO_PSK
1631         SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1632         SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1633         if (debug)
1634             BIO_printf(bio_err, "setting PSK identity hint to s_ctx\n");
1635         if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint")) {
1636             BIO_printf(bio_err, "error setting PSK identity hint to s_ctx\n");
1637             ERR_print_errors(bio_err);
1638             goto end;
1639         }
1640 #endif
1641     }
1642 #ifndef OPENSSL_NO_SRP
1643     if (srp_client_arg.srplogin) {
1644         if (!SSL_CTX_set_srp_username(c_ctx, srp_client_arg.srplogin)) {
1645             BIO_printf(bio_err, "Unable to set SRP username\n");
1646             goto end;
1647         }
1648         SSL_CTX_set_srp_cb_arg(c_ctx, &srp_client_arg);
1649         SSL_CTX_set_srp_client_pwd_callback(c_ctx,
1650                                             ssl_give_srp_client_pwd_cb);
1651         /*
1652          * SSL_CTX_set_srp_strength(c_ctx, srp_client_arg.strength);
1653          */
1654     }
1655
1656     if (srp_server_arg.expected_user != NULL) {
1657         SSL_CTX_set_verify(s_ctx, SSL_VERIFY_NONE, verify_callback);
1658         SSL_CTX_set_srp_cb_arg(s_ctx, &srp_server_arg);
1659         SSL_CTX_set_srp_username_callback(s_ctx, ssl_srp_server_param_cb);
1660     }
1661 #endif
1662
1663 #ifndef OPENSSL_NO_NEXTPROTONEG
1664     if (npn_client) {
1665         SSL_CTX_set_next_proto_select_cb(c_ctx, cb_client_npn, NULL);
1666     }
1667     if (npn_server) {
1668         if (npn_server_reject) {
1669             BIO_printf(bio_err,
1670                        "Can't have both -npn_server and -npn_server_reject\n");
1671             goto end;
1672         }
1673         SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_npn, NULL);
1674     }
1675     if (npn_server_reject) {
1676         SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_rejects_npn,
1677                                               NULL);
1678     }
1679 #endif
1680
1681     if (serverinfo_sct) {
1682         if (!SSL_CTX_add_client_custom_ext(c_ctx, SCT_EXT_TYPE,
1683                                       NULL, NULL, NULL,
1684                                       serverinfo_cli_parse_cb, NULL)) {
1685             BIO_printf(bio_err, "Error adding SCT extension\n");
1686             goto end;
1687         }
1688     }
1689     if (serverinfo_tack) {
1690         if (!SSL_CTX_add_client_custom_ext(c_ctx, TACK_EXT_TYPE,
1691                                       NULL, NULL, NULL,
1692                                       serverinfo_cli_parse_cb, NULL)) {
1693             BIO_printf(bio_err, "Error adding TACK extension\n");
1694             goto end;
1695         }
1696     }
1697     if (serverinfo_file)
1698         if (!SSL_CTX_use_serverinfo_file(s_ctx, serverinfo_file)) {
1699             BIO_printf(bio_err, "missing serverinfo file\n");
1700             goto end;
1701         }
1702
1703     if (custom_ext) {
1704         if (!SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_0,
1705                                       custom_ext_0_cli_add_cb,
1706                                       NULL, NULL,
1707                                       custom_ext_0_cli_parse_cb, NULL)
1708             || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_1,
1709                                       custom_ext_1_cli_add_cb,
1710                                       NULL, NULL,
1711                                       custom_ext_1_cli_parse_cb, NULL)
1712             || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_2,
1713                                       custom_ext_2_cli_add_cb,
1714                                       NULL, NULL,
1715                                       custom_ext_2_cli_parse_cb, NULL)
1716             || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_3,
1717                                       custom_ext_3_cli_add_cb,
1718                                       NULL, NULL,
1719                                       custom_ext_3_cli_parse_cb, NULL)
1720             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_0,
1721                                       custom_ext_0_srv_add_cb,
1722                                       NULL, NULL,
1723                                       custom_ext_0_srv_parse_cb, NULL)
1724             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_1,
1725                                       custom_ext_1_srv_add_cb,
1726                                       NULL, NULL,
1727                                       custom_ext_1_srv_parse_cb, NULL)
1728             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_2,
1729                                       custom_ext_2_srv_add_cb,
1730                                       NULL, NULL,
1731                                       custom_ext_2_srv_parse_cb, NULL)
1732             || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_3,
1733                                       custom_ext_3_srv_add_cb,
1734                                       NULL, NULL,
1735                                       custom_ext_3_srv_parse_cb, NULL)) {
1736             BIO_printf(bio_err, "Error setting custom extensions\n");
1737             goto end;
1738         }
1739     }
1740
1741     if (alpn_server)
1742         SSL_CTX_set_alpn_select_cb(s_ctx, cb_server_alpn, NULL);
1743
1744     if (alpn_client) {
1745         unsigned short alpn_len;
1746         unsigned char *alpn = next_protos_parse(&alpn_len, alpn_client);
1747
1748         if (alpn == NULL) {
1749             BIO_printf(bio_err, "Error parsing -alpn_client argument\n");
1750             goto end;
1751         }
1752         /* Returns 0 on success!! */
1753         if (SSL_CTX_set_alpn_protos(c_ctx, alpn, alpn_len)) {
1754             BIO_printf(bio_err, "Error setting ALPN\n");
1755             OPENSSL_free(alpn);
1756             goto end;
1757         }
1758         OPENSSL_free(alpn);
1759     }
1760
1761     c_ssl = SSL_new(c_ctx);
1762     s_ssl = SSL_new(s_ctx);
1763
1764     if (!set_protocol_version(server_min_proto, s_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1765         goto end;
1766     if (!set_protocol_version(server_max_proto, s_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1767         goto end;
1768     if (!set_protocol_version(client_min_proto, c_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1769         goto end;
1770     if (!set_protocol_version(client_max_proto, c_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1771         goto end;
1772
1773     BIO_printf(bio_stdout, "Doing handshakes=%d bytes=%ld\n", number, bytes);
1774     for (i = 0; i < number; i++) {
1775         if (!reuse) {
1776             if (!SSL_set_session(c_ssl, NULL)) {
1777                 BIO_printf(bio_err, "Failed to set session\n");
1778                 goto end;
1779             }
1780         }
1781         if (bio_pair)
1782             ret = doit_biopair(s_ssl, c_ssl, bytes, &s_time, &c_time);
1783         else
1784             ret = doit(s_ssl, c_ssl, bytes);
1785         if (ret)  break;
1786     }
1787
1788     if (should_negotiate && ret == 0 &&
1789         strcmp(should_negotiate, "fail-server") != 0 &&
1790         strcmp(should_negotiate, "fail-client") != 0) {
1791         int version = protocol_from_string(should_negotiate);
1792         if (version < 0) {
1793             BIO_printf(bio_err, "Error parsing: %s\n", should_negotiate);
1794             ret = 1;
1795             goto err;
1796         }
1797         if (SSL_version(c_ssl) != version) {
1798             BIO_printf(bio_err, "Unxpected version negotiated. "
1799                 "Expected: %s, got %s\n", should_negotiate, SSL_get_version(c_ssl));
1800             ret = 1;
1801             goto err;
1802         }
1803     }
1804
1805     if (!verbose) {
1806         print_details(c_ssl, "");
1807     }
1808     if (print_time) {
1809 #ifdef CLOCKS_PER_SEC
1810         /*
1811          * "To determine the time in seconds, the value returned by the clock
1812          * function should be divided by the value of the macro
1813          * CLOCKS_PER_SEC." -- ISO/IEC 9899
1814          */
1815         BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1816                    "Approximate total client time: %6.2f s\n",
1817                    (double)s_time / CLOCKS_PER_SEC,
1818                    (double)c_time / CLOCKS_PER_SEC);
1819 #else
1820         BIO_printf(bio_stdout,
1821                    "Approximate total server time: %6.2f units\n"
1822                    "Approximate total client time: %6.2f units\n",
1823                    (double)s_time, (double)c_time);
1824 #endif
1825     }
1826
1827  err:
1828     SSL_free(s_ssl);
1829     SSL_free(c_ssl);
1830
1831  end:
1832     SSL_CTX_free(s_ctx);
1833     SSL_CTX_free(c_ctx);
1834     SSL_CONF_CTX_free(s_cctx);
1835     SSL_CONF_CTX_free(c_cctx);
1836     sk_OPENSSL_STRING_free(conf_args);
1837
1838     BIO_free(bio_stdout);
1839
1840 #ifndef OPENSSL_NO_ENGINE
1841     ENGINE_cleanup();
1842 #endif
1843     CONF_modules_unload(1);
1844     CRYPTO_cleanup_all_ex_data();
1845     ERR_free_strings();
1846     ERR_remove_thread_state(NULL);
1847     EVP_cleanup();
1848 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
1849     CRYPTO_mem_leaks(bio_err);
1850 #endif
1851     BIO_free(bio_err);
1852     EXIT(ret);
1853 }
1854
1855 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
1856                  clock_t *s_time, clock_t *c_time)
1857 {
1858     long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1859     BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1860     BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
1861     int ret = 1;
1862     int err_in_client = 0;
1863     int err_in_server = 0;
1864
1865     size_t bufsiz = 256;        /* small buffer for testing */
1866
1867     if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
1868         goto err;
1869     if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
1870         goto err;
1871
1872     s_ssl_bio = BIO_new(BIO_f_ssl());
1873     if (!s_ssl_bio)
1874         goto err;
1875
1876     c_ssl_bio = BIO_new(BIO_f_ssl());
1877     if (!c_ssl_bio)
1878         goto err;
1879
1880     SSL_set_connect_state(c_ssl);
1881     SSL_set_bio(c_ssl, client, client);
1882     (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1883
1884     SSL_set_accept_state(s_ssl);
1885     SSL_set_bio(s_ssl, server, server);
1886     (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1887
1888     do {
1889         /*-
1890          * c_ssl_bio:          SSL filter BIO
1891          *
1892          * client:             pseudo-I/O for SSL library
1893          *
1894          * client_io:          client's SSL communication; usually to be
1895          *                     relayed over some I/O facility, but in this
1896          *                     test program, we're the server, too:
1897          *
1898          * server_io:          server's SSL communication
1899          *
1900          * server:             pseudo-I/O for SSL library
1901          *
1902          * s_ssl_bio:          SSL filter BIO
1903          *
1904          * The client and the server each employ a "BIO pair":
1905          * client + client_io, server + server_io.
1906          * BIO pairs are symmetric.  A BIO pair behaves similar
1907          * to a non-blocking socketpair (but both endpoints must
1908          * be handled by the same thread).
1909          * [Here we could connect client and server to the ends
1910          * of a single BIO pair, but then this code would be less
1911          * suitable as an example for BIO pairs in general.]
1912          *
1913          * Useful functions for querying the state of BIO pair endpoints:
1914          *
1915          * BIO_ctrl_pending(bio)              number of bytes we can read now
1916          * BIO_ctrl_get_read_request(bio)     number of bytes needed to fulfil
1917          *                                      other side's read attempt
1918          * BIO_ctrl_get_write_guarantee(bio)   number of bytes we can write now
1919          *
1920          * ..._read_request is never more than ..._write_guarantee;
1921          * it depends on the application which one you should use.
1922          */
1923
1924         /*
1925          * We have non-blocking behaviour throughout this test program, but
1926          * can be sure that there is *some* progress in each iteration; so we
1927          * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
1928          * we just try everything in each iteration
1929          */
1930
1931         {
1932             /* CLIENT */
1933
1934             char cbuf[1024 * 8];
1935             int i, r;
1936             clock_t c_clock = clock();
1937
1938             memset(cbuf, 0, sizeof(cbuf));
1939
1940             if (debug)
1941                 if (SSL_in_init(c_ssl))
1942                     printf("client waiting in SSL_connect - %s\n",
1943                            SSL_state_string_long(c_ssl));
1944
1945             if (cw_num > 0) {
1946                 /* Write to server. */
1947
1948                 if (cw_num > (long)sizeof cbuf)
1949                     i = sizeof cbuf;
1950                 else
1951                     i = (int)cw_num;
1952                 r = BIO_write(c_ssl_bio, cbuf, i);
1953                 if (r < 0) {
1954                     if (!BIO_should_retry(c_ssl_bio)) {
1955                         fprintf(stderr, "ERROR in CLIENT\n");
1956                         err_in_client = 1;
1957                         goto err;
1958                     }
1959                     /*
1960                      * BIO_should_retry(...) can just be ignored here. The
1961                      * library expects us to call BIO_write with the same
1962                      * arguments again, and that's what we will do in the
1963                      * next iteration.
1964                      */
1965                 } else if (r == 0) {
1966                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1967                     goto err;
1968                 } else {
1969                     if (debug)
1970                         printf("client wrote %d\n", r);
1971                     cw_num -= r;
1972                 }
1973             }
1974
1975             if (cr_num > 0) {
1976                 /* Read from server. */
1977
1978                 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1979                 if (r < 0) {
1980                     if (!BIO_should_retry(c_ssl_bio)) {
1981                         fprintf(stderr, "ERROR in CLIENT\n");
1982                         err_in_client = 1;
1983                         goto err;
1984                     }
1985                     /*
1986                      * Again, "BIO_should_retry" can be ignored.
1987                      */
1988                 } else if (r == 0) {
1989                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1990                     goto err;
1991                 } else {
1992                     if (debug)
1993                         printf("client read %d\n", r);
1994                     cr_num -= r;
1995                 }
1996             }
1997
1998             /*
1999              * c_time and s_time increments will typically be very small
2000              * (depending on machine speed and clock tick intervals), but
2001              * sampling over a large number of connections should result in
2002              * fairly accurate figures.  We cannot guarantee a lot, however
2003              * -- if each connection lasts for exactly one clock tick, it
2004              * will be counted only for the client or only for the server or
2005              * even not at all.
2006              */
2007             *c_time += (clock() - c_clock);
2008         }
2009
2010         {
2011             /* SERVER */
2012
2013             char sbuf[1024 * 8];
2014             int i, r;
2015             clock_t s_clock = clock();
2016
2017             memset(sbuf, 0, sizeof(sbuf));
2018
2019             if (debug)
2020                 if (SSL_in_init(s_ssl))
2021                     printf("server waiting in SSL_accept - %s\n",
2022                            SSL_state_string_long(s_ssl));
2023
2024             if (sw_num > 0) {
2025                 /* Write to client. */
2026
2027                 if (sw_num > (long)sizeof sbuf)
2028                     i = sizeof sbuf;
2029                 else
2030                     i = (int)sw_num;
2031                 r = BIO_write(s_ssl_bio, sbuf, i);
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                     /* Ignore "BIO_should_retry". */
2039                 } else if (r == 0) {
2040                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2041                     goto err;
2042                 } else {
2043                     if (debug)
2044                         printf("server wrote %d\n", r);
2045                     sw_num -= r;
2046                 }
2047             }
2048
2049             if (sr_num > 0) {
2050                 /* Read from client. */
2051
2052                 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2053                 if (r < 0) {
2054                     if (!BIO_should_retry(s_ssl_bio)) {
2055                         fprintf(stderr, "ERROR in SERVER\n");
2056                         err_in_server = 1;
2057                         goto err;
2058                     }
2059                     /* blah, blah */
2060                 } else if (r == 0) {
2061                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2062                     goto err;
2063                 } else {
2064                     if (debug)
2065                         printf("server read %d\n", r);
2066                     sr_num -= r;
2067                 }
2068             }
2069
2070             *s_time += (clock() - s_clock);
2071         }
2072
2073         {
2074             /* "I/O" BETWEEN CLIENT AND SERVER. */
2075
2076             size_t r1, r2;
2077             BIO *io1 = server_io, *io2 = client_io;
2078             /*
2079              * we use the non-copying interface for io1 and the standard
2080              * BIO_write/BIO_read interface for io2
2081              */
2082
2083             static int prev_progress = 1;
2084             int progress = 0;
2085
2086             /* io1 to io2 */
2087             do {
2088                 size_t num;
2089                 int r;
2090
2091                 r1 = BIO_ctrl_pending(io1);
2092                 r2 = BIO_ctrl_get_write_guarantee(io2);
2093
2094                 num = r1;
2095                 if (r2 < num)
2096                     num = r2;
2097                 if (num) {
2098                     char *dataptr;
2099
2100                     if (INT_MAX < num) /* yeah, right */
2101                         num = INT_MAX;
2102
2103                     r = BIO_nread(io1, &dataptr, (int)num);
2104                     assert(r > 0);
2105                     assert(r <= (int)num);
2106                     /*
2107                      * possibly r < num (non-contiguous data)
2108                      */
2109                     num = r;
2110                     r = BIO_write(io2, dataptr, (int)num);
2111                     if (r != (int)num) { /* can't happen */
2112                         fprintf(stderr, "ERROR: BIO_write could not write "
2113                                 "BIO_ctrl_get_write_guarantee() bytes");
2114                         goto err;
2115                     }
2116                     progress = 1;
2117
2118                     if (debug)
2119                         printf((io1 == client_io) ?
2120                                "C->S relaying: %d bytes\n" :
2121                                "S->C relaying: %d bytes\n", (int)num);
2122                 }
2123             }
2124             while (r1 && r2);
2125
2126             /* io2 to io1 */
2127             {
2128                 size_t num;
2129                 int r;
2130
2131                 r1 = BIO_ctrl_pending(io2);
2132                 r2 = BIO_ctrl_get_read_request(io1);
2133                 /*
2134                  * here we could use ..._get_write_guarantee instead of
2135                  * ..._get_read_request, but by using the latter we test
2136                  * restartability of the SSL implementation more thoroughly
2137                  */
2138                 num = r1;
2139                 if (r2 < num)
2140                     num = r2;
2141                 if (num) {
2142                     char *dataptr;
2143
2144                     if (INT_MAX < num)
2145                         num = INT_MAX;
2146
2147                     if (num > 1)
2148                         --num;  /* test restartability even more thoroughly */
2149
2150                     r = BIO_nwrite0(io1, &dataptr);
2151                     assert(r > 0);
2152                     if (r < (int)num)
2153                         num = r;
2154                     r = BIO_read(io2, dataptr, (int)num);
2155                     if (r != (int)num) { /* can't happen */
2156                         fprintf(stderr, "ERROR: BIO_read could not read "
2157                                 "BIO_ctrl_pending() bytes");
2158                         goto err;
2159                     }
2160                     progress = 1;
2161                     r = BIO_nwrite(io1, &dataptr, (int)num);
2162                     if (r != (int)num) { /* can't happen */
2163                         fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
2164                                 "BIO_nwrite0() bytes");
2165                         goto err;
2166                     }
2167
2168                     if (debug)
2169                         printf((io2 == client_io) ?
2170                                "C->S relaying: %d bytes\n" :
2171                                "S->C relaying: %d bytes\n", (int)num);
2172                 }
2173             }                   /* no loop, BIO_ctrl_get_read_request now
2174                                  * returns 0 anyway */
2175
2176             if (!progress && !prev_progress)
2177                 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0) {
2178                     fprintf(stderr, "ERROR: got stuck\n");
2179                     fprintf(stderr, " ERROR.\n");
2180                     goto err;
2181                 }
2182             prev_progress = progress;
2183         }
2184     }
2185     while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2186
2187     if (verbose)
2188         print_details(c_ssl, "DONE via BIO pair: ");
2189 #ifndef OPENSSL_NO_NEXTPROTONEG
2190     if (verify_npn(c_ssl, s_ssl) < 0) {
2191         ret = 1;
2192         goto end;
2193     }
2194 #endif
2195     if (verify_serverinfo() < 0) {
2196         fprintf(stderr, "Server info verify error\n");
2197         ret = 1;
2198         goto err;
2199     }
2200     if (verify_alpn(c_ssl, s_ssl) < 0) {
2201         ret = 1;
2202         goto err;
2203     }
2204
2205     if (custom_ext_error) {
2206         fprintf(stderr, "Custom extension error\n");
2207         ret = 1;
2208         goto err;
2209     }
2210
2211  end:
2212     ret = 0;
2213
2214  err:
2215     ERR_print_errors(bio_err);
2216
2217     BIO_free(server);
2218     BIO_free(server_io);
2219     BIO_free(client);
2220     BIO_free(client_io);
2221     BIO_free(s_ssl_bio);
2222     BIO_free(c_ssl_bio);
2223
2224     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2225         ret = (err_in_client != 0) ? 0 : 1;
2226     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2227         ret = (err_in_server != 0) ? 0 : 1;
2228
2229     return ret;
2230 }
2231
2232 #define W_READ  1
2233 #define W_WRITE 2
2234 #define C_DONE  1
2235 #define S_DONE  2
2236
2237 int doit(SSL *s_ssl, SSL *c_ssl, long count)
2238 {
2239     char *cbuf = NULL, *sbuf = NULL;
2240     long bufsiz;
2241     long cw_num = count, cr_num = count;
2242     long sw_num = count, sr_num = count;
2243     int ret = 1;
2244     BIO *c_to_s = NULL;
2245     BIO *s_to_c = NULL;
2246     BIO *c_bio = NULL;
2247     BIO *s_bio = NULL;
2248     int c_r, c_w, s_r, s_w;
2249     int i, j;
2250     int done = 0;
2251     int c_write, s_write;
2252     int do_server = 0, do_client = 0;
2253     int max_frag = 5 * 1024;
2254     int err_in_client = 0;
2255     int err_in_server = 0;
2256
2257     bufsiz = count > 40 * 1024 ? 40 * 1024 : count;
2258
2259     if ((cbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2260         goto err;
2261     if ((sbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2262         goto err;
2263
2264     c_to_s = BIO_new(BIO_s_mem());
2265     s_to_c = BIO_new(BIO_s_mem());
2266     if ((s_to_c == NULL) || (c_to_s == NULL)) {
2267         ERR_print_errors(bio_err);
2268         goto err;
2269     }
2270
2271     c_bio = BIO_new(BIO_f_ssl());
2272     s_bio = BIO_new(BIO_f_ssl());
2273     if ((c_bio == NULL) || (s_bio == NULL)) {
2274         ERR_print_errors(bio_err);
2275         goto err;
2276     }
2277
2278     SSL_set_connect_state(c_ssl);
2279     SSL_set_bio(c_ssl, s_to_c, c_to_s);
2280     SSL_set_max_send_fragment(c_ssl, max_frag);
2281     BIO_set_ssl(c_bio, c_ssl, BIO_NOCLOSE);
2282
2283     SSL_set_accept_state(s_ssl);
2284     SSL_set_bio(s_ssl, c_to_s, s_to_c);
2285     SSL_set_max_send_fragment(s_ssl, max_frag);
2286     BIO_set_ssl(s_bio, s_ssl, BIO_NOCLOSE);
2287
2288     c_r = 0;
2289     s_r = 1;
2290     c_w = 1;
2291     s_w = 0;
2292     c_write = 1, s_write = 0;
2293
2294     /* We can always do writes */
2295     for (;;) {
2296         do_server = 0;
2297         do_client = 0;
2298
2299         i = (int)BIO_pending(s_bio);
2300         if ((i && s_r) || s_w)
2301             do_server = 1;
2302
2303         i = (int)BIO_pending(c_bio);
2304         if ((i && c_r) || c_w)
2305             do_client = 1;
2306
2307         if (do_server && debug) {
2308             if (SSL_in_init(s_ssl))
2309                 printf("server waiting in SSL_accept - %s\n",
2310                        SSL_state_string_long(s_ssl));
2311 /*-
2312             else if (s_write)
2313                 printf("server:SSL_write()\n");
2314             else
2315                 printf("server:SSL_read()\n"); */
2316         }
2317
2318         if (do_client && debug) {
2319             if (SSL_in_init(c_ssl))
2320                 printf("client waiting in SSL_connect - %s\n",
2321                        SSL_state_string_long(c_ssl));
2322 /*-
2323             else if (c_write)
2324                 printf("client:SSL_write()\n");
2325             else
2326                 printf("client:SSL_read()\n"); */
2327         }
2328
2329         if (!do_client && !do_server) {
2330             fprintf(stdout, "ERROR IN STARTUP\n");
2331             ERR_print_errors(bio_err);
2332             goto err;
2333         }
2334         if (do_client && !(done & C_DONE)) {
2335             if (c_write) {
2336                 j = (cw_num > bufsiz) ? (int)bufsiz : (int)cw_num;
2337                 i = BIO_write(c_bio, cbuf, j);
2338                 if (i < 0) {
2339                     c_r = 0;
2340                     c_w = 0;
2341                     if (BIO_should_retry(c_bio)) {
2342                         if (BIO_should_read(c_bio))
2343                             c_r = 1;
2344                         if (BIO_should_write(c_bio))
2345                             c_w = 1;
2346                     } else {
2347                         fprintf(stderr, "ERROR in CLIENT\n");
2348                         err_in_client = 1;
2349                         ERR_print_errors(bio_err);
2350                         goto err;
2351                     }
2352                 } else if (i == 0) {
2353                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2354                     goto err;
2355                 } else {
2356                     if (debug)
2357                         printf("client wrote %d\n", i);
2358                     /* ok */
2359                     s_r = 1;
2360                     c_write = 0;
2361                     cw_num -= i;
2362                     if (max_frag > 1029)
2363                         SSL_set_max_send_fragment(c_ssl, max_frag -= 5);
2364                 }
2365             } else {
2366                 i = BIO_read(c_bio, cbuf, bufsiz);
2367                 if (i < 0) {
2368                     c_r = 0;
2369                     c_w = 0;
2370                     if (BIO_should_retry(c_bio)) {
2371                         if (BIO_should_read(c_bio))
2372                             c_r = 1;
2373                         if (BIO_should_write(c_bio))
2374                             c_w = 1;
2375                     } else {
2376                         fprintf(stderr, "ERROR in CLIENT\n");
2377                         err_in_client = 1;
2378                         ERR_print_errors(bio_err);
2379                         goto err;
2380                     }
2381                 } else if (i == 0) {
2382                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2383                     goto err;
2384                 } else {
2385                     if (debug)
2386                         printf("client read %d\n", i);
2387                     cr_num -= i;
2388                     if (sw_num > 0) {
2389                         s_write = 1;
2390                         s_w = 1;
2391                     }
2392                     if (cr_num <= 0) {
2393                         s_write = 1;
2394                         s_w = 1;
2395                         done = S_DONE | C_DONE;
2396                     }
2397                 }
2398             }
2399         }
2400
2401         if (do_server && !(done & S_DONE)) {
2402             if (!s_write) {
2403                 i = BIO_read(s_bio, sbuf, bufsiz);
2404                 if (i < 0) {
2405                     s_r = 0;
2406                     s_w = 0;
2407                     if (BIO_should_retry(s_bio)) {
2408                         if (BIO_should_read(s_bio))
2409                             s_r = 1;
2410                         if (BIO_should_write(s_bio))
2411                             s_w = 1;
2412                     } else {
2413                         fprintf(stderr, "ERROR in SERVER\n");
2414                         err_in_server = 1;
2415                         ERR_print_errors(bio_err);
2416                         goto err;
2417                     }
2418                 } else if (i == 0) {
2419                     ERR_print_errors(bio_err);
2420                     fprintf(stderr,
2421                             "SSL SERVER STARTUP FAILED in SSL_read\n");
2422                     goto err;
2423                 } else {
2424                     if (debug)
2425                         printf("server read %d\n", i);
2426                     sr_num -= i;
2427                     if (cw_num > 0) {
2428                         c_write = 1;
2429                         c_w = 1;
2430                     }
2431                     if (sr_num <= 0) {
2432                         s_write = 1;
2433                         s_w = 1;
2434                         c_write = 0;
2435                     }
2436                 }
2437             } else {
2438                 j = (sw_num > bufsiz) ? (int)bufsiz : (int)sw_num;
2439                 i = BIO_write(s_bio, sbuf, j);
2440                 if (i < 0) {
2441                     s_r = 0;
2442                     s_w = 0;
2443                     if (BIO_should_retry(s_bio)) {
2444                         if (BIO_should_read(s_bio))
2445                             s_r = 1;
2446                         if (BIO_should_write(s_bio))
2447                             s_w = 1;
2448                     } else {
2449                         fprintf(stderr, "ERROR in SERVER\n");
2450                         err_in_server = 1;
2451                         ERR_print_errors(bio_err);
2452                         goto err;
2453                     }
2454                 } else if (i == 0) {
2455                     ERR_print_errors(bio_err);
2456                     fprintf(stderr,
2457                             "SSL SERVER STARTUP FAILED in SSL_write\n");
2458                     goto err;
2459                 } else {
2460                     if (debug)
2461                         printf("server wrote %d\n", i);
2462                     sw_num -= i;
2463                     s_write = 0;
2464                     c_r = 1;
2465                     if (sw_num <= 0)
2466                         done |= S_DONE;
2467                     if (max_frag > 1029)
2468                         SSL_set_max_send_fragment(s_ssl, max_frag -= 5);
2469                 }
2470             }
2471         }
2472
2473         if ((done & S_DONE) && (done & C_DONE))
2474             break;
2475     }
2476
2477     if (verbose)
2478         print_details(c_ssl, "DONE: ");
2479 #ifndef OPENSSL_NO_NEXTPROTONEG
2480     if (verify_npn(c_ssl, s_ssl) < 0) {
2481         ret = 1;
2482         goto err;
2483     }
2484 #endif
2485     if (verify_serverinfo() < 0) {
2486         fprintf(stderr, "Server info verify error\n");
2487         ret = 1;
2488         goto err;
2489     }
2490     if (custom_ext_error) {
2491         fprintf(stderr, "Custom extension error\n");
2492         ret = 1;
2493         goto err;
2494     }
2495     ret = 0;
2496  err:
2497     /*
2498      * We have to set the BIO's to NULL otherwise they will be
2499      * OPENSSL_free()ed twice.  Once when th s_ssl is SSL_free()ed and again
2500      * when c_ssl is SSL_free()ed. This is a hack required because s_ssl and
2501      * c_ssl are sharing the same BIO structure and SSL_set_bio() and
2502      * SSL_free() automatically BIO_free non NULL entries. You should not
2503      * normally do this or be required to do this
2504      */
2505     if (s_ssl != NULL) {
2506         s_ssl->rbio = NULL;
2507         s_ssl->wbio = NULL;
2508     }
2509     if (c_ssl != NULL) {
2510         c_ssl->rbio = NULL;
2511         c_ssl->wbio = NULL;
2512     }
2513
2514     BIO_free(c_to_s);
2515     BIO_free(s_to_c);
2516     BIO_free_all(c_bio);
2517     BIO_free_all(s_bio);
2518     OPENSSL_free(cbuf);
2519     OPENSSL_free(sbuf);
2520
2521     if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2522         ret = (err_in_client != 0) ? 0 : 1;
2523     else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2524         ret = (err_in_server != 0) ? 0 : 1;
2525
2526     return (ret);
2527 }
2528
2529 static int get_proxy_auth_ex_data_idx(void)
2530 {
2531     static volatile int idx = -1;
2532     if (idx < 0) {
2533         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
2534         if (idx < 0) {
2535             idx = X509_STORE_CTX_get_ex_new_index(0,
2536                                                   "SSLtest for verify callback",
2537                                                   NULL, NULL, NULL);
2538         }
2539         CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
2540     }
2541     return idx;
2542 }
2543
2544 static int verify_callback(int ok, X509_STORE_CTX *ctx)
2545 {
2546     char *s, buf[256];
2547
2548     s = X509_NAME_oneline(X509_get_subject_name(ctx->current_cert), buf,
2549                           sizeof buf);
2550     if (s != NULL) {
2551         if (ok)
2552             printf("depth=%d %s\n", ctx->error_depth, buf);
2553         else {
2554             fprintf(stderr, "depth=%d error=%d %s\n",
2555                     ctx->error_depth, ctx->error, buf);
2556         }
2557     }
2558
2559     if (ok == 0) {
2560         switch (ctx->error) {
2561         default:
2562             fprintf(stderr, "Error string: %s\n",
2563                     X509_verify_cert_error_string(ctx->error));
2564             break;
2565         case X509_V_ERR_CERT_NOT_YET_VALID:
2566         case X509_V_ERR_CERT_HAS_EXPIRED:
2567         case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2568             ok = 1;
2569         }
2570     }
2571
2572     if (ok == 1) {
2573         X509 *xs = ctx->current_cert;
2574         if (X509_get_extension_flags(xs) & EXFLAG_PROXY) {
2575             unsigned int *letters = X509_STORE_CTX_get_ex_data(ctx,
2576                                                                get_proxy_auth_ex_data_idx
2577                                                                ());
2578
2579             if (letters) {
2580                 int found_any = 0;
2581                 int i;
2582                 PROXY_CERT_INFO_EXTENSION *pci =
2583                     X509_get_ext_d2i(xs, NID_proxyCertInfo,
2584                                      NULL, NULL);
2585
2586                 switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage)) {
2587                 case NID_Independent:
2588                     /*
2589                      * Completely meaningless in this program, as there's no
2590                      * way to grant explicit rights to a specific PrC.
2591                      * Basically, using id-ppl-Independent is the perfect way
2592                      * to grant no rights at all.
2593                      */
2594                     fprintf(stderr, "  Independent proxy certificate");
2595                     for (i = 0; i < 26; i++)
2596                         letters[i] = 0;
2597                     break;
2598                 case NID_id_ppl_inheritAll:
2599                     /*
2600                      * This is basically a NOP, we simply let the current
2601                      * rights stand as they are.
2602                      */
2603                     fprintf(stderr, "  Proxy certificate inherits all");
2604                     break;
2605                 default:
2606                     s = (char *)
2607                         pci->proxyPolicy->policy->data;
2608                     i = pci->proxyPolicy->policy->length;
2609
2610                     /*
2611                      * The algorithm works as follows: it is assumed that
2612                      * previous iterations or the initial granted rights has
2613                      * already set some elements of `letters'.  What we need
2614                      * to do is to clear those that weren't granted by the
2615                      * current PrC as well.  The easiest way to do this is to
2616                      * add 1 to all the elements whose letters are given with
2617                      * the current policy. That way, all elements that are
2618                      * set by the current policy and were already set by
2619                      * earlier policies and through the original grant of
2620                      * rights will get the value 2 or higher. The last thing
2621                      * to do is to sweep through `letters' and keep the
2622                      * elements having the value 2 as set, and clear all the
2623                      * others.
2624                      */
2625
2626                     printf("  Certificate proxy rights = %*.*s", i,
2627                             i, s);
2628                     while (i-- > 0) {
2629                         int c = *s++;
2630                         if (isascii(c) && isalpha(c)) {
2631                             if (islower(c))
2632                                 c = toupper(c);
2633                             letters[c - 'A']++;
2634                         }
2635                     }
2636                     for (i = 0; i < 26; i++)
2637                         if (letters[i] < 2)
2638                             letters[i] = 0;
2639                         else
2640                             letters[i] = 1;
2641                 }
2642
2643                 found_any = 0;
2644                 printf(", resulting proxy rights = ");
2645                 for (i = 0; i < 26; i++)
2646                     if (letters[i]) {
2647                         printf("%c", i + 'A');
2648                         found_any = 1;
2649                     }
2650                 if (!found_any)
2651                     printf("none");
2652                 printf("\n");
2653
2654                 PROXY_CERT_INFO_EXTENSION_free(pci);
2655             }
2656         }
2657     }
2658
2659     return (ok);
2660 }
2661
2662 static void process_proxy_debug(int indent, const char *format, ...)
2663 {
2664     /* That's 80 > */
2665     static const char indentation[] =
2666         ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
2667         ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
2668     char my_format[256];
2669     va_list args;
2670
2671     BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
2672                  indent, indent, indentation, format);
2673
2674     va_start(args, format);
2675     vfprintf(stderr, my_format, args);
2676     va_end(args);
2677 }
2678
2679 /*-
2680  * Priority levels:
2681  *  0   [!]var, ()
2682  *  1   & ^
2683  *  2   |
2684  */
2685 static int process_proxy_cond_adders(unsigned int letters[26],
2686                                      const char *cond, const char **cond_end,
2687                                      int *pos, int indent);
2688 static int process_proxy_cond_val(unsigned int letters[26], const char *cond,
2689                                   const char **cond_end, int *pos, int indent)
2690 {
2691     int c;
2692     int ok = 1;
2693     int negate = 0;
2694
2695     while (isspace((int)*cond)) {
2696         cond++;
2697         (*pos)++;
2698     }
2699     c = *cond;
2700
2701     if (debug)
2702         process_proxy_debug(indent,
2703                             "Start process_proxy_cond_val at position %d: %s\n",
2704                             *pos, cond);
2705
2706     while (c == '!') {
2707         negate = !negate;
2708         cond++;
2709         (*pos)++;
2710         while (isspace((int)*cond)) {
2711             cond++;
2712             (*pos)++;
2713         }
2714         c = *cond;
2715     }
2716
2717     if (c == '(') {
2718         cond++;
2719         (*pos)++;
2720         ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
2721                                        indent + 1);
2722         cond = *cond_end;
2723         if (ok < 0)
2724             goto end;
2725         while (isspace((int)*cond)) {
2726             cond++;
2727             (*pos)++;
2728         }
2729         c = *cond;
2730         if (c != ')') {
2731             fprintf(stderr,
2732                     "Weird condition character in position %d: "
2733                     "%c\n", *pos, c);
2734             ok = -1;
2735             goto end;
2736         }
2737         cond++;
2738         (*pos)++;
2739     } else if (isascii(c) && isalpha(c)) {
2740         if (islower(c))
2741             c = toupper(c);
2742         ok = letters[c - 'A'];
2743         cond++;
2744         (*pos)++;
2745     } else {
2746         fprintf(stderr,
2747                 "Weird condition character in position %d: " "%c\n", *pos, c);
2748         ok = -1;
2749         goto end;
2750     }
2751  end:
2752     *cond_end = cond;
2753     if (ok >= 0 && negate)
2754         ok = !ok;
2755
2756     if (debug)
2757         process_proxy_debug(indent,
2758                             "End process_proxy_cond_val at position %d: %s, returning %d\n",
2759                             *pos, cond, ok);
2760
2761     return ok;
2762 }
2763
2764 static int process_proxy_cond_multipliers(unsigned int letters[26],
2765                                           const char *cond,
2766                                           const char **cond_end, int *pos,
2767                                           int indent)
2768 {
2769     int ok;
2770     char c;
2771
2772     if (debug)
2773         process_proxy_debug(indent,
2774                             "Start process_proxy_cond_multipliers at position %d: %s\n",
2775                             *pos, cond);
2776
2777     ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
2778     cond = *cond_end;
2779     if (ok < 0)
2780         goto end;
2781
2782     while (ok >= 0) {
2783         while (isspace((int)*cond)) {
2784             cond++;
2785             (*pos)++;
2786         }
2787         c = *cond;
2788
2789         switch (c) {
2790         case '&':
2791         case '^':
2792             {
2793                 int save_ok = ok;
2794
2795                 cond++;
2796                 (*pos)++;
2797                 ok = process_proxy_cond_val(letters,
2798                                             cond, cond_end, pos, indent + 1);
2799                 cond = *cond_end;
2800                 if (ok < 0)
2801                     break;
2802
2803                 switch (c) {
2804                 case '&':
2805                     ok &= save_ok;
2806                     break;
2807                 case '^':
2808                     ok ^= save_ok;
2809                     break;
2810                 default:
2811                     fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2812                             " STOPPING\n");
2813                     EXIT(1);
2814                 }
2815             }
2816             break;
2817         default:
2818             goto end;
2819         }
2820     }
2821  end:
2822     if (debug)
2823         process_proxy_debug(indent,
2824                             "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
2825                             *pos, cond, ok);
2826
2827     *cond_end = cond;
2828     return ok;
2829 }
2830
2831 static int process_proxy_cond_adders(unsigned int letters[26],
2832                                      const char *cond, const char **cond_end,
2833                                      int *pos, int indent)
2834 {
2835     int ok;
2836     char c;
2837
2838     if (debug)
2839         process_proxy_debug(indent,
2840                             "Start process_proxy_cond_adders at position %d: %s\n",
2841                             *pos, cond);
2842
2843     ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
2844                                         indent + 1);
2845     cond = *cond_end;
2846     if (ok < 0)
2847         goto end;
2848
2849     while (ok >= 0) {
2850         while (isspace((int)*cond)) {
2851             cond++;
2852             (*pos)++;
2853         }
2854         c = *cond;
2855
2856         switch (c) {
2857         case '|':
2858             {
2859                 int save_ok = ok;
2860
2861                 cond++;
2862                 (*pos)++;
2863                 ok = process_proxy_cond_multipliers(letters,
2864                                                     cond, cond_end, pos,
2865                                                     indent + 1);
2866                 cond = *cond_end;
2867                 if (ok < 0)
2868                     break;
2869
2870                 switch (c) {
2871                 case '|':
2872                     ok |= save_ok;
2873                     break;
2874                 default:
2875                     fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2876                             " STOPPING\n");
2877                     EXIT(1);
2878                 }
2879             }
2880             break;
2881         default:
2882             goto end;
2883         }
2884     }
2885  end:
2886     if (debug)
2887         process_proxy_debug(indent,
2888                             "End process_proxy_cond_adders at position %d: %s, returning %d\n",
2889                             *pos, cond, ok);
2890
2891     *cond_end = cond;
2892     return ok;
2893 }
2894
2895 static int process_proxy_cond(unsigned int letters[26],
2896                               const char *cond, const char **cond_end)
2897 {
2898     int pos = 1;
2899     return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
2900 }
2901
2902 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2903 {
2904     int ok = 1;
2905     struct app_verify_arg *cb_arg = arg;
2906     unsigned int letters[26];   /* only used with proxy_auth */
2907
2908     if (cb_arg->app_verify) {
2909         char *s = NULL, buf[256];
2910
2911         printf("In app_verify_callback, allowing cert. ");
2912         printf("Arg is: %s\n", cb_arg->string);
2913         printf("Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2914                 (void *)ctx, (void *)ctx->cert);
2915         if (ctx->cert)
2916             s = X509_NAME_oneline(X509_get_subject_name(ctx->cert), buf, 256);
2917         if (s != NULL) {
2918             printf("cert depth=%d %s\n", ctx->error_depth, buf);
2919         }
2920         return (1);
2921     }
2922     if (cb_arg->proxy_auth) {
2923         int found_any = 0, i;
2924         char *sp;
2925
2926         for (i = 0; i < 26; i++)
2927             letters[i] = 0;
2928         for (sp = cb_arg->proxy_auth; *sp; sp++) {
2929             int c = *sp;
2930             if (isascii(c) && isalpha(c)) {
2931                 if (islower(c))
2932                     c = toupper(c);
2933                 letters[c - 'A'] = 1;
2934             }
2935         }
2936
2937         printf("  Initial proxy rights = ");
2938         for (i = 0; i < 26; i++)
2939             if (letters[i]) {
2940                 printf("%c", i + 'A');
2941                 found_any = 1;
2942             }
2943         if (!found_any)
2944             printf("none");
2945         printf("\n");
2946
2947         X509_STORE_CTX_set_ex_data(ctx,
2948                                    get_proxy_auth_ex_data_idx(), letters);
2949     }
2950     if (cb_arg->allow_proxy_certs) {
2951         X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
2952     }
2953     ok = X509_verify_cert(ctx);
2954
2955     if (cb_arg->proxy_auth) {
2956         if (ok > 0) {
2957             const char *cond_end = NULL;
2958
2959             ok = process_proxy_cond(letters, cb_arg->proxy_cond, &cond_end);
2960
2961             if (ok < 0)
2962                 EXIT(3);
2963             if (*cond_end) {
2964                 fprintf(stderr,
2965                         "Stopped processing condition before it's end.\n");
2966                 ok = 0;
2967             }
2968             if (!ok)
2969                 fprintf(stderr,
2970                         "Proxy rights check with condition '%s' invalid\n",
2971                         cb_arg->proxy_cond);
2972             else
2973                 printf("Proxy rights check with condition '%s' ok\n",
2974                         cb_arg->proxy_cond);
2975         }
2976     }
2977     return (ok);
2978 }
2979
2980 #ifndef OPENSSL_NO_DH
2981 /*-
2982  * These DH parameters have been generated as follows:
2983  *    $ openssl dhparam -C -noout 512
2984  *    $ openssl dhparam -C -noout 1024
2985  *    $ openssl dhparam -C -noout -dsaparam 1024
2986  * (The third function has been renamed to avoid name conflicts.)
2987  */
2988 static DH *get_dh512()
2989 {
2990     static unsigned char dh512_p[] = {
2991         0xCB, 0xC8, 0xE1, 0x86, 0xD0, 0x1F, 0x94, 0x17, 0xA6, 0x99, 0xF0,
2992         0xC6,
2993         0x1F, 0x0D, 0xAC, 0xB6, 0x25, 0x3E, 0x06, 0x39, 0xCA, 0x72, 0x04,
2994         0xB0,
2995         0x6E, 0xDA, 0xC0, 0x61, 0xE6, 0x7A, 0x77, 0x25, 0xE8, 0x3B, 0xB9,
2996         0x5F,
2997         0x9A, 0xB6, 0xB5, 0xFE, 0x99, 0x0B, 0xA1, 0x93, 0x4E, 0x35, 0x33,
2998         0xB8,
2999         0xE1, 0xF1, 0x13, 0x4F, 0x59, 0x1A, 0xD2, 0x57, 0xC0, 0x26, 0x21,
3000         0x33,
3001         0x02, 0xC5, 0xAE, 0x23,
3002     };
3003     static unsigned char dh512_g[] = {
3004         0x02,
3005     };
3006     DH *dh;
3007
3008     if ((dh = DH_new()) == NULL)
3009         return (NULL);
3010     dh->p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
3011     dh->g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
3012     if ((dh->p == NULL) || (dh->g == NULL)) {
3013         DH_free(dh);
3014         return (NULL);
3015     }
3016     return (dh);
3017 }
3018
3019 static DH *get_dh1024()
3020 {
3021     static unsigned char dh1024_p[] = {
3022         0xF8, 0x81, 0x89, 0x7D, 0x14, 0x24, 0xC5, 0xD1, 0xE6, 0xF7, 0xBF,
3023         0x3A,
3024         0xE4, 0x90, 0xF4, 0xFC, 0x73, 0xFB, 0x34, 0xB5, 0xFA, 0x4C, 0x56,
3025         0xA2,
3026         0xEA, 0xA7, 0xE9, 0xC0, 0xC0, 0xCE, 0x89, 0xE1, 0xFA, 0x63, 0x3F,
3027         0xB0,
3028         0x6B, 0x32, 0x66, 0xF1, 0xD1, 0x7B, 0xB0, 0x00, 0x8F, 0xCA, 0x87,
3029         0xC2,
3030         0xAE, 0x98, 0x89, 0x26, 0x17, 0xC2, 0x05, 0xD2, 0xEC, 0x08, 0xD0,
3031         0x8C,
3032         0xFF, 0x17, 0x52, 0x8C, 0xC5, 0x07, 0x93, 0x03, 0xB1, 0xF6, 0x2F,
3033         0xB8,
3034         0x1C, 0x52, 0x47, 0x27, 0x1B, 0xDB, 0xD1, 0x8D, 0x9D, 0x69, 0x1D,
3035         0x52,
3036         0x4B, 0x32, 0x81, 0xAA, 0x7F, 0x00, 0xC8, 0xDC, 0xE6, 0xD9, 0xCC,
3037         0xC1,
3038         0x11, 0x2D, 0x37, 0x34, 0x6C, 0xEA, 0x02, 0x97, 0x4B, 0x0E, 0xBB,
3039         0xB1,
3040         0x71, 0x33, 0x09, 0x15, 0xFD, 0xDD, 0x23, 0x87, 0x07, 0x5E, 0x89,
3041         0xAB,
3042         0x6B, 0x7C, 0x5F, 0xEC, 0xA6, 0x24, 0xDC, 0x53,
3043     };
3044     static unsigned char dh1024_g[] = {
3045         0x02,
3046     };
3047     DH *dh;
3048
3049     if ((dh = DH_new()) == NULL)
3050         return (NULL);
3051     dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
3052     dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
3053     if ((dh->p == NULL) || (dh->g == NULL)) {
3054         DH_free(dh);
3055         return (NULL);
3056     }
3057     return (dh);
3058 }
3059
3060 static DH *get_dh1024dsa()
3061 {
3062     static unsigned char dh1024_p[] = {
3063         0xC8, 0x00, 0xF7, 0x08, 0x07, 0x89, 0x4D, 0x90, 0x53, 0xF3, 0xD5,
3064         0x00,
3065         0x21, 0x1B, 0xF7, 0x31, 0xA6, 0xA2, 0xDA, 0x23, 0x9A, 0xC7, 0x87,
3066         0x19,
3067         0x3B, 0x47, 0xB6, 0x8C, 0x04, 0x6F, 0xFF, 0xC6, 0x9B, 0xB8, 0x65,
3068         0xD2,
3069         0xC2, 0x5F, 0x31, 0x83, 0x4A, 0xA7, 0x5F, 0x2F, 0x88, 0x38, 0xB6,
3070         0x55,
3071         0xCF, 0xD9, 0x87, 0x6D, 0x6F, 0x9F, 0xDA, 0xAC, 0xA6, 0x48, 0xAF,
3072         0xFC,
3073         0x33, 0x84, 0x37, 0x5B, 0x82, 0x4A, 0x31, 0x5D, 0xE7, 0xBD, 0x52,
3074         0x97,
3075         0xA1, 0x77, 0xBF, 0x10, 0x9E, 0x37, 0xEA, 0x64, 0xFA, 0xCA, 0x28,
3076         0x8D,
3077         0x9D, 0x3B, 0xD2, 0x6E, 0x09, 0x5C, 0x68, 0xC7, 0x45, 0x90, 0xFD,
3078         0xBB,
3079         0x70, 0xC9, 0x3A, 0xBB, 0xDF, 0xD4, 0x21, 0x0F, 0xC4, 0x6A, 0x3C,
3080         0xF6,
3081         0x61, 0xCF, 0x3F, 0xD6, 0x13, 0xF1, 0x5F, 0xBC, 0xCF, 0xBC, 0x26,
3082         0x9E,
3083         0xBC, 0x0B, 0xBD, 0xAB, 0x5D, 0xC9, 0x54, 0x39,
3084     };
3085     static unsigned char dh1024_g[] = {
3086         0x3B, 0x40, 0x86, 0xE7, 0xF3, 0x6C, 0xDE, 0x67, 0x1C, 0xCC, 0x80,
3087         0x05,
3088         0x5A, 0xDF, 0xFE, 0xBD, 0x20, 0x27, 0x74, 0x6C, 0x24, 0xC9, 0x03,
3089         0xF3,
3090         0xE1, 0x8D, 0xC3, 0x7D, 0x98, 0x27, 0x40, 0x08, 0xB8, 0x8C, 0x6A,
3091         0xE9,
3092         0xBB, 0x1A, 0x3A, 0xD6, 0x86, 0x83, 0x5E, 0x72, 0x41, 0xCE, 0x85,
3093         0x3C,
3094         0xD2, 0xB3, 0xFC, 0x13, 0xCE, 0x37, 0x81, 0x9E, 0x4C, 0x1C, 0x7B,
3095         0x65,
3096         0xD3, 0xE6, 0xA6, 0x00, 0xF5, 0x5A, 0x95, 0x43, 0x5E, 0x81, 0xCF,
3097         0x60,
3098         0xA2, 0x23, 0xFC, 0x36, 0xA7, 0x5D, 0x7A, 0x4C, 0x06, 0x91, 0x6E,
3099         0xF6,
3100         0x57, 0xEE, 0x36, 0xCB, 0x06, 0xEA, 0xF5, 0x3D, 0x95, 0x49, 0xCB,
3101         0xA7,
3102         0xDD, 0x81, 0xDF, 0x80, 0x09, 0x4A, 0x97, 0x4D, 0xA8, 0x22, 0x72,
3103         0xA1,
3104         0x7F, 0xC4, 0x70, 0x56, 0x70, 0xE8, 0x20, 0x10, 0x18, 0x8F, 0x2E,
3105         0x60,
3106         0x07, 0xE7, 0x68, 0x1A, 0x82, 0x5D, 0x32, 0xA2,
3107     };
3108     DH *dh;
3109
3110     if ((dh = DH_new()) == NULL)
3111         return (NULL);
3112     dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
3113     dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
3114     if ((dh->p == NULL) || (dh->g == NULL)) {
3115         DH_free(dh);
3116         return (NULL);
3117     }
3118     dh->length = 160;
3119     return (dh);
3120 }
3121 #endif
3122
3123 #ifndef OPENSSL_NO_PSK
3124 /* convert the PSK key (psk_key) in ascii to binary (psk) */
3125 static int psk_key2bn(const char *pskkey, unsigned char *psk,
3126                       unsigned int max_psk_len)
3127 {
3128     int ret;
3129     BIGNUM *bn = NULL;
3130
3131     ret = BN_hex2bn(&bn, pskkey);
3132     if (!ret) {
3133         BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
3134                    pskkey);
3135         BN_free(bn);
3136         return 0;
3137     }
3138     if (BN_num_bytes(bn) > (int)max_psk_len) {
3139         BIO_printf(bio_err,
3140                    "psk buffer of callback is too small (%d) for key (%d)\n",
3141                    max_psk_len, BN_num_bytes(bn));
3142         BN_free(bn);
3143         return 0;
3144     }
3145     ret = BN_bn2bin(bn, psk);
3146     BN_free(bn);
3147     return ret;
3148 }
3149
3150 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
3151                                         char *identity,
3152                                         unsigned int max_identity_len,
3153                                         unsigned char *psk,
3154                                         unsigned int max_psk_len)
3155 {
3156     int ret;
3157     unsigned int psk_len = 0;
3158
3159     ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3160     if (ret < 0)
3161         goto out_err;
3162     if (debug)
3163         fprintf(stderr, "client: created identity '%s' len=%d\n", identity,
3164                 ret);
3165     ret = psk_key2bn(psk_key, psk, max_psk_len);
3166     if (ret < 0)
3167         goto out_err;
3168     psk_len = ret;
3169  out_err:
3170     return psk_len;
3171 }
3172
3173 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3174                                         unsigned char *psk,
3175                                         unsigned int max_psk_len)
3176 {
3177     unsigned int psk_len = 0;
3178
3179     if (strcmp(identity, "Client_identity") != 0) {
3180         BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3181         return 0;
3182     }
3183     psk_len = psk_key2bn(psk_key, psk, max_psk_len);
3184     return psk_len;
3185 }
3186 #endif
3187
3188 static int do_test_cipherlist(void)
3189 {
3190 #if !defined(OPENSSL_NO_SSL3) || !defined(OPENSSL_NO_TLS1)
3191     int i = 0;
3192     const SSL_METHOD *meth;
3193     const SSL_CIPHER *ci, *tci = NULL;
3194 #endif
3195
3196 #ifndef OPENSSL_NO_SSL3
3197     meth = SSLv3_method();
3198     tci = NULL;
3199     while ((ci = meth->get_cipher(i++)) != NULL) {
3200         if (tci != NULL)
3201             if (ci->id >= tci->id) {
3202                 fprintf(stderr, "testing SSLv3 cipher list order: ");
3203                 fprintf(stderr, "failed %x vs. %x\n", ci->id, tci->id);
3204                 return 0;
3205             }
3206         tci = ci;
3207     }
3208 #endif
3209 #ifndef OPENSSL_NO_TLS1
3210     meth = TLSv1_method();
3211     tci = NULL;
3212     while ((ci = meth->get_cipher(i++)) != NULL) {
3213         if (tci != NULL)
3214             if (ci->id >= tci->id) {
3215                 fprintf(stderr, "testing TLSv1 cipher list order: ");
3216                 fprintf(stderr, "failed %x vs. %x\n", ci->id, tci->id);
3217                 return 0;
3218             }
3219         tci = ci;
3220     }
3221 #endif
3222
3223     return 1;
3224 }