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