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