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