ssl/ssltest.c

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