test/ssltest.c

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