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