test/ssltest.c

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