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