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