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