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