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