test/ssltest.c

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