ssl/ssltest.c

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