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