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 OPENSSL_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     CONF_modules_unload(1);
1715     CRYPTO_cleanup_all_ex_data();
1716     ERR_free_strings();
1717     ERR_remove_thread_state(NULL);
1718     EVP_cleanup();
1719     CRYPTO_mem_leaks(bio_err);
1720     BIO_free(bio_err);
1721     EXIT(ret);
1722 }
1723
1724 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
1725                  clock_t *s_time, clock_t *c_time)
1726 {
1727     long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1728     BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1729     BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
1730     int ret = 1;
1731
1732     size_t bufsiz = 256;        /* small buffer for testing */
1733
1734     if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
1735         goto err;
1736     if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
1737         goto err;
1738
1739     s_ssl_bio = BIO_new(BIO_f_ssl());
1740     if (!s_ssl_bio)
1741         goto err;
1742
1743     c_ssl_bio = BIO_new(BIO_f_ssl());
1744     if (!c_ssl_bio)
1745         goto err;
1746
1747     SSL_set_connect_state(c_ssl);
1748     SSL_set_bio(c_ssl, client, client);
1749     (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1750
1751     SSL_set_accept_state(s_ssl);
1752     SSL_set_bio(s_ssl, server, server);
1753     (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1754
1755     do {
1756         /*-
1757          * c_ssl_bio:          SSL filter BIO
1758          *
1759          * client:             pseudo-I/O for SSL library
1760          *
1761          * client_io:          client's SSL communication; usually to be
1762          *                     relayed over some I/O facility, but in this
1763          *                     test program, we're the server, too:
1764          *
1765          * server_io:          server's SSL communication
1766          *
1767          * server:             pseudo-I/O for SSL library
1768          *
1769          * s_ssl_bio:          SSL filter BIO
1770          *
1771          * The client and the server each employ a "BIO pair":
1772          * client + client_io, server + server_io.
1773          * BIO pairs are symmetric.  A BIO pair behaves similar
1774          * to a non-blocking socketpair (but both endpoints must
1775          * be handled by the same thread).
1776          * [Here we could connect client and server to the ends
1777          * of a single BIO pair, but then this code would be less
1778          * suitable as an example for BIO pairs in general.]
1779          *
1780          * Useful functions for querying the state of BIO pair endpoints:
1781          *
1782          * BIO_ctrl_pending(bio)              number of bytes we can read now
1783          * BIO_ctrl_get_read_request(bio)     number of bytes needed to fulfil
1784          *                                      other side's read attempt
1785          * BIO_ctrl_get_write_guarantee(bio)   number of bytes we can write now
1786          *
1787          * ..._read_request is never more than ..._write_guarantee;
1788          * it depends on the application which one you should use.
1789          */
1790
1791         /*
1792          * We have non-blocking behaviour throughout this test program, but
1793          * can be sure that there is *some* progress in each iteration; so we
1794          * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
1795          * we just try everything in each iteration
1796          */
1797
1798         {
1799             /* CLIENT */
1800
1801             char cbuf[1024 * 8];
1802             int i, r;
1803             clock_t c_clock = clock();
1804
1805             memset(cbuf, 0, sizeof(cbuf));
1806
1807             if (debug)
1808                 if (SSL_in_init(c_ssl))
1809                     printf("client waiting in SSL_connect - %s\n",
1810                            SSL_state_string_long(c_ssl));
1811
1812             if (cw_num > 0) {
1813                 /* Write to server. */
1814
1815                 if (cw_num > (long)sizeof cbuf)
1816                     i = sizeof cbuf;
1817                 else
1818                     i = (int)cw_num;
1819                 r = BIO_write(c_ssl_bio, cbuf, i);
1820                 if (r < 0) {
1821                     if (!BIO_should_retry(c_ssl_bio)) {
1822                         fprintf(stderr, "ERROR in CLIENT\n");
1823                         goto err;
1824                     }
1825                     /*
1826                      * BIO_should_retry(...) can just be ignored here. The
1827                      * library expects us to call BIO_write with the same
1828                      * arguments again, and that's what we will do in the
1829                      * next iteration.
1830                      */
1831                 } else if (r == 0) {
1832                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1833                     goto err;
1834                 } else {
1835                     if (debug)
1836                         printf("client wrote %d\n", r);
1837                     cw_num -= r;
1838                 }
1839             }
1840
1841             if (cr_num > 0) {
1842                 /* Read from server. */
1843
1844                 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1845                 if (r < 0) {
1846                     if (!BIO_should_retry(c_ssl_bio)) {
1847                         fprintf(stderr, "ERROR in CLIENT\n");
1848                         goto err;
1849                     }
1850                     /*
1851                      * Again, "BIO_should_retry" can be ignored.
1852                      */
1853                 } else if (r == 0) {
1854                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1855                     goto err;
1856                 } else {
1857                     if (debug)
1858                         printf("client read %d\n", r);
1859                     cr_num -= r;
1860                 }
1861             }
1862
1863             /*
1864              * c_time and s_time increments will typically be very small
1865              * (depending on machine speed and clock tick intervals), but
1866              * sampling over a large number of connections should result in
1867              * fairly accurate figures.  We cannot guarantee a lot, however
1868              * -- if each connection lasts for exactly one clock tick, it
1869              * will be counted only for the client or only for the server or
1870              * even not at all.
1871              */
1872             *c_time += (clock() - c_clock);
1873         }
1874
1875         {
1876             /* SERVER */
1877
1878             char sbuf[1024 * 8];
1879             int i, r;
1880             clock_t s_clock = clock();
1881
1882             memset(sbuf, 0, sizeof(sbuf));
1883
1884             if (debug)
1885                 if (SSL_in_init(s_ssl))
1886                     printf("server waiting in SSL_accept - %s\n",
1887                            SSL_state_string_long(s_ssl));
1888
1889             if (sw_num > 0) {
1890                 /* Write to client. */
1891
1892                 if (sw_num > (long)sizeof sbuf)
1893                     i = sizeof sbuf;
1894                 else
1895                     i = (int)sw_num;
1896                 r = BIO_write(s_ssl_bio, sbuf, i);
1897                 if (r < 0) {
1898                     if (!BIO_should_retry(s_ssl_bio)) {
1899                         fprintf(stderr, "ERROR in SERVER\n");
1900                         goto err;
1901                     }
1902                     /* Ignore "BIO_should_retry". */
1903                 } else if (r == 0) {
1904                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
1905                     goto err;
1906                 } else {
1907                     if (debug)
1908                         printf("server wrote %d\n", r);
1909                     sw_num -= r;
1910                 }
1911             }
1912
1913             if (sr_num > 0) {
1914                 /* Read from client. */
1915
1916                 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
1917                 if (r < 0) {
1918                     if (!BIO_should_retry(s_ssl_bio)) {
1919                         fprintf(stderr, "ERROR in SERVER\n");
1920                         goto err;
1921                     }
1922                     /* blah, blah */
1923                 } else if (r == 0) {
1924                     fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
1925                     goto err;
1926                 } else {
1927                     if (debug)
1928                         printf("server read %d\n", r);
1929                     sr_num -= r;
1930                 }
1931             }
1932
1933             *s_time += (clock() - s_clock);
1934         }
1935
1936         {
1937             /* "I/O" BETWEEN CLIENT AND SERVER. */
1938
1939             size_t r1, r2;
1940             BIO *io1 = server_io, *io2 = client_io;
1941             /*
1942              * we use the non-copying interface for io1 and the standard
1943              * BIO_write/BIO_read interface for io2
1944              */
1945
1946             static int prev_progress = 1;
1947             int progress = 0;
1948
1949             /* io1 to io2 */
1950             do {
1951                 size_t num;
1952                 int r;
1953
1954                 r1 = BIO_ctrl_pending(io1);
1955                 r2 = BIO_ctrl_get_write_guarantee(io2);
1956
1957                 num = r1;
1958                 if (r2 < num)
1959                     num = r2;
1960                 if (num) {
1961                     char *dataptr;
1962
1963                     if (INT_MAX < num) /* yeah, right */
1964                         num = INT_MAX;
1965
1966                     r = BIO_nread(io1, &dataptr, (int)num);
1967                     assert(r > 0);
1968                     assert(r <= (int)num);
1969                     /*
1970                      * possibly r < num (non-contiguous data)
1971                      */
1972                     num = r;
1973                     r = BIO_write(io2, dataptr, (int)num);
1974                     if (r != (int)num) { /* can't happen */
1975                         fprintf(stderr, "ERROR: BIO_write could not write "
1976                                 "BIO_ctrl_get_write_guarantee() bytes");
1977                         goto err;
1978                     }
1979                     progress = 1;
1980
1981                     if (debug)
1982                         printf((io1 == client_io) ?
1983                                "C->S relaying: %d bytes\n" :
1984                                "S->C relaying: %d bytes\n", (int)num);
1985                 }
1986             }
1987             while (r1 && r2);
1988
1989             /* io2 to io1 */
1990             {
1991                 size_t num;
1992                 int r;
1993
1994                 r1 = BIO_ctrl_pending(io2);
1995                 r2 = BIO_ctrl_get_read_request(io1);
1996                 /*
1997                  * here we could use ..._get_write_guarantee instead of
1998                  * ..._get_read_request, but by using the latter we test
1999                  * restartability of the SSL implementation more thoroughly
2000                  */
2001                 num = r1;
2002                 if (r2 < num)
2003                     num = r2;
2004                 if (num) {
2005                     char *dataptr;
2006
2007                     if (INT_MAX < num)
2008                         num = INT_MAX;
2009
2010                     if (num > 1)
2011                         --num;  /* test restartability even more thoroughly */
2012
2013                     r = BIO_nwrite0(io1, &dataptr);
2014                     assert(r > 0);
2015                     if (r < (int)num)
2016                         num = r;
2017                     r = BIO_read(io2, dataptr, (int)num);
2018                     if (r != (int)num) { /* can't happen */
2019                         fprintf(stderr, "ERROR: BIO_read could not read "
2020                                 "BIO_ctrl_pending() bytes");
2021                         goto err;
2022                     }
2023                     progress = 1;
2024                     r = BIO_nwrite(io1, &dataptr, (int)num);
2025                     if (r != (int)num) { /* can't happen */
2026                         fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
2027                                 "BIO_nwrite0() bytes");
2028                         goto err;
2029                     }
2030
2031                     if (debug)
2032                         printf((io2 == client_io) ?
2033                                "C->S relaying: %d bytes\n" :
2034                                "S->C relaying: %d bytes\n", (int)num);
2035                 }
2036             }                   /* no loop, BIO_ctrl_get_read_request now
2037                                  * returns 0 anyway */
2038
2039             if (!progress && !prev_progress)
2040                 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0) {
2041                     fprintf(stderr, "ERROR: got stuck\n");
2042                     fprintf(stderr, " ERROR.\n");
2043                     goto err;
2044                 }
2045             prev_progress = progress;
2046         }
2047     }
2048     while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2049
2050     if (verbose)
2051         print_details(c_ssl, "DONE via BIO pair: ");
2052 #ifndef OPENSSL_NO_NEXTPROTONEG
2053     if (verify_npn(c_ssl, s_ssl) < 0) {
2054         ret = 1;
2055         goto end;
2056     }
2057 #endif
2058     if (verify_serverinfo() < 0) {
2059         fprintf(stderr, "Server info verify error\n");
2060         ret = 1;
2061         goto err;
2062     }
2063     if (verify_alpn(c_ssl, s_ssl) < 0) {
2064         ret = 1;
2065         goto err;
2066     }
2067
2068     if (custom_ext_error) {
2069         fprintf(stderr, "Custom extension error\n");
2070         ret = 1;
2071         goto err;
2072     }
2073
2074  end:
2075     ret = 0;
2076
2077  err:
2078     ERR_print_errors(bio_err);
2079
2080     BIO_free(server);
2081     BIO_free(server_io);
2082     BIO_free(client);
2083     BIO_free(client_io);
2084     BIO_free(s_ssl_bio);
2085     BIO_free(c_ssl_bio);
2086
2087     return ret;
2088 }
2089
2090 #define W_READ  1
2091 #define W_WRITE 2
2092 #define C_DONE  1
2093 #define S_DONE  2
2094
2095 int doit(SSL *s_ssl, SSL *c_ssl, long count)
2096 {
2097     char *cbuf = NULL, *sbuf = NULL;
2098     long bufsiz;
2099     long cw_num = count, cr_num = count;
2100     long sw_num = count, sr_num = count;
2101     int ret = 1;
2102     BIO *c_to_s = NULL;
2103     BIO *s_to_c = NULL;
2104     BIO *c_bio = NULL;
2105     BIO *s_bio = NULL;
2106     int c_r, c_w, s_r, s_w;
2107     int i, j;
2108     int done = 0;
2109     int c_write, s_write;
2110     int do_server = 0, do_client = 0;
2111     int max_frag = 5 * 1024;
2112
2113     bufsiz = count > 40 * 1024 ? 40 * 1024 : count;
2114
2115     if ((cbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2116         goto err;
2117     if ((sbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2118         goto err;
2119
2120     c_to_s = BIO_new(BIO_s_mem());
2121     s_to_c = BIO_new(BIO_s_mem());
2122     if ((s_to_c == NULL) || (c_to_s == NULL)) {
2123         ERR_print_errors(bio_err);
2124         goto err;
2125     }
2126
2127     c_bio = BIO_new(BIO_f_ssl());
2128     s_bio = BIO_new(BIO_f_ssl());
2129     if ((c_bio == NULL) || (s_bio == NULL)) {
2130         ERR_print_errors(bio_err);
2131         goto err;
2132     }
2133
2134     SSL_set_connect_state(c_ssl);
2135     SSL_set_bio(c_ssl, s_to_c, c_to_s);
2136     SSL_set_max_send_fragment(c_ssl, max_frag);
2137     BIO_set_ssl(c_bio, c_ssl, BIO_NOCLOSE);
2138
2139     SSL_set_accept_state(s_ssl);
2140     SSL_set_bio(s_ssl, c_to_s, s_to_c);
2141     SSL_set_max_send_fragment(s_ssl, max_frag);
2142     BIO_set_ssl(s_bio, s_ssl, BIO_NOCLOSE);
2143
2144     c_r = 0;
2145     s_r = 1;
2146     c_w = 1;
2147     s_w = 0;
2148     c_write = 1, s_write = 0;
2149
2150     /* We can always do writes */
2151     for (;;) {
2152         do_server = 0;
2153         do_client = 0;
2154
2155         i = (int)BIO_pending(s_bio);
2156         if ((i && s_r) || s_w)
2157             do_server = 1;
2158
2159         i = (int)BIO_pending(c_bio);
2160         if ((i && c_r) || c_w)
2161             do_client = 1;
2162
2163         if (do_server && debug) {
2164             if (SSL_in_init(s_ssl))
2165                 printf("server waiting in SSL_accept - %s\n",
2166                        SSL_state_string_long(s_ssl));
2167 /*-
2168             else if (s_write)
2169                 printf("server:SSL_write()\n");
2170             else
2171                 printf("server:SSL_read()\n"); */
2172         }
2173
2174         if (do_client && debug) {
2175             if (SSL_in_init(c_ssl))
2176                 printf("client waiting in SSL_connect - %s\n",
2177                        SSL_state_string_long(c_ssl));
2178 /*-
2179             else if (c_write)
2180                 printf("client:SSL_write()\n");
2181             else
2182                 printf("client:SSL_read()\n"); */
2183         }
2184
2185         if (!do_client && !do_server) {
2186             fprintf(stdout, "ERROR IN STARTUP\n");
2187             ERR_print_errors(bio_err);
2188             goto err;
2189         }
2190         if (do_client && !(done & C_DONE)) {
2191             if (c_write) {
2192                 j = (cw_num > bufsiz) ? (int)bufsiz : (int)cw_num;
2193                 i = BIO_write(c_bio, cbuf, j);
2194                 if (i < 0) {
2195                     c_r = 0;
2196                     c_w = 0;
2197                     if (BIO_should_retry(c_bio)) {
2198                         if (BIO_should_read(c_bio))
2199                             c_r = 1;
2200                         if (BIO_should_write(c_bio))
2201                             c_w = 1;
2202                     } else {
2203                         fprintf(stderr, "ERROR in CLIENT\n");
2204                         ERR_print_errors(bio_err);
2205                         goto err;
2206                     }
2207                 } else if (i == 0) {
2208                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2209                     goto err;
2210                 } else {
2211                     if (debug)
2212                         printf("client wrote %d\n", i);
2213                     /* ok */
2214                     s_r = 1;
2215                     c_write = 0;
2216                     cw_num -= i;
2217                     if (max_frag > 1029)
2218                         SSL_set_max_send_fragment(c_ssl, max_frag -= 5);
2219                 }
2220             } else {
2221                 i = BIO_read(c_bio, cbuf, bufsiz);
2222                 if (i < 0) {
2223                     c_r = 0;
2224                     c_w = 0;
2225                     if (BIO_should_retry(c_bio)) {
2226                         if (BIO_should_read(c_bio))
2227                             c_r = 1;
2228                         if (BIO_should_write(c_bio))
2229                             c_w = 1;
2230                     } else {
2231                         fprintf(stderr, "ERROR in CLIENT\n");
2232                         ERR_print_errors(bio_err);
2233                         goto err;
2234                     }
2235                 } else if (i == 0) {
2236                     fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2237                     goto err;
2238                 } else {
2239                     if (debug)
2240                         printf("client read %d\n", i);
2241                     cr_num -= i;
2242                     if (sw_num > 0) {
2243                         s_write = 1;
2244                         s_w = 1;
2245                     }
2246                     if (cr_num <= 0) {
2247                         s_write = 1;
2248                         s_w = 1;
2249                         done = S_DONE | C_DONE;
2250                     }
2251                 }
2252             }
2253         }
2254
2255         if (do_server && !(done & S_DONE)) {
2256             if (!s_write) {
2257                 i = BIO_read(s_bio, sbuf, bufsiz);
2258                 if (i < 0) {
2259                     s_r = 0;
2260                     s_w = 0;
2261                     if (BIO_should_retry(s_bio)) {
2262                         if (BIO_should_read(s_bio))
2263                             s_r = 1;
2264                         if (BIO_should_write(s_bio))
2265                             s_w = 1;
2266                     } else {
2267                         fprintf(stderr, "ERROR in SERVER\n");
2268                         ERR_print_errors(bio_err);
2269                         goto err;
2270                     }
2271                 } else if (i == 0) {
2272                     ERR_print_errors(bio_err);
2273                     fprintf(stderr,
2274                             "SSL SERVER STARTUP FAILED in SSL_read\n");
2275                     goto err;
2276                 } else {
2277                     if (debug)
2278                         printf("server read %d\n", i);
2279                     sr_num -= i;
2280                     if (cw_num > 0) {
2281                         c_write = 1;
2282                         c_w = 1;
2283                     }
2284                     if (sr_num <= 0) {
2285                         s_write = 1;
2286                         s_w = 1;
2287                         c_write = 0;
2288                     }
2289                 }
2290             } else {
2291                 j = (sw_num > bufsiz) ? (int)bufsiz : (int)sw_num;
2292                 i = BIO_write(s_bio, sbuf, j);
2293                 if (i < 0) {
2294                     s_r = 0;
2295                     s_w = 0;
2296                     if (BIO_should_retry(s_bio)) {
2297                         if (BIO_should_read(s_bio))
2298                             s_r = 1;
2299                         if (BIO_should_write(s_bio))
2300                             s_w = 1;
2301                     } else {
2302                         fprintf(stderr, "ERROR in SERVER\n");
2303                         ERR_print_errors(bio_err);
2304                         goto err;
2305                     }
2306                 } else if (i == 0) {
2307                     ERR_print_errors(bio_err);
2308                     fprintf(stderr,
2309                             "SSL SERVER STARTUP FAILED in SSL_write\n");
2310                     goto err;
2311                 } else {
2312                     if (debug)
2313                         printf("server wrote %d\n", i);
2314                     sw_num -= i;
2315                     s_write = 0;
2316                     c_r = 1;
2317                     if (sw_num <= 0)
2318                         done |= S_DONE;
2319                     if (max_frag > 1029)
2320                         SSL_set_max_send_fragment(s_ssl, max_frag -= 5);
2321                 }
2322             }
2323         }
2324
2325         if ((done & S_DONE) && (done & C_DONE))
2326             break;
2327     }
2328
2329     if (verbose)
2330         print_details(c_ssl, "DONE: ");
2331 #ifndef OPENSSL_NO_NEXTPROTONEG
2332     if (verify_npn(c_ssl, s_ssl) < 0) {
2333         ret = 1;
2334         goto err;
2335     }
2336 #endif
2337     if (verify_serverinfo() < 0) {
2338         fprintf(stderr, "Server info verify error\n");
2339         ret = 1;
2340         goto err;
2341     }
2342     if (custom_ext_error) {
2343         fprintf(stderr, "Custom extension error\n");
2344         ret = 1;
2345         goto err;
2346     }
2347     ret = 0;
2348  err:
2349     /*
2350      * We have to set the BIO's to NULL otherwise they will be
2351      * OPENSSL_free()ed twice.  Once when th s_ssl is SSL_free()ed and again
2352      * when c_ssl is SSL_free()ed. This is a hack required because s_ssl and
2353      * c_ssl are sharing the same BIO structure and SSL_set_bio() and
2354      * SSL_free() automatically BIO_free non NULL entries. You should not
2355      * normally do this or be required to do this
2356      */
2357     if (s_ssl != NULL) {
2358         s_ssl->rbio = NULL;
2359         s_ssl->wbio = NULL;
2360     }
2361     if (c_ssl != NULL) {
2362         c_ssl->rbio = NULL;
2363         c_ssl->wbio = NULL;
2364     }
2365
2366     BIO_free(c_to_s);
2367     BIO_free(s_to_c);
2368     BIO_free_all(c_bio);
2369     BIO_free_all(s_bio);
2370     OPENSSL_free(cbuf);
2371     OPENSSL_free(sbuf);
2372
2373     return (ret);
2374 }
2375
2376 static int get_proxy_auth_ex_data_idx(void)
2377 {
2378     static volatile int idx = -1;
2379     if (idx < 0) {
2380         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
2381         if (idx < 0) {
2382             idx = X509_STORE_CTX_get_ex_new_index(0,
2383                                                   "SSLtest for verify callback",
2384                                                   NULL, NULL, NULL);
2385         }
2386         CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
2387     }
2388     return idx;
2389 }
2390
2391 static int verify_callback(int ok, X509_STORE_CTX *ctx)
2392 {
2393     char *s, buf[256];
2394
2395     s = X509_NAME_oneline(X509_get_subject_name(ctx->current_cert), buf,
2396                           sizeof buf);
2397     if (s != NULL) {
2398         if (ok)
2399             printf("depth=%d %s\n", ctx->error_depth, buf);
2400         else {
2401             fprintf(stderr, "depth=%d error=%d %s\n",
2402                     ctx->error_depth, ctx->error, buf);
2403         }
2404     }
2405
2406     if (ok == 0) {
2407         switch (ctx->error) {
2408         default:
2409             fprintf(stderr, "Error string: %s\n",
2410                     X509_verify_cert_error_string(ctx->error));
2411             break;
2412         case X509_V_ERR_CERT_NOT_YET_VALID:
2413         case X509_V_ERR_CERT_HAS_EXPIRED:
2414         case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2415             ok = 1;
2416         }
2417     }
2418
2419     if (ok == 1) {
2420         X509 *xs = ctx->current_cert;
2421         if (X509_get_extension_flags(xs) & EXFLAG_PROXY) {
2422             unsigned int *letters = X509_STORE_CTX_get_ex_data(ctx,
2423                                                                get_proxy_auth_ex_data_idx
2424                                                                ());
2425
2426             if (letters) {
2427                 int found_any = 0;
2428                 int i;
2429                 PROXY_CERT_INFO_EXTENSION *pci =
2430                     X509_get_ext_d2i(xs, NID_proxyCertInfo,
2431                                      NULL, NULL);
2432
2433                 switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage)) {
2434                 case NID_Independent:
2435                     /*
2436                      * Completely meaningless in this program, as there's no
2437                      * way to grant explicit rights to a specific PrC.
2438                      * Basically, using id-ppl-Independent is the perfect way
2439                      * to grant no rights at all.
2440                      */
2441                     fprintf(stderr, "  Independent proxy certificate");
2442                     for (i = 0; i < 26; i++)
2443                         letters[i] = 0;
2444                     break;
2445                 case NID_id_ppl_inheritAll:
2446                     /*
2447                      * This is basically a NOP, we simply let the current
2448                      * rights stand as they are.
2449                      */
2450                     fprintf(stderr, "  Proxy certificate inherits all");
2451                     break;
2452                 default:
2453                     s = (char *)
2454                         pci->proxyPolicy->policy->data;
2455                     i = pci->proxyPolicy->policy->length;
2456
2457                     /*
2458                      * The algorithm works as follows: it is assumed that
2459                      * previous iterations or the initial granted rights has
2460                      * already set some elements of `letters'.  What we need
2461                      * to do is to clear those that weren't granted by the
2462                      * current PrC as well.  The easiest way to do this is to
2463                      * add 1 to all the elements whose letters are given with
2464                      * the current policy. That way, all elements that are
2465                      * set by the current policy and were already set by
2466                      * earlier policies and through the original grant of
2467                      * rights will get the value 2 or higher. The last thing
2468                      * to do is to sweep through `letters' and keep the
2469                      * elements having the value 2 as set, and clear all the
2470                      * others.
2471                      */
2472
2473                     printf("  Certificate proxy rights = %*.*s", i,
2474                             i, s);
2475                     while (i-- > 0) {
2476                         int c = *s++;
2477                         if (isascii(c) && isalpha(c)) {
2478                             if (islower(c))
2479                                 c = toupper(c);
2480                             letters[c - 'A']++;
2481                         }
2482                     }
2483                     for (i = 0; i < 26; i++)
2484                         if (letters[i] < 2)
2485                             letters[i] = 0;
2486                         else
2487                             letters[i] = 1;
2488                 }
2489
2490                 found_any = 0;
2491                 printf(", resulting proxy rights = ");
2492                 for (i = 0; i < 26; i++)
2493                     if (letters[i]) {
2494                         printf("%c", i + 'A');
2495                         found_any = 1;
2496                     }
2497                 if (!found_any)
2498                     printf("none");
2499                 printf("\n");
2500
2501                 PROXY_CERT_INFO_EXTENSION_free(pci);
2502             }
2503         }
2504     }
2505
2506     return (ok);
2507 }
2508
2509 static void process_proxy_debug(int indent, const char *format, ...)
2510 {
2511     /* That's 80 > */
2512     static const char indentation[] =
2513         ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
2514         ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
2515     char my_format[256];
2516     va_list args;
2517
2518     BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
2519                  indent, indent, indentation, format);
2520
2521     va_start(args, format);
2522     vfprintf(stderr, my_format, args);
2523     va_end(args);
2524 }
2525
2526 /*-
2527  * Priority levels:
2528  *  0   [!]var, ()
2529  *  1   & ^
2530  *  2   |
2531  */
2532 static int process_proxy_cond_adders(unsigned int letters[26],
2533                                      const char *cond, const char **cond_end,
2534                                      int *pos, int indent);
2535 static int process_proxy_cond_val(unsigned int letters[26], const char *cond,
2536                                   const char **cond_end, int *pos, int indent)
2537 {
2538     int c;
2539     int ok = 1;
2540     int negate = 0;
2541
2542     while (isspace((int)*cond)) {
2543         cond++;
2544         (*pos)++;
2545     }
2546     c = *cond;
2547
2548     if (debug)
2549         process_proxy_debug(indent,
2550                             "Start process_proxy_cond_val at position %d: %s\n",
2551                             *pos, cond);
2552
2553     while (c == '!') {
2554         negate = !negate;
2555         cond++;
2556         (*pos)++;
2557         while (isspace((int)*cond)) {
2558             cond++;
2559             (*pos)++;
2560         }
2561         c = *cond;
2562     }
2563
2564     if (c == '(') {
2565         cond++;
2566         (*pos)++;
2567         ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
2568                                        indent + 1);
2569         cond = *cond_end;
2570         if (ok < 0)
2571             goto end;
2572         while (isspace((int)*cond)) {
2573             cond++;
2574             (*pos)++;
2575         }
2576         c = *cond;
2577         if (c != ')') {
2578             fprintf(stderr,
2579                     "Weird condition character in position %d: "
2580                     "%c\n", *pos, c);
2581             ok = -1;
2582             goto end;
2583         }
2584         cond++;
2585         (*pos)++;
2586     } else if (isascii(c) && isalpha(c)) {
2587         if (islower(c))
2588             c = toupper(c);
2589         ok = letters[c - 'A'];
2590         cond++;
2591         (*pos)++;
2592     } else {
2593         fprintf(stderr,
2594                 "Weird condition character in position %d: " "%c\n", *pos, c);
2595         ok = -1;
2596         goto end;
2597     }
2598  end:
2599     *cond_end = cond;
2600     if (ok >= 0 && negate)
2601         ok = !ok;
2602
2603     if (debug)
2604         process_proxy_debug(indent,
2605                             "End process_proxy_cond_val at position %d: %s, returning %d\n",
2606                             *pos, cond, ok);
2607
2608     return ok;
2609 }
2610
2611 static int process_proxy_cond_multipliers(unsigned int letters[26],
2612                                           const char *cond,
2613                                           const char **cond_end, int *pos,
2614                                           int indent)
2615 {
2616     int ok;
2617     char c;
2618
2619     if (debug)
2620         process_proxy_debug(indent,
2621                             "Start process_proxy_cond_multipliers at position %d: %s\n",
2622                             *pos, cond);
2623
2624     ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
2625     cond = *cond_end;
2626     if (ok < 0)
2627         goto end;
2628
2629     while (ok >= 0) {
2630         while (isspace((int)*cond)) {
2631             cond++;
2632             (*pos)++;
2633         }
2634         c = *cond;
2635
2636         switch (c) {
2637         case '&':
2638         case '^':
2639             {
2640                 int save_ok = ok;
2641
2642                 cond++;
2643                 (*pos)++;
2644                 ok = process_proxy_cond_val(letters,
2645                                             cond, cond_end, pos, indent + 1);
2646                 cond = *cond_end;
2647                 if (ok < 0)
2648                     break;
2649
2650                 switch (c) {
2651                 case '&':
2652                     ok &= save_ok;
2653                     break;
2654                 case '^':
2655                     ok ^= save_ok;
2656                     break;
2657                 default:
2658                     fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2659                             " STOPPING\n");
2660                     EXIT(1);
2661                 }
2662             }
2663             break;
2664         default:
2665             goto end;
2666         }
2667     }
2668  end:
2669     if (debug)
2670         process_proxy_debug(indent,
2671                             "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
2672                             *pos, cond, ok);
2673
2674     *cond_end = cond;
2675     return ok;
2676 }
2677
2678 static int process_proxy_cond_adders(unsigned int letters[26],
2679                                      const char *cond, const char **cond_end,
2680                                      int *pos, int indent)
2681 {
2682     int ok;
2683     char c;
2684
2685     if (debug)
2686         process_proxy_debug(indent,
2687                             "Start process_proxy_cond_adders at position %d: %s\n",
2688                             *pos, cond);
2689
2690     ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
2691                                         indent + 1);
2692     cond = *cond_end;
2693     if (ok < 0)
2694         goto end;
2695
2696     while (ok >= 0) {
2697         while (isspace((int)*cond)) {
2698             cond++;
2699             (*pos)++;
2700         }
2701         c = *cond;
2702
2703         switch (c) {
2704         case '|':
2705             {
2706                 int save_ok = ok;
2707
2708                 cond++;
2709                 (*pos)++;
2710                 ok = process_proxy_cond_multipliers(letters,
2711                                                     cond, cond_end, pos,
2712                                                     indent + 1);
2713                 cond = *cond_end;
2714                 if (ok < 0)
2715                     break;
2716
2717                 switch (c) {
2718                 case '|':
2719                     ok |= save_ok;
2720                     break;
2721                 default:
2722                     fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2723                             " STOPPING\n");
2724                     EXIT(1);
2725                 }
2726             }
2727             break;
2728         default:
2729             goto end;
2730         }
2731     }
2732  end:
2733     if (debug)
2734         process_proxy_debug(indent,
2735                             "End process_proxy_cond_adders at position %d: %s, returning %d\n",
2736                             *pos, cond, ok);
2737
2738     *cond_end = cond;
2739     return ok;
2740 }
2741
2742 static int process_proxy_cond(unsigned int letters[26],
2743                               const char *cond, const char **cond_end)
2744 {
2745     int pos = 1;
2746     return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
2747 }
2748
2749 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2750 {
2751     int ok = 1;
2752     struct app_verify_arg *cb_arg = arg;
2753     unsigned int letters[26];   /* only used with proxy_auth */
2754
2755     if (cb_arg->app_verify) {
2756         char *s = NULL, buf[256];
2757
2758         printf("In app_verify_callback, allowing cert. ");
2759         printf("Arg is: %s\n", cb_arg->string);
2760         printf("Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2761                 (void *)ctx, (void *)ctx->cert);
2762         if (ctx->cert)
2763             s = X509_NAME_oneline(X509_get_subject_name(ctx->cert), buf, 256);
2764         if (s != NULL) {
2765             printf("cert depth=%d %s\n", ctx->error_depth, buf);
2766         }
2767         return (1);
2768     }
2769     if (cb_arg->proxy_auth) {
2770         int found_any = 0, i;
2771         char *sp;
2772
2773         for (i = 0; i < 26; i++)
2774             letters[i] = 0;
2775         for (sp = cb_arg->proxy_auth; *sp; sp++) {
2776             int c = *sp;
2777             if (isascii(c) && isalpha(c)) {
2778                 if (islower(c))
2779                     c = toupper(c);
2780                 letters[c - 'A'] = 1;
2781             }
2782         }
2783
2784         printf("  Initial proxy rights = ");
2785         for (i = 0; i < 26; i++)
2786             if (letters[i]) {
2787                 printf("%c", i + 'A');
2788                 found_any = 1;
2789             }
2790         if (!found_any)
2791             printf("none");
2792         printf("\n");
2793
2794         X509_STORE_CTX_set_ex_data(ctx,
2795                                    get_proxy_auth_ex_data_idx(), letters);
2796     }
2797     if (cb_arg->allow_proxy_certs) {
2798         X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
2799     }
2800     ok = X509_verify_cert(ctx);
2801
2802     if (cb_arg->proxy_auth) {
2803         if (ok > 0) {
2804             const char *cond_end = NULL;
2805
2806             ok = process_proxy_cond(letters, cb_arg->proxy_cond, &cond_end);
2807
2808             if (ok < 0)
2809                 EXIT(3);
2810             if (*cond_end) {
2811                 fprintf(stderr,
2812                         "Stopped processing condition before it's end.\n");
2813                 ok = 0;
2814             }
2815             if (!ok)
2816                 fprintf(stderr,
2817                         "Proxy rights check with condition '%s' invalid\n",
2818                         cb_arg->proxy_cond);
2819             else
2820                 printf("Proxy rights check with condition '%s' ok\n",
2821                         cb_arg->proxy_cond);
2822         }
2823     }
2824     return (ok);
2825 }
2826
2827 #ifndef OPENSSL_NO_DH
2828 /*-
2829  * These DH parameters have been generated as follows:
2830  *    $ openssl dhparam -C -noout 512
2831  *    $ openssl dhparam -C -noout 1024
2832  *    $ openssl dhparam -C -noout -dsaparam 1024
2833  * (The third function has been renamed to avoid name conflicts.)
2834  */
2835 static DH *get_dh512()
2836 {
2837     static unsigned char dh512_p[] = {
2838         0xCB, 0xC8, 0xE1, 0x86, 0xD0, 0x1F, 0x94, 0x17, 0xA6, 0x99, 0xF0,
2839         0xC6,
2840         0x1F, 0x0D, 0xAC, 0xB6, 0x25, 0x3E, 0x06, 0x39, 0xCA, 0x72, 0x04,
2841         0xB0,
2842         0x6E, 0xDA, 0xC0, 0x61, 0xE6, 0x7A, 0x77, 0x25, 0xE8, 0x3B, 0xB9,
2843         0x5F,
2844         0x9A, 0xB6, 0xB5, 0xFE, 0x99, 0x0B, 0xA1, 0x93, 0x4E, 0x35, 0x33,
2845         0xB8,
2846         0xE1, 0xF1, 0x13, 0x4F, 0x59, 0x1A, 0xD2, 0x57, 0xC0, 0x26, 0x21,
2847         0x33,
2848         0x02, 0xC5, 0xAE, 0x23,
2849     };
2850     static unsigned char dh512_g[] = {
2851         0x02,
2852     };
2853     DH *dh;
2854
2855     if ((dh = DH_new()) == NULL)
2856         return (NULL);
2857     dh->p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
2858     dh->g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
2859     if ((dh->p == NULL) || (dh->g == NULL)) {
2860         DH_free(dh);
2861         return (NULL);
2862     }
2863     return (dh);
2864 }
2865
2866 static DH *get_dh1024()
2867 {
2868     static unsigned char dh1024_p[] = {
2869         0xF8, 0x81, 0x89, 0x7D, 0x14, 0x24, 0xC5, 0xD1, 0xE6, 0xF7, 0xBF,
2870         0x3A,
2871         0xE4, 0x90, 0xF4, 0xFC, 0x73, 0xFB, 0x34, 0xB5, 0xFA, 0x4C, 0x56,
2872         0xA2,
2873         0xEA, 0xA7, 0xE9, 0xC0, 0xC0, 0xCE, 0x89, 0xE1, 0xFA, 0x63, 0x3F,
2874         0xB0,
2875         0x6B, 0x32, 0x66, 0xF1, 0xD1, 0x7B, 0xB0, 0x00, 0x8F, 0xCA, 0x87,
2876         0xC2,
2877         0xAE, 0x98, 0x89, 0x26, 0x17, 0xC2, 0x05, 0xD2, 0xEC, 0x08, 0xD0,
2878         0x8C,
2879         0xFF, 0x17, 0x52, 0x8C, 0xC5, 0x07, 0x93, 0x03, 0xB1, 0xF6, 0x2F,
2880         0xB8,
2881         0x1C, 0x52, 0x47, 0x27, 0x1B, 0xDB, 0xD1, 0x8D, 0x9D, 0x69, 0x1D,
2882         0x52,
2883         0x4B, 0x32, 0x81, 0xAA, 0x7F, 0x00, 0xC8, 0xDC, 0xE6, 0xD9, 0xCC,
2884         0xC1,
2885         0x11, 0x2D, 0x37, 0x34, 0x6C, 0xEA, 0x02, 0x97, 0x4B, 0x0E, 0xBB,
2886         0xB1,
2887         0x71, 0x33, 0x09, 0x15, 0xFD, 0xDD, 0x23, 0x87, 0x07, 0x5E, 0x89,
2888         0xAB,
2889         0x6B, 0x7C, 0x5F, 0xEC, 0xA6, 0x24, 0xDC, 0x53,
2890     };
2891     static unsigned char dh1024_g[] = {
2892         0x02,
2893     };
2894     DH *dh;
2895
2896     if ((dh = DH_new()) == NULL)
2897         return (NULL);
2898     dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
2899     dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
2900     if ((dh->p == NULL) || (dh->g == NULL)) {
2901         DH_free(dh);
2902         return (NULL);
2903     }
2904     return (dh);
2905 }
2906
2907 static DH *get_dh1024dsa()
2908 {
2909     static unsigned char dh1024_p[] = {
2910         0xC8, 0x00, 0xF7, 0x08, 0x07, 0x89, 0x4D, 0x90, 0x53, 0xF3, 0xD5,
2911         0x00,
2912         0x21, 0x1B, 0xF7, 0x31, 0xA6, 0xA2, 0xDA, 0x23, 0x9A, 0xC7, 0x87,
2913         0x19,
2914         0x3B, 0x47, 0xB6, 0x8C, 0x04, 0x6F, 0xFF, 0xC6, 0x9B, 0xB8, 0x65,
2915         0xD2,
2916         0xC2, 0x5F, 0x31, 0x83, 0x4A, 0xA7, 0x5F, 0x2F, 0x88, 0x38, 0xB6,
2917         0x55,
2918         0xCF, 0xD9, 0x87, 0x6D, 0x6F, 0x9F, 0xDA, 0xAC, 0xA6, 0x48, 0xAF,
2919         0xFC,
2920         0x33, 0x84, 0x37, 0x5B, 0x82, 0x4A, 0x31, 0x5D, 0xE7, 0xBD, 0x52,
2921         0x97,
2922         0xA1, 0x77, 0xBF, 0x10, 0x9E, 0x37, 0xEA, 0x64, 0xFA, 0xCA, 0x28,
2923         0x8D,
2924         0x9D, 0x3B, 0xD2, 0x6E, 0x09, 0x5C, 0x68, 0xC7, 0x45, 0x90, 0xFD,
2925         0xBB,
2926         0x70, 0xC9, 0x3A, 0xBB, 0xDF, 0xD4, 0x21, 0x0F, 0xC4, 0x6A, 0x3C,
2927         0xF6,
2928         0x61, 0xCF, 0x3F, 0xD6, 0x13, 0xF1, 0x5F, 0xBC, 0xCF, 0xBC, 0x26,
2929         0x9E,
2930         0xBC, 0x0B, 0xBD, 0xAB, 0x5D, 0xC9, 0x54, 0x39,
2931     };
2932     static unsigned char dh1024_g[] = {
2933         0x3B, 0x40, 0x86, 0xE7, 0xF3, 0x6C, 0xDE, 0x67, 0x1C, 0xCC, 0x80,
2934         0x05,
2935         0x5A, 0xDF, 0xFE, 0xBD, 0x20, 0x27, 0x74, 0x6C, 0x24, 0xC9, 0x03,
2936         0xF3,
2937         0xE1, 0x8D, 0xC3, 0x7D, 0x98, 0x27, 0x40, 0x08, 0xB8, 0x8C, 0x6A,
2938         0xE9,
2939         0xBB, 0x1A, 0x3A, 0xD6, 0x86, 0x83, 0x5E, 0x72, 0x41, 0xCE, 0x85,
2940         0x3C,
2941         0xD2, 0xB3, 0xFC, 0x13, 0xCE, 0x37, 0x81, 0x9E, 0x4C, 0x1C, 0x7B,
2942         0x65,
2943         0xD3, 0xE6, 0xA6, 0x00, 0xF5, 0x5A, 0x95, 0x43, 0x5E, 0x81, 0xCF,
2944         0x60,
2945         0xA2, 0x23, 0xFC, 0x36, 0xA7, 0x5D, 0x7A, 0x4C, 0x06, 0x91, 0x6E,
2946         0xF6,
2947         0x57, 0xEE, 0x36, 0xCB, 0x06, 0xEA, 0xF5, 0x3D, 0x95, 0x49, 0xCB,
2948         0xA7,
2949         0xDD, 0x81, 0xDF, 0x80, 0x09, 0x4A, 0x97, 0x4D, 0xA8, 0x22, 0x72,
2950         0xA1,
2951         0x7F, 0xC4, 0x70, 0x56, 0x70, 0xE8, 0x20, 0x10, 0x18, 0x8F, 0x2E,
2952         0x60,
2953         0x07, 0xE7, 0x68, 0x1A, 0x82, 0x5D, 0x32, 0xA2,
2954     };
2955     DH *dh;
2956
2957     if ((dh = DH_new()) == NULL)
2958         return (NULL);
2959     dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
2960     dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
2961     if ((dh->p == NULL) || (dh->g == NULL)) {
2962         DH_free(dh);
2963         return (NULL);
2964     }
2965     dh->length = 160;
2966     return (dh);
2967 }
2968 #endif
2969
2970 #ifndef OPENSSL_NO_PSK
2971 /* convert the PSK key (psk_key) in ascii to binary (psk) */
2972 static int psk_key2bn(const char *pskkey, unsigned char *psk,
2973                       unsigned int max_psk_len)
2974 {
2975     int ret;
2976     BIGNUM *bn = NULL;
2977
2978     ret = BN_hex2bn(&bn, pskkey);
2979     if (!ret) {
2980         BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
2981                    pskkey);
2982         BN_free(bn);
2983         return 0;
2984     }
2985     if (BN_num_bytes(bn) > (int)max_psk_len) {
2986         BIO_printf(bio_err,
2987                    "psk buffer of callback is too small (%d) for key (%d)\n",
2988                    max_psk_len, BN_num_bytes(bn));
2989         BN_free(bn);
2990         return 0;
2991     }
2992     ret = BN_bn2bin(bn, psk);
2993     BN_free(bn);
2994     return ret;
2995 }
2996
2997 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
2998                                         char *identity,
2999                                         unsigned int max_identity_len,
3000                                         unsigned char *psk,
3001                                         unsigned int max_psk_len)
3002 {
3003     int ret;
3004     unsigned int psk_len = 0;
3005
3006     ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3007     if (ret < 0)
3008         goto out_err;
3009     if (debug)
3010         fprintf(stderr, "client: created identity '%s' len=%d\n", identity,
3011                 ret);
3012     ret = psk_key2bn(psk_key, psk, max_psk_len);
3013     if (ret < 0)
3014         goto out_err;
3015     psk_len = ret;
3016  out_err:
3017     return psk_len;
3018 }
3019
3020 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3021                                         unsigned char *psk,
3022                                         unsigned int max_psk_len)
3023 {
3024     unsigned int psk_len = 0;
3025
3026     if (strcmp(identity, "Client_identity") != 0) {
3027         BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3028         return 0;
3029     }
3030     psk_len = psk_key2bn(psk_key, psk, max_psk_len);
3031     return psk_len;
3032 }
3033 #endif
3034
3035 static int do_test_cipherlist(void)
3036 {
3037     int i = 0;
3038     const SSL_METHOD *meth;
3039     const SSL_CIPHER *ci, *tci = NULL;
3040
3041 #ifndef OPENSSL_NO_SSL3
3042     meth = SSLv3_method();
3043     tci = NULL;
3044     while ((ci = meth->get_cipher(i++)) != NULL) {
3045         if (tci != NULL)
3046             if (ci->id >= tci->id) {
3047                 fprintf(stderr, "testing SSLv3 cipher list order: ");
3048                 fprintf(stderr, "failed %x vs. %x\n", ci->id, tci->id);
3049                 return 0;
3050             }
3051         tci = ci;
3052     }
3053 #endif
3054     meth = TLSv1_method();
3055     tci = NULL;
3056     while ((ci = meth->get_cipher(i++)) != NULL) {
3057         if (tci != NULL)
3058             if (ci->id >= tci->id) {
3059                 fprintf(stderr, "testing TLSv1 cipher list order: ");
3060                 fprintf(stderr, "failed %x vs. %x\n", ci->id, tci->id);
3061                 return 0;
3062             }
3063         tci = ci;
3064     }
3065
3066     return 1;
3067 }