ssl/ssltest.c

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