2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
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.
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).
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.
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
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)"
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
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.]
58 /* ====================================================================
59 * Copyright (c) 1998-2000 The OpenSSL Project. All rights reserved.
61 * Redistribution and use in source and binary forms, with or without
62 * modification, are permitted provided that the following conditions
65 * 1. Redistributions of source code must retain the above copyright
66 * notice, this list of conditions and the following disclaimer.
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
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/)"
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.
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.
87 * 6. Redistributions of any form whatsoever must retain the following
89 * "This product includes software developed by the OpenSSL Project
90 * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
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 * ====================================================================
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).
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.
116 /* ====================================================================
117 * Copyright 2005 Nokia. All rights reserved.
119 * The portions of the attached software ("Contribution") is developed by
120 * Nokia Corporation and is licensed pursuant to the OpenSSL open source
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.
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.
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.
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
143 /* Or gethostname won't be declared properly on Linux and GNU platforms. */
144 #define _BSD_SOURCE 1
145 #define _DEFAULT_SOURCE 1
158 #ifdef OPENSSL_SYS_VMS
160 * Or isascii won't be declared properly on VMS (at least with DECompHP C).
162 # define _XOPEN_SOURCE 500
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>
176 #include <openssl/err.h>
177 #include <openssl/rand.h>
178 #ifndef OPENSSL_NO_RSA
179 # include <openssl/rsa.h>
181 #ifndef OPENSSL_NO_DSA
182 # include <openssl/dsa.h>
184 #ifndef OPENSSL_NO_DH
185 # include <openssl/dh.h>
187 #ifndef OPENSSL_NO_SRP
188 # include <openssl/srp.h>
190 #include <openssl/bn.h>
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
198 #define _XOPEN_SOURCE_EXTENDED 1
200 #ifdef OPENSSL_SYS_WINDOWS
201 # include <winsock.h>
203 # include OPENSSL_UNISTD
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"
216 # define TEST_SERVER_CERT "../apps/server.pem"
217 # define TEST_CLIENT_CERT "../apps/client.pem"
221 * There is really no standard for this, so let's assign some tentative
222 * numbers. In any case, these numbers are only for this test
227 static int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx);
228 #ifndef OPENSSL_NO_RSA
229 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength);
230 static void free_tmp_rsa(void);
232 static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg);
233 #define APP_CALLBACK_STRING "Test Callback Argument"
234 struct app_verify_arg {
237 int allow_proxy_certs;
242 #ifndef OPENSSL_NO_DH
243 static DH *get_dh512(void);
244 static DH *get_dh1024(void);
245 static DH *get_dh1024dsa(void);
248 static char *psk_key = NULL; /* by default PSK is not used */
249 #ifndef OPENSSL_NO_PSK
250 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
252 unsigned int max_identity_len,
254 unsigned int max_psk_len);
255 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
257 unsigned int max_psk_len);
260 #ifndef OPENSSL_NO_SRP
262 /* This is a context that we pass to all callbacks */
263 typedef struct srp_client_arg_st {
268 # define PWD_STRLEN 1024
270 static char *MS_CALLBACK ssl_give_srp_client_pwd_cb(SSL *s, void *arg)
272 SRP_CLIENT_ARG *srp_client_arg = (SRP_CLIENT_ARG *)arg;
273 return BUF_strdup((char *)srp_client_arg->srppassin);
277 /* This is a context that we pass to SRP server callbacks */
278 typedef struct srp_server_arg_st {
283 static int MS_CALLBACK ssl_srp_server_param_cb(SSL *s, int *ad, void *arg)
285 SRP_SERVER_ARG *p = (SRP_SERVER_ARG *)arg;
287 if (strcmp(p->expected_user, SSL_get_srp_username(s)) != 0) {
288 fprintf(stderr, "User %s doesn't exist\n", SSL_get_srp_username(s));
289 return SSL3_AL_FATAL;
291 if (SSL_set_srp_server_param_pw(s, p->expected_user, p->pass, "1024") < 0) {
292 *ad = SSL_AD_INTERNAL_ERROR;
293 return SSL3_AL_FATAL;
295 return SSL_ERROR_NONE;
299 static BIO *bio_err = NULL;
300 static BIO *bio_stdout = NULL;
302 static char *cipher = NULL;
303 static int verbose = 0;
304 static int debug = 0;
308 static int s_nbio = 0;
312 static const char rnd_seed[] =
313 "string to make the random number generator think it has entropy";
315 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long bytes, clock_t *s_time,
317 int doit(SSL *s_ssl, SSL *c_ssl, long bytes);
318 static int do_test_cipherlist(void);
319 static void sv_usage(void)
321 fprintf(stderr, "usage: ssltest [args ...]\n");
322 fprintf(stderr, "\n");
324 fprintf(stderr, "-F - run test in FIPS mode\n");
326 fprintf(stderr, " -server_auth - check server certificate\n");
327 fprintf(stderr, " -client_auth - do client authentication\n");
328 fprintf(stderr, " -proxy - allow proxy certificates\n");
329 fprintf(stderr, " -proxy_auth <val> - set proxy policy rights\n");
331 " -proxy_cond <val> - experssion to test proxy policy rights\n");
332 fprintf(stderr, " -v - more output\n");
333 fprintf(stderr, " -d - debug output\n");
334 fprintf(stderr, " -reuse - use session-id reuse\n");
335 fprintf(stderr, " -num <val> - number of connections to perform\n");
337 " -bytes <val> - number of bytes to swap between client/server\n");
338 #ifndef OPENSSL_NO_DH
340 " -dhe512 - use 512 bit key for DHE (to test failure)\n");
342 " -dhe1024 - use 1024 bit key (safe prime) for DHE (default, no-op)\n");
344 " -dhe1024dsa - use 1024 bit key (with 160-bit subprime) for DHE\n");
345 fprintf(stderr, " -no_dhe - disable DHE\n");
347 #ifndef OPENSSL_NO_ECDH
348 fprintf(stderr, " -no_ecdhe - disable ECDHE\n");
350 #ifndef OPENSSL_NO_PSK
351 fprintf(stderr, " -psk arg - PSK in hex (without 0x)\n");
353 #ifndef OPENSSL_NO_SRP
354 fprintf(stderr, " -srpuser user - SRP username to use\n");
355 fprintf(stderr, " -srppass arg - password for 'user'\n");
357 #ifndef OPENSSL_NO_SSL2
358 fprintf(stderr, " -ssl2 - use SSLv2\n");
360 #ifndef OPENSSL_NO_SSL3_METHOD
361 fprintf(stderr, " -ssl3 - use SSLv3\n");
363 #ifndef OPENSSL_NO_TLS1
364 fprintf(stderr, " -tls1 - use TLSv1\n");
366 fprintf(stderr, " -CApath arg - PEM format directory of CA's\n");
367 fprintf(stderr, " -CAfile arg - PEM format file of CA's\n");
368 fprintf(stderr, " -cert arg - Server certificate file\n");
370 " -key arg - Server key file (default: same as -cert)\n");
371 fprintf(stderr, " -c_cert arg - Client certificate file\n");
373 " -c_key arg - Client key file (default: same as -c_cert)\n");
374 fprintf(stderr, " -cipher arg - The cipher list\n");
375 fprintf(stderr, " -bio_pair - Use BIO pairs\n");
376 fprintf(stderr, " -f - Test even cases that can't work\n");
378 " -time - measure processor time used by client and server\n");
379 fprintf(stderr, " -zlib - use zlib compression\n");
380 fprintf(stderr, " -rle - use rle compression\n");
381 #ifndef OPENSSL_NO_ECDH
383 " -named_curve arg - Elliptic curve name to use for ephemeral ECDH keys.\n"
384 " Use \"openssl ecparam -list_curves\" for all names\n"
385 " (default is sect163r2).\n");
388 " -test_cipherlist - Verifies the order of the ssl cipher lists.\n"
389 " When this option is requested, the cipherlist\n"
390 " tests are run instead of handshake tests.\n");
393 static void print_details(SSL *c_ssl, const char *prefix)
395 const SSL_CIPHER *ciph;
398 ciph = SSL_get_current_cipher(c_ssl);
399 BIO_printf(bio_stdout, "%s%s, cipher %s %s",
401 SSL_get_version(c_ssl),
402 SSL_CIPHER_get_version(ciph), SSL_CIPHER_get_name(ciph));
403 cert = SSL_get_peer_certificate(c_ssl);
405 EVP_PKEY *pkey = X509_get_pubkey(cert);
408 #ifndef OPENSSL_NO_RSA
409 else if (pkey->type == EVP_PKEY_RSA && pkey->pkey.rsa != NULL
410 && pkey->pkey.rsa->n != NULL) {
411 BIO_printf(bio_stdout, ", %d bit RSA",
412 BN_num_bits(pkey->pkey.rsa->n));
415 #ifndef OPENSSL_NO_DSA
416 else if (pkey->type == EVP_PKEY_DSA && pkey->pkey.dsa != NULL
417 && pkey->pkey.dsa->p != NULL) {
418 BIO_printf(bio_stdout, ", %d bit DSA",
419 BN_num_bits(pkey->pkey.dsa->p));
427 * The SSL API does not allow us to look at temporary RSA/DH keys,
428 * otherwise we should print their lengths too
430 BIO_printf(bio_stdout, "\n");
433 static void lock_dbg_cb(int mode, int type, const char *file, int line)
435 static int modes[CRYPTO_NUM_LOCKS]; /* = {0, 0, ... } */
436 const char *errstr = NULL;
439 rw = mode & (CRYPTO_READ | CRYPTO_WRITE);
440 if (!((rw == CRYPTO_READ) || (rw == CRYPTO_WRITE))) {
441 errstr = "invalid mode";
445 if (type < 0 || type >= CRYPTO_NUM_LOCKS) {
446 errstr = "type out of bounds";
450 if (mode & CRYPTO_LOCK) {
452 errstr = "already locked";
454 * must not happen in a single-threaded program (would deadlock)
460 } else if (mode & CRYPTO_UNLOCK) {
462 errstr = "not locked";
466 if (modes[type] != rw) {
467 errstr = (rw == CRYPTO_READ) ?
468 "CRYPTO_r_unlock on write lock" :
469 "CRYPTO_w_unlock on read lock";
474 errstr = "invalid mode";
480 /* we cannot use bio_err here */
482 "openssl (lock_dbg_cb): %s (mode=%d, type=%d) at %s:%d\n",
483 errstr, mode, type, file, line);
487 #ifdef TLSEXT_TYPE_opaque_prf_input
493 struct cb_info_st co1 = { "C", 1, 1 }; /* try to negotiate oqaque PRF input */
494 struct cb_info_st co2 = { "C", 1, 2 }; /* insist on oqaque PRF input */
495 struct cb_info_st so1 = { "S", 1, 1 }; /* try to negotiate oqaque PRF input */
496 struct cb_info_st so2 = { "S", 1, 2 }; /* insist on oqaque PRF input */
498 int opaque_prf_input_cb(SSL *ssl, void *peerinput, size_t len, void *arg_)
500 struct cb_info_st *arg = arg_;
505 if (!SSL_set_tlsext_opaque_prf_input(ssl, arg->input, arg->len))
511 int main(int argc, char *argv[])
513 char *CApath = NULL, *CAfile = NULL;
517 int tls1 = 0, ssl2 = 0, ssl3 = 0, ret = 1;
519 int server_auth = 0, i;
520 struct app_verify_arg app_verify_arg =
521 { APP_CALLBACK_STRING, 0, 0, NULL, NULL };
522 char *server_cert = TEST_SERVER_CERT;
523 char *server_key = NULL;
524 char *client_cert = TEST_CLIENT_CERT;
525 char *client_key = NULL;
526 #ifndef OPENSSL_NO_ECDH
527 char *named_curve = NULL;
529 SSL_CTX *s_ctx = NULL;
530 SSL_CTX *c_ctx = NULL;
531 const SSL_METHOD *meth = NULL;
533 int number = 1, reuse = 0;
535 #ifndef OPENSSL_NO_DH
537 int dhe512 = 0, dhe1024dsa = 0;
539 #ifndef OPENSSL_NO_ECDH
542 #ifndef OPENSSL_NO_SRP
544 SRP_CLIENT_ARG srp_client_arg = { NULL, NULL };
546 SRP_SERVER_ARG srp_server_arg = { NULL, NULL };
552 clock_t s_time = 0, c_time = 0;
554 #ifndef OPENSSL_NO_COMP
555 COMP_METHOD *cm = NULL;
556 STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
558 int test_cipherlist = 0;
568 bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
570 CRYPTO_set_locking_callback(lock_dbg_cb);
572 /* enable memory leak checking unless explicitly disabled */
573 if (!((getenv("OPENSSL_DEBUG_MEMORY") != NULL)
574 && (0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off")))) {
575 CRYPTO_malloc_debug_init();
576 CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
578 /* OPENSSL_DEBUG_MEMORY=off */
579 CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);
581 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
583 RAND_seed(rnd_seed, sizeof rnd_seed);
585 bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);
591 if (!strcmp(*argv, "-F")) {
596 "not compiled with FIPS support, so exitting without running.\n");
599 } else if (strcmp(*argv, "-server_auth") == 0)
601 else if (strcmp(*argv, "-client_auth") == 0)
603 else if (strcmp(*argv, "-proxy_auth") == 0) {
606 app_verify_arg.proxy_auth = *(++argv);
607 } else if (strcmp(*argv, "-proxy_cond") == 0) {
610 app_verify_arg.proxy_cond = *(++argv);
611 } else if (strcmp(*argv, "-v") == 0)
613 else if (strcmp(*argv, "-d") == 0)
615 else if (strcmp(*argv, "-reuse") == 0)
617 else if (strcmp(*argv, "-dhe512") == 0) {
618 #ifndef OPENSSL_NO_DH
622 "ignoring -dhe512, since I'm compiled without DH\n");
624 } else if (strcmp(*argv, "-dhe1024dsa") == 0) {
625 #ifndef OPENSSL_NO_DH
629 "ignoring -dhe1024dsa, since I'm compiled without DH\n");
631 } else if (strcmp(*argv, "-no_dhe") == 0)
633 else if (strcmp(*argv, "-no_ecdhe") == 0)
635 else if (strcmp(*argv, "-psk") == 0) {
639 #ifndef OPENSSL_NO_PSK
640 if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key)) {
641 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
648 #ifndef OPENSSL_NO_SRP
649 else if (strcmp(*argv, "-srpuser") == 0) {
652 srp_server_arg.expected_user = srp_client_arg.srplogin =
655 } else if (strcmp(*argv, "-srppass") == 0) {
658 srp_server_arg.pass = srp_client_arg.srppassin = *(++argv);
662 else if (strcmp(*argv, "-ssl2") == 0) {
663 #ifdef OPENSSL_NO_SSL2
667 } else if (strcmp(*argv, "-tls1") == 0) {
668 #ifdef OPENSSL_NO_TLS1
672 } else if (strcmp(*argv, "-ssl3") == 0) {
673 #ifdef OPENSSL_NO_SSL3_METHOD
677 } else if (strncmp(*argv, "-num", 4) == 0) {
680 number = atoi(*(++argv));
683 } else if (strcmp(*argv, "-bytes") == 0) {
686 bytes = atol(*(++argv));
690 if (argv[0][i - 1] == 'k')
692 if (argv[0][i - 1] == 'm')
693 bytes *= 1024L * 1024L;
694 } else if (strcmp(*argv, "-cert") == 0) {
697 server_cert = *(++argv);
698 } else if (strcmp(*argv, "-s_cert") == 0) {
701 server_cert = *(++argv);
702 } else if (strcmp(*argv, "-key") == 0) {
705 server_key = *(++argv);
706 } else if (strcmp(*argv, "-s_key") == 0) {
709 server_key = *(++argv);
710 } else if (strcmp(*argv, "-c_cert") == 0) {
713 client_cert = *(++argv);
714 } else if (strcmp(*argv, "-c_key") == 0) {
717 client_key = *(++argv);
718 } else if (strcmp(*argv, "-cipher") == 0) {
722 } else if (strcmp(*argv, "-CApath") == 0) {
726 } else if (strcmp(*argv, "-CAfile") == 0) {
730 } else if (strcmp(*argv, "-bio_pair") == 0) {
732 } else if (strcmp(*argv, "-f") == 0) {
734 } else if (strcmp(*argv, "-time") == 0) {
736 } else if (strcmp(*argv, "-zlib") == 0) {
738 } else if (strcmp(*argv, "-rle") == 0) {
740 } else if (strcmp(*argv, "-named_curve") == 0) {
743 #ifndef OPENSSL_NO_ECDH
744 named_curve = *(++argv);
747 "ignoring -named_curve, since I'm compiled without ECDH\n");
750 } else if (strcmp(*argv, "-app_verify") == 0) {
751 app_verify_arg.app_verify = 1;
752 } else if (strcmp(*argv, "-proxy") == 0) {
753 app_verify_arg.allow_proxy_certs = 1;
754 } else if (strcmp(*argv, "-test_cipherlist") == 0) {
757 fprintf(stderr, "unknown option %s\n", *argv);
771 * test_cipherlist prevails over protocol switch: we test the cipherlist
772 * for all enabled protocols.
774 if (test_cipherlist == 1) {
776 * ensure that the cipher list are correctly sorted and exit
778 fprintf(stdout, "Testing cipherlist order only. Ignoring all "
780 if (do_test_cipherlist() == 0)
786 if (ssl2 + ssl3 + tls1 > 1) {
787 fprintf(stderr, "At most one of -ssl2, -ssl3, or -tls1 should "
793 * Testing was requested for a compiled-out protocol (e.g. SSLv2).
794 * Ideally, we would error out, but the generic test wrapper can't know
795 * when to expect failure. So we do nothing and return success.
798 fprintf(stderr, "Testing was requested for a disabled protocol. "
799 "Skipping tests.\n");
804 if (!ssl2 && !ssl3 && !tls1 && number > 1 && !reuse && !force) {
805 fprintf(stderr, "This case cannot work. Use -f to perform "
806 "the test anyway (and\n-d to see what happens), "
807 "or add one of -ssl2, -ssl3, -tls1, -reuse\n"
808 "to avoid protocol mismatch.\n");
813 if (!FIPS_mode_set(1)) {
814 ERR_load_crypto_strings();
815 ERR_print_errors(BIO_new_fp(stderr, BIO_NOCLOSE));
818 fprintf(stderr, "*** IN FIPS MODE ***\n");
824 fprintf(stderr, "Using BIO pair (-bio_pair)\n");
827 if (number < 50 && !force)
829 "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
832 /* if (cipher == NULL) cipher=getenv("SSL_CIPHER"); */
835 SSL_load_error_strings();
837 #ifndef OPENSSL_NO_COMP
838 if (comp == COMP_ZLIB)
840 if (comp == COMP_RLE)
843 if (cm->type != NID_undef) {
844 if (SSL_COMP_add_compression_method(comp, cm) != 0) {
845 fprintf(stderr, "Failed to add compression method\n");
846 ERR_print_errors_fp(stderr);
850 "Warning: %s compression not supported\n",
851 (comp == COMP_RLE ? "rle" :
852 (comp == COMP_ZLIB ? "zlib" : "unknown")));
853 ERR_print_errors_fp(stderr);
856 ssl_comp_methods = SSL_COMP_get_compression_methods();
857 fprintf(stderr, "Available compression methods:\n");
859 int j, n = sk_SSL_COMP_num(ssl_comp_methods);
861 fprintf(stderr, " NONE\n");
863 for (j = 0; j < n; j++) {
864 SSL_COMP *c = sk_SSL_COMP_value(ssl_comp_methods, j);
865 fprintf(stderr, " %d: %s\n", c->id, c->name);
871 * At this point, ssl2/ssl3/tls1 is only set if the protocol is
872 * available. (Otherwise we exit early.) However the compiler doesn't
873 * know this, so we ifdef.
875 #ifndef OPENSSL_NO_SSL2
877 meth = SSLv2_method();
880 #ifndef OPENSSL_NO_SSL3
882 meth = SSLv3_method();
885 #ifndef OPENSSL_NO_TLS1
887 meth = TLSv1_method();
890 meth = SSLv23_method();
892 c_ctx = SSL_CTX_new(meth);
893 s_ctx = SSL_CTX_new(meth);
894 if ((c_ctx == NULL) || (s_ctx == NULL)) {
895 ERR_print_errors(bio_err);
899 if (cipher != NULL) {
900 SSL_CTX_set_cipher_list(c_ctx, cipher);
901 SSL_CTX_set_cipher_list(s_ctx, cipher);
903 #ifndef OPENSSL_NO_DH
907 * use SSL_OP_SINGLE_DH_USE to avoid small subgroup attacks
909 SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_DH_USE);
910 dh = get_dh1024dsa();
915 SSL_CTX_set_tmp_dh(s_ctx, dh);
922 #ifndef OPENSSL_NO_ECDH
926 if (named_curve != NULL) {
927 nid = OBJ_sn2nid(named_curve);
929 BIO_printf(bio_err, "unknown curve name (%s)\n", named_curve);
933 # ifdef OPENSSL_NO_EC2M
934 nid = NID_X9_62_prime256v1;
939 ecdh = EC_KEY_new_by_curve_name(nid);
941 BIO_printf(bio_err, "unable to create curve\n");
945 SSL_CTX_set_tmp_ecdh(s_ctx, ecdh);
946 SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_ECDH_USE);
953 #ifndef OPENSSL_NO_RSA
954 SSL_CTX_set_tmp_rsa_callback(s_ctx, tmp_rsa_cb);
957 #ifdef TLSEXT_TYPE_opaque_prf_input
958 SSL_CTX_set_tlsext_opaque_prf_input_callback(c_ctx, opaque_prf_input_cb);
959 SSL_CTX_set_tlsext_opaque_prf_input_callback(s_ctx, opaque_prf_input_cb);
960 /* or &co2 or NULL */
961 SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(c_ctx, &co1);
962 /* or &so2 or NULL */
963 SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(s_ctx, &so1);
966 if (!SSL_CTX_use_certificate_file(s_ctx, server_cert, SSL_FILETYPE_PEM)) {
967 ERR_print_errors(bio_err);
968 } else if (!SSL_CTX_use_PrivateKey_file(s_ctx,
969 (server_key ? server_key :
972 ERR_print_errors(bio_err);
977 SSL_CTX_use_certificate_file(c_ctx, client_cert, SSL_FILETYPE_PEM);
978 SSL_CTX_use_PrivateKey_file(c_ctx,
979 (client_key ? client_key : client_cert),
983 if ((!SSL_CTX_load_verify_locations(s_ctx, CAfile, CApath)) ||
984 (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
985 (!SSL_CTX_load_verify_locations(c_ctx, CAfile, CApath)) ||
986 (!SSL_CTX_set_default_verify_paths(c_ctx))) {
987 /* fprintf(stderr,"SSL_load_verify_locations\n"); */
988 ERR_print_errors(bio_err);
993 BIO_printf(bio_err, "client authentication\n");
994 SSL_CTX_set_verify(s_ctx,
995 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
997 SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback,
1001 BIO_printf(bio_err, "server authentication\n");
1002 SSL_CTX_set_verify(c_ctx, SSL_VERIFY_PEER, verify_callback);
1003 SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback,
1008 int session_id_context = 0;
1009 SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context,
1010 sizeof session_id_context);
1013 /* Use PSK only if PSK key is given */
1014 if (psk_key != NULL) {
1016 * no_psk is used to avoid putting psk command to openssl tool
1020 * if PSK is not compiled in and psk key is given, do nothing and
1026 #ifndef OPENSSL_NO_PSK
1027 SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1028 SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1030 BIO_printf(bio_err, "setting PSK identity hint to s_ctx\n");
1031 if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint")) {
1032 BIO_printf(bio_err, "error setting PSK identity hint to s_ctx\n");
1033 ERR_print_errors(bio_err);
1038 #ifndef OPENSSL_NO_SRP
1039 if (srp_client_arg.srplogin) {
1040 if (!SSL_CTX_set_srp_username(c_ctx, srp_client_arg.srplogin)) {
1041 BIO_printf(bio_err, "Unable to set SRP username\n");
1044 SSL_CTX_set_srp_cb_arg(c_ctx, &srp_client_arg);
1045 SSL_CTX_set_srp_client_pwd_callback(c_ctx,
1046 ssl_give_srp_client_pwd_cb);
1048 * SSL_CTX_set_srp_strength(c_ctx, srp_client_arg.strength);
1052 if (srp_server_arg.expected_user != NULL) {
1053 SSL_CTX_set_verify(s_ctx, SSL_VERIFY_NONE, verify_callback);
1054 SSL_CTX_set_srp_cb_arg(s_ctx, &srp_server_arg);
1055 SSL_CTX_set_srp_username_callback(s_ctx, ssl_srp_server_param_cb);
1059 c_ssl = SSL_new(c_ctx);
1060 s_ssl = SSL_new(s_ctx);
1062 #ifndef OPENSSL_NO_KRB5
1063 if (c_ssl && c_ssl->kssl_ctx) {
1064 char localhost[MAXHOSTNAMELEN + 2];
1066 if (gethostname(localhost, sizeof localhost - 1) == 0) {
1067 localhost[sizeof localhost - 1] = '\0';
1068 if (strlen(localhost) == sizeof localhost - 1) {
1069 BIO_printf(bio_err, "localhost name too long\n");
1072 kssl_ctx_setstring(c_ssl->kssl_ctx, KSSL_SERVER, localhost);
1075 #endif /* OPENSSL_NO_KRB5 */
1077 for (i = 0; i < number; i++) {
1079 SSL_set_session(c_ssl, NULL);
1081 ret = doit_biopair(s_ssl, c_ssl, bytes, &s_time, &c_time);
1083 ret = doit(s_ssl, c_ssl, bytes);
1087 print_details(c_ssl, "");
1089 if ((number > 1) || (bytes > 1L))
1090 BIO_printf(bio_stdout, "%d handshakes of %ld bytes done\n", number,
1093 #ifdef CLOCKS_PER_SEC
1095 * "To determine the time in seconds, the value returned by the clock
1096 * function should be divided by the value of the macro
1097 * CLOCKS_PER_SEC." -- ISO/IEC 9899
1099 BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1100 "Approximate total client time: %6.2f s\n",
1101 (double)s_time / CLOCKS_PER_SEC,
1102 (double)c_time / CLOCKS_PER_SEC);
1105 * "`CLOCKS_PER_SEC' undeclared (first use this function)" -- cc on
1108 BIO_printf(bio_stdout,
1109 "Approximate total server time: %6.2f units\n"
1110 "Approximate total client time: %6.2f units\n",
1111 (double)s_time, (double)c_time);
1120 SSL_CTX_free(s_ctx);
1122 SSL_CTX_free(c_ctx);
1124 if (bio_stdout != NULL)
1125 BIO_free(bio_stdout);
1127 #ifndef OPENSSL_NO_RSA
1130 #ifndef OPENSSL_NO_ENGINE
1133 CRYPTO_cleanup_all_ex_data();
1135 ERR_remove_thread_state(NULL);
1137 CRYPTO_mem_leaks(bio_err);
1138 if (bio_err != NULL)
1144 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
1145 clock_t *s_time, clock_t *c_time)
1147 long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1148 BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1149 BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
1152 size_t bufsiz = 256; /* small buffer for testing */
1154 if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
1156 if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
1159 s_ssl_bio = BIO_new(BIO_f_ssl());
1163 c_ssl_bio = BIO_new(BIO_f_ssl());
1167 SSL_set_connect_state(c_ssl);
1168 SSL_set_bio(c_ssl, client, client);
1169 (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1171 SSL_set_accept_state(s_ssl);
1172 SSL_set_bio(s_ssl, server, server);
1173 (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1177 * c_ssl_bio: SSL filter BIO
1179 * client: pseudo-I/O for SSL library
1181 * client_io: client's SSL communication; usually to be
1182 * relayed over some I/O facility, but in this
1183 * test program, we're the server, too:
1185 * server_io: server's SSL communication
1187 * server: pseudo-I/O for SSL library
1189 * s_ssl_bio: SSL filter BIO
1191 * The client and the server each employ a "BIO pair":
1192 * client + client_io, server + server_io.
1193 * BIO pairs are symmetric. A BIO pair behaves similar
1194 * to a non-blocking socketpair (but both endpoints must
1195 * be handled by the same thread).
1196 * [Here we could connect client and server to the ends
1197 * of a single BIO pair, but then this code would be less
1198 * suitable as an example for BIO pairs in general.]
1200 * Useful functions for querying the state of BIO pair endpoints:
1202 * BIO_ctrl_pending(bio) number of bytes we can read now
1203 * BIO_ctrl_get_read_request(bio) number of bytes needed to fulfil
1204 * other side's read attempt
1205 * BIO_ctrl_get_write_guarantee(bio) number of bytes we can write now
1207 * ..._read_request is never more than ..._write_guarantee;
1208 * it depends on the application which one you should use.
1212 * We have non-blocking behaviour throughout this test program, but
1213 * can be sure that there is *some* progress in each iteration; so we
1214 * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
1215 * we just try everything in each iteration
1221 MS_STATIC char cbuf[1024 * 8];
1223 clock_t c_clock = clock();
1225 memset(cbuf, 0, sizeof(cbuf));
1228 if (SSL_in_init(c_ssl))
1229 printf("client waiting in SSL_connect - %s\n",
1230 SSL_state_string_long(c_ssl));
1233 /* Write to server. */
1235 if (cw_num > (long)sizeof cbuf)
1239 r = BIO_write(c_ssl_bio, cbuf, i);
1241 if (!BIO_should_retry(c_ssl_bio)) {
1242 fprintf(stderr, "ERROR in CLIENT\n");
1246 * BIO_should_retry(...) can just be ignored here. The
1247 * library expects us to call BIO_write with the same
1248 * arguments again, and that's what we will do in the
1251 } else if (r == 0) {
1252 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1256 printf("client wrote %d\n", r);
1262 /* Read from server. */
1264 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1266 if (!BIO_should_retry(c_ssl_bio)) {
1267 fprintf(stderr, "ERROR in CLIENT\n");
1271 * Again, "BIO_should_retry" can be ignored.
1273 } else if (r == 0) {
1274 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1278 printf("client read %d\n", r);
1284 * c_time and s_time increments will typically be very small
1285 * (depending on machine speed and clock tick intervals), but
1286 * sampling over a large number of connections should result in
1287 * fairly accurate figures. We cannot guarantee a lot, however
1288 * -- if each connection lasts for exactly one clock tick, it
1289 * will be counted only for the client or only for the server or
1292 *c_time += (clock() - c_clock);
1298 MS_STATIC char sbuf[1024 * 8];
1300 clock_t s_clock = clock();
1302 memset(sbuf, 0, sizeof(sbuf));
1305 if (SSL_in_init(s_ssl))
1306 printf("server waiting in SSL_accept - %s\n",
1307 SSL_state_string_long(s_ssl));
1310 /* Write to client. */
1312 if (sw_num > (long)sizeof sbuf)
1316 r = BIO_write(s_ssl_bio, sbuf, i);
1318 if (!BIO_should_retry(s_ssl_bio)) {
1319 fprintf(stderr, "ERROR in SERVER\n");
1322 /* Ignore "BIO_should_retry". */
1323 } else if (r == 0) {
1324 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
1328 printf("server wrote %d\n", r);
1334 /* Read from client. */
1336 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
1338 if (!BIO_should_retry(s_ssl_bio)) {
1339 fprintf(stderr, "ERROR in SERVER\n");
1343 } else if (r == 0) {
1344 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
1348 printf("server read %d\n", r);
1353 *s_time += (clock() - s_clock);
1357 /* "I/O" BETWEEN CLIENT AND SERVER. */
1360 BIO *io1 = server_io, *io2 = client_io;
1362 * we use the non-copying interface for io1 and the standard
1363 * BIO_write/BIO_read interface for io2
1366 static int prev_progress = 1;
1374 r1 = BIO_ctrl_pending(io1);
1375 r2 = BIO_ctrl_get_write_guarantee(io2);
1383 if (INT_MAX < num) /* yeah, right */
1386 r = BIO_nread(io1, &dataptr, (int)num);
1388 assert(r <= (int)num);
1390 * possibly r < num (non-contiguous data)
1393 r = BIO_write(io2, dataptr, (int)num);
1394 if (r != (int)num) { /* can't happen */
1395 fprintf(stderr, "ERROR: BIO_write could not write "
1396 "BIO_ctrl_get_write_guarantee() bytes");
1402 printf((io1 == client_io) ?
1403 "C->S relaying: %d bytes\n" :
1404 "S->C relaying: %d bytes\n", (int)num);
1414 r1 = BIO_ctrl_pending(io2);
1415 r2 = BIO_ctrl_get_read_request(io1);
1417 * here we could use ..._get_write_guarantee instead of
1418 * ..._get_read_request, but by using the latter we test
1419 * restartability of the SSL implementation more thoroughly
1431 --num; /* test restartability even more thoroughly */
1433 r = BIO_nwrite0(io1, &dataptr);
1437 r = BIO_read(io2, dataptr, (int)num);
1438 if (r != (int)num) { /* can't happen */
1439 fprintf(stderr, "ERROR: BIO_read could not read "
1440 "BIO_ctrl_pending() bytes");
1444 r = BIO_nwrite(io1, &dataptr, (int)num);
1445 if (r != (int)num) { /* can't happen */
1446 fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
1447 "BIO_nwrite0() bytes");
1452 printf((io2 == client_io) ?
1453 "C->S relaying: %d bytes\n" :
1454 "S->C relaying: %d bytes\n", (int)num);
1456 } /* no loop, BIO_ctrl_get_read_request now
1457 * returns 0 anyway */
1459 if (!progress && !prev_progress)
1460 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0) {
1461 fprintf(stderr, "ERROR: got stuck\n");
1462 if (strcmp("SSLv2", SSL_get_version(c_ssl)) == 0) {
1463 fprintf(stderr, "This can happen for SSL2 because "
1464 "CLIENT-FINISHED and SERVER-VERIFY are written \n"
1465 "concurrently ...");
1466 if (strncmp("2SCF", SSL_state_string(c_ssl), 4) == 0
1467 && strncmp("2SSV", SSL_state_string(s_ssl),
1469 fprintf(stderr, " ok.\n");
1473 fprintf(stderr, " ERROR.\n");
1476 prev_progress = progress;
1479 while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
1482 print_details(c_ssl, "DONE via BIO pair: ");
1487 ERR_print_errors(bio_err);
1492 BIO_free(server_io);
1496 BIO_free(client_io);
1498 BIO_free(s_ssl_bio);
1500 BIO_free(c_ssl_bio);
1510 int doit(SSL *s_ssl, SSL *c_ssl, long count)
1512 MS_STATIC char cbuf[1024 * 8], sbuf[1024 * 8];
1513 long cw_num = count, cr_num = count;
1514 long sw_num = count, sr_num = count;
1520 int c_r, c_w, s_r, s_w;
1523 int c_write, s_write;
1524 int do_server = 0, do_client = 0;
1526 memset(cbuf, 0, sizeof(cbuf));
1527 memset(sbuf, 0, sizeof(sbuf));
1529 c_to_s = BIO_new(BIO_s_mem());
1530 s_to_c = BIO_new(BIO_s_mem());
1531 if ((s_to_c == NULL) || (c_to_s == NULL)) {
1532 ERR_print_errors(bio_err);
1536 c_bio = BIO_new(BIO_f_ssl());
1537 s_bio = BIO_new(BIO_f_ssl());
1538 if ((c_bio == NULL) || (s_bio == NULL)) {
1539 ERR_print_errors(bio_err);
1543 SSL_set_connect_state(c_ssl);
1544 SSL_set_bio(c_ssl, s_to_c, c_to_s);
1545 BIO_set_ssl(c_bio, c_ssl, BIO_NOCLOSE);
1547 SSL_set_accept_state(s_ssl);
1548 SSL_set_bio(s_ssl, c_to_s, s_to_c);
1549 BIO_set_ssl(s_bio, s_ssl, BIO_NOCLOSE);
1555 c_write = 1, s_write = 0;
1557 /* We can always do writes */
1562 i = (int)BIO_pending(s_bio);
1563 if ((i && s_r) || s_w)
1566 i = (int)BIO_pending(c_bio);
1567 if ((i && c_r) || c_w)
1570 if (do_server && debug) {
1571 if (SSL_in_init(s_ssl))
1572 printf("server waiting in SSL_accept - %s\n",
1573 SSL_state_string_long(s_ssl));
1576 printf("server:SSL_write()\n");
1578 printf("server:SSL_read()\n"); */
1581 if (do_client && debug) {
1582 if (SSL_in_init(c_ssl))
1583 printf("client waiting in SSL_connect - %s\n",
1584 SSL_state_string_long(c_ssl));
1587 printf("client:SSL_write()\n");
1589 printf("client:SSL_read()\n"); */
1592 if (!do_client && !do_server) {
1593 fprintf(stdout, "ERROR IN STARTUP\n");
1594 ERR_print_errors(bio_err);
1597 if (do_client && !(done & C_DONE)) {
1599 j = (cw_num > (long)sizeof(cbuf)) ?
1600 (int)sizeof(cbuf) : (int)cw_num;
1601 i = BIO_write(c_bio, cbuf, j);
1605 if (BIO_should_retry(c_bio)) {
1606 if (BIO_should_read(c_bio))
1608 if (BIO_should_write(c_bio))
1611 fprintf(stderr, "ERROR in CLIENT\n");
1612 ERR_print_errors(bio_err);
1615 } else if (i == 0) {
1616 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1620 printf("client wrote %d\n", i);
1627 i = BIO_read(c_bio, cbuf, sizeof(cbuf));
1631 if (BIO_should_retry(c_bio)) {
1632 if (BIO_should_read(c_bio))
1634 if (BIO_should_write(c_bio))
1637 fprintf(stderr, "ERROR in CLIENT\n");
1638 ERR_print_errors(bio_err);
1641 } else if (i == 0) {
1642 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1646 printf("client read %d\n", i);
1655 done = S_DONE | C_DONE;
1661 if (do_server && !(done & S_DONE)) {
1663 i = BIO_read(s_bio, sbuf, sizeof(cbuf));
1667 if (BIO_should_retry(s_bio)) {
1668 if (BIO_should_read(s_bio))
1670 if (BIO_should_write(s_bio))
1673 fprintf(stderr, "ERROR in SERVER\n");
1674 ERR_print_errors(bio_err);
1677 } else if (i == 0) {
1678 ERR_print_errors(bio_err);
1680 "SSL SERVER STARTUP FAILED in SSL_read\n");
1684 printf("server read %d\n", i);
1697 j = (sw_num > (long)sizeof(sbuf)) ?
1698 (int)sizeof(sbuf) : (int)sw_num;
1699 i = BIO_write(s_bio, sbuf, j);
1703 if (BIO_should_retry(s_bio)) {
1704 if (BIO_should_read(s_bio))
1706 if (BIO_should_write(s_bio))
1709 fprintf(stderr, "ERROR in SERVER\n");
1710 ERR_print_errors(bio_err);
1713 } else if (i == 0) {
1714 ERR_print_errors(bio_err);
1716 "SSL SERVER STARTUP FAILED in SSL_write\n");
1720 printf("server wrote %d\n", i);
1730 if ((done & S_DONE) && (done & C_DONE))
1735 print_details(c_ssl, "DONE: ");
1739 * We have to set the BIO's to NULL otherwise they will be
1740 * OPENSSL_free()ed twice. Once when th s_ssl is SSL_free()ed and again
1741 * when c_ssl is SSL_free()ed. This is a hack required because s_ssl and
1742 * c_ssl are sharing the same BIO structure and SSL_set_bio() and
1743 * SSL_free() automatically BIO_free non NULL entries. You should not
1744 * normally do this or be required to do this
1746 if (s_ssl != NULL) {
1750 if (c_ssl != NULL) {
1760 BIO_free_all(c_bio);
1762 BIO_free_all(s_bio);
1766 static int get_proxy_auth_ex_data_idx(void)
1768 static volatile int idx = -1;
1770 CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
1772 idx = X509_STORE_CTX_get_ex_new_index(0,
1773 "SSLtest for verify callback",
1776 CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
1781 static int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx)
1785 s = X509_NAME_oneline(X509_get_subject_name(ctx->current_cert), buf,
1789 fprintf(stderr, "depth=%d %s\n", ctx->error_depth, buf);
1791 fprintf(stderr, "depth=%d error=%d %s\n",
1792 ctx->error_depth, ctx->error, buf);
1797 fprintf(stderr, "Error string: %s\n",
1798 X509_verify_cert_error_string(ctx->error));
1799 switch (ctx->error) {
1800 case X509_V_ERR_CERT_NOT_YET_VALID:
1801 case X509_V_ERR_CERT_HAS_EXPIRED:
1802 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
1803 fprintf(stderr, " ... ignored.\n");
1809 X509 *xs = ctx->current_cert;
1811 X509 *xi = ctx->current_issuer;
1814 if (xs->ex_flags & EXFLAG_PROXY) {
1815 unsigned int *letters = X509_STORE_CTX_get_ex_data(ctx,
1816 get_proxy_auth_ex_data_idx
1822 PROXY_CERT_INFO_EXTENSION *pci =
1823 X509_get_ext_d2i(xs, NID_proxyCertInfo,
1826 switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage)) {
1827 case NID_Independent:
1829 * Completely meaningless in this program, as there's no
1830 * way to grant explicit rights to a specific PrC.
1831 * Basically, using id-ppl-Independent is the perfect way
1832 * to grant no rights at all.
1834 fprintf(stderr, " Independent proxy certificate");
1835 for (i = 0; i < 26; i++)
1838 case NID_id_ppl_inheritAll:
1840 * This is basically a NOP, we simply let the current
1841 * rights stand as they are.
1843 fprintf(stderr, " Proxy certificate inherits all");
1847 pci->proxyPolicy->policy->data;
1848 i = pci->proxyPolicy->policy->length;
1851 * The algorithm works as follows: it is assumed that
1852 * previous iterations or the initial granted rights has
1853 * already set some elements of `letters'. What we need
1854 * to do is to clear those that weren't granted by the
1855 * current PrC as well. The easiest way to do this is to
1856 * add 1 to all the elements whose letters are given with
1857 * the current policy. That way, all elements that are
1858 * set by the current policy and were already set by
1859 * earlier policies and through the original grant of
1860 * rights will get the value 2 or higher. The last thing
1861 * to do is to sweep through `letters' and keep the
1862 * elements having the value 2 as set, and clear all the
1866 fprintf(stderr, " Certificate proxy rights = %*.*s", i,
1870 if (isascii(c) && isalpha(c)) {
1876 for (i = 0; i < 26; i++)
1884 fprintf(stderr, ", resulting proxy rights = ");
1885 for (i = 0; i < 26; i++)
1887 fprintf(stderr, "%c", i + 'A');
1891 fprintf(stderr, "none");
1892 fprintf(stderr, "\n");
1894 PROXY_CERT_INFO_EXTENSION_free(pci);
1902 static void process_proxy_debug(int indent, const char *format, ...)
1905 static const char indentation[] =
1906 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
1907 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
1908 char my_format[256];
1911 BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
1912 indent, indent, indentation, format);
1914 va_start(args, format);
1915 vfprintf(stderr, my_format, args);
1925 static int process_proxy_cond_adders(unsigned int letters[26],
1926 const char *cond, const char **cond_end,
1927 int *pos, int indent);
1928 static int process_proxy_cond_val(unsigned int letters[26], const char *cond,
1929 const char **cond_end, int *pos, int indent)
1935 while (isspace((int)*cond)) {
1942 process_proxy_debug(indent,
1943 "Start process_proxy_cond_val at position %d: %s\n",
1950 while (isspace((int)*cond)) {
1960 ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
1965 while (isspace((int)*cond)) {
1972 "Weird condition character in position %d: "
1979 } else if (isascii(c) && isalpha(c)) {
1982 ok = letters[c - 'A'];
1987 "Weird condition character in position %d: " "%c\n", *pos, c);
1993 if (ok >= 0 && negate)
1997 process_proxy_debug(indent,
1998 "End process_proxy_cond_val at position %d: %s, returning %d\n",
2004 static int process_proxy_cond_multipliers(unsigned int letters[26],
2006 const char **cond_end, int *pos,
2013 process_proxy_debug(indent,
2014 "Start process_proxy_cond_multipliers at position %d: %s\n",
2017 ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
2023 while (isspace((int)*cond)) {
2037 ok = process_proxy_cond_val(letters,
2038 cond, cond_end, pos, indent + 1);
2051 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2063 process_proxy_debug(indent,
2064 "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
2071 static int process_proxy_cond_adders(unsigned int letters[26],
2072 const char *cond, const char **cond_end,
2073 int *pos, int indent)
2079 process_proxy_debug(indent,
2080 "Start process_proxy_cond_adders at position %d: %s\n",
2083 ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
2090 while (isspace((int)*cond)) {
2103 ok = process_proxy_cond_multipliers(letters,
2104 cond, cond_end, pos,
2115 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2127 process_proxy_debug(indent,
2128 "End process_proxy_cond_adders at position %d: %s, returning %d\n",
2135 static int process_proxy_cond(unsigned int letters[26],
2136 const char *cond, const char **cond_end)
2139 return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
2142 static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2145 struct app_verify_arg *cb_arg = arg;
2146 unsigned int letters[26]; /* only used with proxy_auth */
2148 if (cb_arg->app_verify) {
2149 char *s = NULL, buf[256];
2151 fprintf(stderr, "In app_verify_callback, allowing cert. ");
2152 fprintf(stderr, "Arg is: %s\n", cb_arg->string);
2154 "Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2155 (void *)ctx, (void *)ctx->cert);
2157 s = X509_NAME_oneline(X509_get_subject_name(ctx->cert), buf, 256);
2159 fprintf(stderr, "cert depth=%d %s\n", ctx->error_depth, buf);
2163 if (cb_arg->proxy_auth) {
2164 int found_any = 0, i;
2167 for (i = 0; i < 26; i++)
2169 for (sp = cb_arg->proxy_auth; *sp; sp++) {
2171 if (isascii(c) && isalpha(c)) {
2174 letters[c - 'A'] = 1;
2178 fprintf(stderr, " Initial proxy rights = ");
2179 for (i = 0; i < 26; i++)
2181 fprintf(stderr, "%c", i + 'A');
2185 fprintf(stderr, "none");
2186 fprintf(stderr, "\n");
2188 X509_STORE_CTX_set_ex_data(ctx,
2189 get_proxy_auth_ex_data_idx(), letters);
2191 if (cb_arg->allow_proxy_certs) {
2192 X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
2194 #ifndef OPENSSL_NO_X509_VERIFY
2195 ok = X509_verify_cert(ctx);
2198 if (cb_arg->proxy_auth) {
2200 const char *cond_end = NULL;
2202 ok = process_proxy_cond(letters, cb_arg->proxy_cond, &cond_end);
2208 "Stopped processing condition before it's end.\n");
2213 "Proxy rights check with condition '%s' proved invalid\n",
2214 cb_arg->proxy_cond);
2217 "Proxy rights check with condition '%s' proved valid\n",
2218 cb_arg->proxy_cond);
2224 #ifndef OPENSSL_NO_RSA
2225 static RSA *rsa_tmp = NULL;
2227 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
2230 if (rsa_tmp == NULL) {
2232 rsa_tmp = RSA_new();
2233 if (!bn || !rsa_tmp || !BN_set_word(bn, RSA_F4)) {
2234 BIO_printf(bio_err, "Memory error...");
2237 BIO_printf(bio_err, "Generating temp (%d bit) RSA key...", keylength);
2238 (void)BIO_flush(bio_err);
2239 if (!RSA_generate_key_ex(rsa_tmp, keylength, bn, NULL)) {
2240 BIO_printf(bio_err, "Error generating key.");
2245 BIO_printf(bio_err, "\n");
2246 (void)BIO_flush(bio_err);
2253 static void free_tmp_rsa(void)
2255 if (rsa_tmp != NULL) {
2262 #ifndef OPENSSL_NO_DH
2264 * These DH parameters have been generated as follows:
2265 * $ openssl dhparam -C -noout 512
2266 * $ openssl dhparam -C -noout 1024
2267 * $ openssl dhparam -C -noout -dsaparam 1024
2268 * (The third function has been renamed to avoid name conflicts.)
2270 static DH *get_dh512()
2272 static unsigned char dh512_p[] = {
2273 0xCB, 0xC8, 0xE1, 0x86, 0xD0, 0x1F, 0x94, 0x17, 0xA6, 0x99, 0xF0,
2275 0x1F, 0x0D, 0xAC, 0xB6, 0x25, 0x3E, 0x06, 0x39, 0xCA, 0x72, 0x04,
2277 0x6E, 0xDA, 0xC0, 0x61, 0xE6, 0x7A, 0x77, 0x25, 0xE8, 0x3B, 0xB9,
2279 0x9A, 0xB6, 0xB5, 0xFE, 0x99, 0x0B, 0xA1, 0x93, 0x4E, 0x35, 0x33,
2281 0xE1, 0xF1, 0x13, 0x4F, 0x59, 0x1A, 0xD2, 0x57, 0xC0, 0x26, 0x21,
2283 0x02, 0xC5, 0xAE, 0x23,
2285 static unsigned char dh512_g[] = {
2290 if ((dh = DH_new()) == NULL)
2292 dh->p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
2293 dh->g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
2294 if ((dh->p == NULL) || (dh->g == NULL)) {
2301 static DH *get_dh1024()
2303 static unsigned char dh1024_p[] = {
2304 0xF8, 0x81, 0x89, 0x7D, 0x14, 0x24, 0xC5, 0xD1, 0xE6, 0xF7, 0xBF,
2306 0xE4, 0x90, 0xF4, 0xFC, 0x73, 0xFB, 0x34, 0xB5, 0xFA, 0x4C, 0x56,
2308 0xEA, 0xA7, 0xE9, 0xC0, 0xC0, 0xCE, 0x89, 0xE1, 0xFA, 0x63, 0x3F,
2310 0x6B, 0x32, 0x66, 0xF1, 0xD1, 0x7B, 0xB0, 0x00, 0x8F, 0xCA, 0x87,
2312 0xAE, 0x98, 0x89, 0x26, 0x17, 0xC2, 0x05, 0xD2, 0xEC, 0x08, 0xD0,
2314 0xFF, 0x17, 0x52, 0x8C, 0xC5, 0x07, 0x93, 0x03, 0xB1, 0xF6, 0x2F,
2316 0x1C, 0x52, 0x47, 0x27, 0x1B, 0xDB, 0xD1, 0x8D, 0x9D, 0x69, 0x1D,
2318 0x4B, 0x32, 0x81, 0xAA, 0x7F, 0x00, 0xC8, 0xDC, 0xE6, 0xD9, 0xCC,
2320 0x11, 0x2D, 0x37, 0x34, 0x6C, 0xEA, 0x02, 0x97, 0x4B, 0x0E, 0xBB,
2322 0x71, 0x33, 0x09, 0x15, 0xFD, 0xDD, 0x23, 0x87, 0x07, 0x5E, 0x89,
2324 0x6B, 0x7C, 0x5F, 0xEC, 0xA6, 0x24, 0xDC, 0x53,
2326 static unsigned char dh1024_g[] = {
2331 if ((dh = DH_new()) == NULL)
2333 dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
2334 dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
2335 if ((dh->p == NULL) || (dh->g == NULL)) {
2342 static DH *get_dh1024dsa()
2344 static unsigned char dh1024_p[] = {
2345 0xC8, 0x00, 0xF7, 0x08, 0x07, 0x89, 0x4D, 0x90, 0x53, 0xF3, 0xD5,
2347 0x21, 0x1B, 0xF7, 0x31, 0xA6, 0xA2, 0xDA, 0x23, 0x9A, 0xC7, 0x87,
2349 0x3B, 0x47, 0xB6, 0x8C, 0x04, 0x6F, 0xFF, 0xC6, 0x9B, 0xB8, 0x65,
2351 0xC2, 0x5F, 0x31, 0x83, 0x4A, 0xA7, 0x5F, 0x2F, 0x88, 0x38, 0xB6,
2353 0xCF, 0xD9, 0x87, 0x6D, 0x6F, 0x9F, 0xDA, 0xAC, 0xA6, 0x48, 0xAF,
2355 0x33, 0x84, 0x37, 0x5B, 0x82, 0x4A, 0x31, 0x5D, 0xE7, 0xBD, 0x52,
2357 0xA1, 0x77, 0xBF, 0x10, 0x9E, 0x37, 0xEA, 0x64, 0xFA, 0xCA, 0x28,
2359 0x9D, 0x3B, 0xD2, 0x6E, 0x09, 0x5C, 0x68, 0xC7, 0x45, 0x90, 0xFD,
2361 0x70, 0xC9, 0x3A, 0xBB, 0xDF, 0xD4, 0x21, 0x0F, 0xC4, 0x6A, 0x3C,
2363 0x61, 0xCF, 0x3F, 0xD6, 0x13, 0xF1, 0x5F, 0xBC, 0xCF, 0xBC, 0x26,
2365 0xBC, 0x0B, 0xBD, 0xAB, 0x5D, 0xC9, 0x54, 0x39,
2367 static unsigned char dh1024_g[] = {
2368 0x3B, 0x40, 0x86, 0xE7, 0xF3, 0x6C, 0xDE, 0x67, 0x1C, 0xCC, 0x80,
2370 0x5A, 0xDF, 0xFE, 0xBD, 0x20, 0x27, 0x74, 0x6C, 0x24, 0xC9, 0x03,
2372 0xE1, 0x8D, 0xC3, 0x7D, 0x98, 0x27, 0x40, 0x08, 0xB8, 0x8C, 0x6A,
2374 0xBB, 0x1A, 0x3A, 0xD6, 0x86, 0x83, 0x5E, 0x72, 0x41, 0xCE, 0x85,
2376 0xD2, 0xB3, 0xFC, 0x13, 0xCE, 0x37, 0x81, 0x9E, 0x4C, 0x1C, 0x7B,
2378 0xD3, 0xE6, 0xA6, 0x00, 0xF5, 0x5A, 0x95, 0x43, 0x5E, 0x81, 0xCF,
2380 0xA2, 0x23, 0xFC, 0x36, 0xA7, 0x5D, 0x7A, 0x4C, 0x06, 0x91, 0x6E,
2382 0x57, 0xEE, 0x36, 0xCB, 0x06, 0xEA, 0xF5, 0x3D, 0x95, 0x49, 0xCB,
2384 0xDD, 0x81, 0xDF, 0x80, 0x09, 0x4A, 0x97, 0x4D, 0xA8, 0x22, 0x72,
2386 0x7F, 0xC4, 0x70, 0x56, 0x70, 0xE8, 0x20, 0x10, 0x18, 0x8F, 0x2E,
2388 0x07, 0xE7, 0x68, 0x1A, 0x82, 0x5D, 0x32, 0xA2,
2392 if ((dh = DH_new()) == NULL)
2394 dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
2395 dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
2396 if ((dh->p == NULL) || (dh->g == NULL)) {
2405 #ifndef OPENSSL_NO_PSK
2406 /* convert the PSK key (psk_key) in ascii to binary (psk) */
2407 static int psk_key2bn(const char *pskkey, unsigned char *psk,
2408 unsigned int max_psk_len)
2413 ret = BN_hex2bn(&bn, pskkey);
2415 BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
2421 if (BN_num_bytes(bn) > (int)max_psk_len) {
2423 "psk buffer of callback is too small (%d) for key (%d)\n",
2424 max_psk_len, BN_num_bytes(bn));
2428 ret = BN_bn2bin(bn, psk);
2433 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
2435 unsigned int max_identity_len,
2437 unsigned int max_psk_len)
2440 unsigned int psk_len = 0;
2442 ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
2446 fprintf(stderr, "client: created identity '%s' len=%d\n", identity,
2448 ret = psk_key2bn(psk_key, psk, max_psk_len);
2456 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
2458 unsigned int max_psk_len)
2460 unsigned int psk_len = 0;
2462 if (strcmp(identity, "Client_identity") != 0) {
2463 BIO_printf(bio_err, "server: PSK error: client identity not found\n");
2466 psk_len = psk_key2bn(psk_key, psk, max_psk_len);
2471 static int do_test_cipherlist(void)
2474 const SSL_METHOD *meth;
2475 const SSL_CIPHER *ci, *tci = NULL;
2477 #ifndef OPENSSL_NO_SSL2
2478 fprintf(stderr, "testing SSLv2 cipher list order: ");
2479 meth = SSLv2_method();
2480 while ((ci = meth->get_cipher(i++)) != NULL) {
2482 if (ci->id >= tci->id) {
2483 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
2488 fprintf(stderr, "ok\n");
2490 #ifndef OPENSSL_NO_SSL3
2491 fprintf(stderr, "testing SSLv3 cipher list order: ");
2492 meth = SSLv3_method();
2494 while ((ci = meth->get_cipher(i++)) != NULL) {
2496 if (ci->id >= tci->id) {
2497 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
2502 fprintf(stderr, "ok\n");
2504 #ifndef OPENSSL_NO_TLS1
2505 fprintf(stderr, "testing TLSv1 cipher list order: ");
2506 meth = TLSv1_method();
2508 while ((ci = meth->get_cipher(i++)) != NULL) {
2510 if (ci->id >= tci->id) {
2511 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
2516 fprintf(stderr, "ok\n");