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