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
157 #ifdef OPENSSL_SYS_VMS
158 /* Or isascii won't be declared properly on VMS (at least with DECompHP C). */
159 #define _XOPEN_SOURCE 500
164 #include <openssl/bio.h>
165 #include <openssl/crypto.h>
166 #include <openssl/evp.h>
167 #include <openssl/x509.h>
168 #include <openssl/x509v3.h>
169 #include <openssl/ssl.h>
170 #ifndef OPENSSL_NO_ENGINE
171 #include <openssl/engine.h>
173 #include <openssl/err.h>
174 #include <openssl/rand.h>
175 #ifndef OPENSSL_NO_RSA
176 #include <openssl/rsa.h>
178 #ifndef OPENSSL_NO_DSA
179 #include <openssl/dsa.h>
181 #ifndef OPENSSL_NO_DH
182 #include <openssl/dh.h>
184 #ifndef OPENSSL_NO_SRP
185 #include <openssl/srp.h>
187 #include <openssl/bn.h>
190 * Or gethostname won't be declared properly
191 * on Compaq platforms (at least with DEC C).
192 * Do not try to put it earlier, or IPv6 includes
195 #define _XOPEN_SOURCE_EXTENDED 1
197 #ifdef OPENSSL_SYS_WINDOWS
200 #include OPENSSL_UNISTD
203 #ifdef OPENSSL_SYS_VMS
204 # define TEST_SERVER_CERT "SYS$DISK:[-.APPS]SERVER.PEM"
205 # define TEST_CLIENT_CERT "SYS$DISK:[-.APPS]CLIENT.PEM"
206 #elif defined(OPENSSL_SYS_WINCE)
207 # define TEST_SERVER_CERT "\\OpenSSL\\server.pem"
208 # define TEST_CLIENT_CERT "\\OpenSSL\\client.pem"
209 #elif defined(OPENSSL_SYS_NETWARE)
210 # define TEST_SERVER_CERT "\\openssl\\apps\\server.pem"
211 # define TEST_CLIENT_CERT "\\openssl\\apps\\client.pem"
213 # define TEST_SERVER_CERT "../apps/server.pem"
214 # define TEST_CLIENT_CERT "../apps/client.pem"
217 /* There is really no standard for this, so let's assign some tentative
218 numbers. In any case, these numbers are only for this test */
222 static int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx);
223 #ifndef OPENSSL_NO_RSA
224 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export,int keylength);
225 static void free_tmp_rsa(void);
227 static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg);
228 #define APP_CALLBACK_STRING "Test Callback Argument"
229 struct app_verify_arg
233 int allow_proxy_certs;
238 #ifndef OPENSSL_NO_DH
239 static DH *get_dh512(void);
240 static DH *get_dh1024(void);
241 static DH *get_dh1024dsa(void);
245 static char *psk_key=NULL; /* by default PSK is not used */
246 #ifndef OPENSSL_NO_PSK
247 static unsigned int psk_client_callback(SSL *ssl, const char *hint, char *identity,
248 unsigned int max_identity_len, unsigned char *psk,
249 unsigned int max_psk_len);
250 static unsigned int psk_server_callback(SSL *ssl, const char *identity, unsigned char *psk,
251 unsigned int max_psk_len);
254 #ifndef OPENSSL_NO_SRP
256 /* This is a context that we pass to all callbacks */
257 typedef struct srp_client_arg_st
263 #define PWD_STRLEN 1024
265 static char * MS_CALLBACK ssl_give_srp_client_pwd_cb(SSL *s, void *arg)
267 SRP_CLIENT_ARG *srp_client_arg = (SRP_CLIENT_ARG *)arg;
268 return BUF_strdup((char *)srp_client_arg->srppassin);
272 /* This is a context that we pass to SRP server callbacks */
273 typedef struct srp_server_arg_st
279 static int MS_CALLBACK ssl_srp_server_param_cb(SSL *s, int *ad, void *arg)
281 SRP_SERVER_ARG * p = (SRP_SERVER_ARG *) arg;
283 if (strcmp(p->expected_user, SSL_get_srp_username(s)) != 0)
285 fprintf(stderr, "User %s doesn't exist\n", SSL_get_srp_username(s));
286 return SSL3_AL_FATAL;
288 if (SSL_set_srp_server_param_pw(s,p->expected_user,p->pass,"1024")<0)
290 *ad = SSL_AD_INTERNAL_ERROR;
291 return SSL3_AL_FATAL;
293 return SSL_ERROR_NONE;
297 static BIO *bio_err=NULL;
298 static BIO *bio_stdout=NULL;
300 static const char *alpn_client;
301 static const char *alpn_server;
302 static const char *alpn_expected;
303 static unsigned char *alpn_selected;
306 * next_protos_parse parses a comma separated list of strings into a string
307 * in a format suitable for passing to SSL_CTX_set_next_protos_advertised.
308 * outlen: (output) set to the length of the resulting buffer on success.
309 * err: (maybe NULL) on failure, an error message line is written to this BIO.
310 * in: a NUL terminated string like "abc,def,ghi"
312 * returns: a malloced buffer or NULL on failure.
314 static unsigned char *next_protos_parse(unsigned short *outlen, const char *in)
324 out = OPENSSL_malloc(strlen(in) + 1);
328 for (i = 0; i <= len; ++i)
330 if (i == len || in[i] == ',')
337 out[start] = i - start;
348 static int cb_server_alpn(SSL *s, const unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg)
350 unsigned char *protos;
351 unsigned short protos_len;
353 protos = next_protos_parse(&protos_len, alpn_server);
356 fprintf(stderr, "failed to parser ALPN server protocol string: %s\n", alpn_server);
360 if (SSL_select_next_proto((unsigned char**) out, outlen, protos, protos_len, in, inlen) !=
361 OPENSSL_NPN_NEGOTIATED)
363 OPENSSL_free(protos);
364 return SSL_TLSEXT_ERR_NOACK;
367 /* Make a copy of the selected protocol which will be freed in verify_alpn. */
368 alpn_selected = OPENSSL_malloc(*outlen);
369 memcpy(alpn_selected, *out, *outlen);
370 *out = alpn_selected;
372 OPENSSL_free(protos);
373 return SSL_TLSEXT_ERR_OK;
376 static int verify_alpn(SSL *client, SSL *server)
378 const unsigned char *client_proto, *server_proto;
379 unsigned int client_proto_len = 0, server_proto_len = 0;
380 SSL_get0_alpn_selected(client, &client_proto, &client_proto_len);
381 SSL_get0_alpn_selected(server, &server_proto, &server_proto_len);
383 if (alpn_selected != NULL)
385 OPENSSL_free(alpn_selected);
386 alpn_selected = NULL;
389 if (client_proto_len != server_proto_len ||
390 memcmp(client_proto, server_proto, client_proto_len) != 0)
392 BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");
396 if (client_proto_len > 0 && alpn_expected == NULL)
398 BIO_printf(bio_stdout, "ALPN unexpectedly negotiated\n");
402 if (alpn_expected != NULL &&
403 (client_proto_len != strlen(alpn_expected) ||
404 memcmp(client_proto, alpn_expected, client_proto_len) != 0))
406 BIO_printf(bio_stdout, "ALPN selected protocols not equal to expected protocol: %s\n", alpn_expected);
413 BIO_printf(bio_stdout, "ALPN results: client: '");
414 BIO_write(bio_stdout, client_proto, client_proto_len);
415 BIO_printf(bio_stdout, "', server: '");
416 BIO_write(bio_stdout, server_proto, server_proto_len);
417 BIO_printf(bio_stdout, "'\n");
418 BIO_printf(bio_stdout, "ALPN configured: client: '%s', server: '%s'\n", alpn_client, alpn_server);
422 #define SCT_EXT_TYPE 18
424 /* WARNING : below extension types are *NOT* IETF assigned, and
425 could conflict if these types are reassigned and handled
426 specially by OpenSSL in the future */
427 #define TACK_EXT_TYPE 62208
428 #define CUSTOM_EXT_TYPE_0 1000
429 #define CUSTOM_EXT_TYPE_1 1001
430 #define CUSTOM_EXT_TYPE_2 1002
431 #define CUSTOM_EXT_TYPE_3 1003
433 const char custom_ext_cli_string[] = "abc";
434 const char custom_ext_srv_string[] = "defg";
436 /* These set from cmdline */
437 char* serverinfo_file = NULL;
438 int serverinfo_sct = 0;
439 int serverinfo_tack = 0;
441 /* These set based on extension callbacks */
442 int serverinfo_sct_seen = 0;
443 int serverinfo_tack_seen = 0;
444 int serverinfo_other_seen = 0;
446 /* This set from cmdline */
449 /* This set based on extension callbacks */
450 int custom_ext_error = 0;
452 static int serverinfo_cli_parse_cb(SSL *s, unsigned int ext_type,
453 const unsigned char *in, size_t inlen,
456 if (ext_type == SCT_EXT_TYPE)
457 serverinfo_sct_seen++;
458 else if (ext_type == TACK_EXT_TYPE)
459 serverinfo_tack_seen++;
461 serverinfo_other_seen++;
465 static int verify_serverinfo()
467 if (serverinfo_sct != serverinfo_sct_seen)
469 if (serverinfo_tack != serverinfo_tack_seen)
471 if (serverinfo_other_seen)
477 * Four test cases for custom extensions:
478 * 0 - no ClientHello extension or ServerHello response
479 * 1 - ClientHello with "abc", no response
480 * 2 - ClientHello with "abc", empty response
481 * 3 - ClientHello with "abc", "defg" response
484 static int custom_ext_0_cli_add_cb(SSL *s, unsigned int ext_type,
485 const unsigned char **out,
486 size_t *outlen, int *al, void *arg)
488 if (ext_type != CUSTOM_EXT_TYPE_0)
489 custom_ext_error = 1;
490 return 0; /* Don't send an extension */
493 static int custom_ext_0_cli_parse_cb(SSL *s, unsigned int ext_type,
494 const unsigned char *in,
495 size_t inlen, int *al,
501 static int custom_ext_1_cli_add_cb(SSL *s, unsigned int ext_type,
502 const unsigned char **out,
503 size_t *outlen, int *al, void *arg)
505 if (ext_type != CUSTOM_EXT_TYPE_1)
506 custom_ext_error = 1;
507 *out = (const unsigned char*)custom_ext_cli_string;
508 *outlen = strlen(custom_ext_cli_string);
509 return 1; /* Send "abc" */
512 static int custom_ext_1_cli_parse_cb(SSL *s, unsigned int ext_type,
513 const unsigned char *in,
514 size_t inlen, int *al,
520 static int custom_ext_2_cli_add_cb(SSL *s, unsigned int ext_type,
521 const unsigned char **out,
522 size_t *outlen, int *al, void *arg)
524 if (ext_type != CUSTOM_EXT_TYPE_2)
525 custom_ext_error = 1;
526 *out = (const unsigned char*)custom_ext_cli_string;
527 *outlen = strlen(custom_ext_cli_string);
528 return 1; /* Send "abc" */
531 static int custom_ext_2_cli_parse_cb(SSL *s, unsigned int ext_type,
532 const unsigned char *in,
533 size_t inlen, int *al,
536 if (ext_type != CUSTOM_EXT_TYPE_2)
537 custom_ext_error = 1;
539 custom_ext_error = 1; /* Should be empty response */
543 static int custom_ext_3_cli_add_cb(SSL *s, unsigned int ext_type,
544 const unsigned char **out,
545 size_t *outlen, int *al, void *arg)
547 if (ext_type != CUSTOM_EXT_TYPE_3)
548 custom_ext_error = 1;
549 *out = (const unsigned char*)custom_ext_cli_string;
550 *outlen = strlen(custom_ext_cli_string);
551 return 1; /* Send "abc" */
554 static int custom_ext_3_cli_parse_cb(SSL *s, unsigned int ext_type,
555 const unsigned char *in,
556 size_t inlen, int *al,
559 if (ext_type != CUSTOM_EXT_TYPE_3)
560 custom_ext_error = 1;
561 if (inlen != strlen(custom_ext_srv_string))
562 custom_ext_error = 1;
563 if (memcmp(custom_ext_srv_string, in, inlen) != 0)
564 custom_ext_error = 1; /* Check for "defg" */
568 /* custom_ext_0_cli_add_cb returns 0 - the server won't receive a callback for this extension */
569 static int custom_ext_0_srv_parse_cb(SSL *s, unsigned int ext_type,
570 const unsigned char *in,
571 size_t inlen, int *al,
574 custom_ext_error = 1;
578 /* 'add' callbacks are only called if the 'parse' callback is called */
579 static int custom_ext_0_srv_add_cb(SSL *s, unsigned int ext_type,
580 const unsigned char **out,
581 size_t *outlen, int *al, void *arg)
583 /* Error: should not have been called */
584 custom_ext_error = 1;
585 return 0; /* Don't send an extension */
588 static int custom_ext_1_srv_parse_cb(SSL *s, unsigned int ext_type,
589 const unsigned char *in,
590 size_t inlen, int *al,
593 if (ext_type != CUSTOM_EXT_TYPE_1)
594 custom_ext_error = 1;
595 /* Check for "abc" */
596 if (inlen != strlen(custom_ext_cli_string))
597 custom_ext_error = 1;
598 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
599 custom_ext_error = 1;
603 static int custom_ext_1_srv_add_cb(SSL *s, unsigned int ext_type,
604 const unsigned char **out,
605 size_t *outlen, int *al, void *arg)
607 return 0; /* Don't send an extension */
610 static int custom_ext_2_srv_parse_cb(SSL *s, unsigned int ext_type,
611 const unsigned char *in,
612 size_t inlen, int *al,
615 if (ext_type != CUSTOM_EXT_TYPE_2)
616 custom_ext_error = 1;
617 /* Check for "abc" */
618 if (inlen != strlen(custom_ext_cli_string))
619 custom_ext_error = 1;
620 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
621 custom_ext_error = 1;
625 static int custom_ext_2_srv_add_cb(SSL *s, unsigned int ext_type,
626 const unsigned char **out,
627 size_t *outlen, int *al, void *arg)
631 return 1; /* Send empty extension */
634 static int custom_ext_3_srv_parse_cb(SSL *s, unsigned int ext_type,
635 const unsigned char *in,
636 size_t inlen, int *al,
639 if (ext_type != CUSTOM_EXT_TYPE_3)
640 custom_ext_error = 1;
641 /* Check for "abc" */
642 if (inlen != strlen(custom_ext_cli_string))
643 custom_ext_error = 1;
644 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
645 custom_ext_error = 1;
649 static int custom_ext_3_srv_add_cb(SSL *s, unsigned int ext_type,
650 const unsigned char **out,
651 size_t *outlen, int *al, void *arg)
653 *out = (const unsigned char*)custom_ext_srv_string;
654 *outlen = strlen(custom_ext_srv_string);
655 return 1; /* Send "defg" */
658 static char *cipher=NULL;
659 static int verbose=0;
668 static const char rnd_seed[] = "string to make the random number generator think it has entropy";
670 int doit_biopair(SSL *s_ssl,SSL *c_ssl,long bytes,clock_t *s_time,clock_t *c_time);
671 int doit(SSL *s_ssl,SSL *c_ssl,long bytes);
672 static int do_test_cipherlist(void);
673 static void sv_usage(void)
675 fprintf(stderr,"usage: ssltest [args ...]\n");
676 fprintf(stderr,"\n");
678 fprintf(stderr,"-F - run test in FIPS mode\n");
680 fprintf(stderr," -server_auth - check server certificate\n");
681 fprintf(stderr," -client_auth - do client authentication\n");
682 fprintf(stderr," -proxy - allow proxy certificates\n");
683 fprintf(stderr," -proxy_auth <val> - set proxy policy rights\n");
684 fprintf(stderr," -proxy_cond <val> - expression to test proxy policy rights\n");
685 fprintf(stderr," -v - more output\n");
686 fprintf(stderr," -d - debug output\n");
687 fprintf(stderr," -reuse - use session-id reuse\n");
688 fprintf(stderr," -num <val> - number of connections to perform\n");
689 fprintf(stderr," -bytes <val> - number of bytes to swap between client/server\n");
690 #ifndef OPENSSL_NO_DH
691 fprintf(stderr," -dhe1024 - use 1024 bit key (safe prime) for DHE\n");
692 fprintf(stderr," -dhe1024dsa - use 1024 bit key (with 160-bit subprime) for DHE\n");
693 fprintf(stderr," -no_dhe - disable DHE\n");
695 #ifndef OPENSSL_NO_ECDH
696 fprintf(stderr," -no_ecdhe - disable ECDHE\n");
698 #ifndef OPENSSL_NO_PSK
699 fprintf(stderr," -psk arg - PSK in hex (without 0x)\n");
701 #ifndef OPENSSL_NO_SRP
702 fprintf(stderr," -srpuser user - SRP username to use\n");
703 fprintf(stderr," -srppass arg - password for 'user'\n");
705 #ifndef OPENSSL_NO_SSL2
706 fprintf(stderr," -ssl2 - use SSLv2\n");
708 #ifndef OPENSSL_NO_SSL3_METHOD
709 fprintf(stderr," -ssl3 - use SSLv3\n");
711 #ifndef OPENSSL_NO_TLS1
712 fprintf(stderr," -tls1 - use TLSv1\n");
714 fprintf(stderr," -CApath arg - PEM format directory of CA's\n");
715 fprintf(stderr," -CAfile arg - PEM format file of CA's\n");
716 fprintf(stderr," -cert arg - Server certificate file\n");
717 fprintf(stderr," -key arg - Server key file (default: same as -cert)\n");
718 fprintf(stderr," -c_cert arg - Client certificate file\n");
719 fprintf(stderr," -c_key arg - Client key file (default: same as -c_cert)\n");
720 fprintf(stderr," -cipher arg - The cipher list\n");
721 fprintf(stderr," -bio_pair - Use BIO pairs\n");
722 fprintf(stderr," -f - Test even cases that can't work\n");
723 fprintf(stderr," -time - measure processor time used by client and server\n");
724 fprintf(stderr," -zlib - use zlib compression\n");
725 fprintf(stderr," -rle - use rle compression\n");
726 #ifndef OPENSSL_NO_ECDH
727 fprintf(stderr," -named_curve arg - Elliptic curve name to use for ephemeral ECDH keys.\n" \
728 " Use \"openssl ecparam -list_curves\" for all names\n" \
729 " (default is sect163r2).\n");
731 fprintf(stderr," -test_cipherlist - Verifies the order of the ssl cipher lists.\n"
732 " When this option is requested, the cipherlist\n"
733 " tests are run instead of handshake tests.\n");
734 fprintf(stderr," -serverinfo_file file - have server use this file\n");
735 fprintf(stderr," -serverinfo_sct - have client offer and expect SCT\n");
736 fprintf(stderr," -serverinfo_tack - have client offer and expect TACK\n");
737 fprintf(stderr," -custom_ext - try various custom extension callbacks\n");
738 fprintf(stderr," -alpn_client <string> - have client side offer ALPN\n");
739 fprintf(stderr," -alpn_server <string> - have server side offer ALPN\n");
740 fprintf(stderr," -alpn_expected <string> - the ALPN protocol that should be negotiated\n");
743 static void print_details(SSL *c_ssl, const char *prefix)
745 const SSL_CIPHER *ciph;
748 ciph=SSL_get_current_cipher(c_ssl);
749 BIO_printf(bio_stdout,"%s%s, cipher %s %s",
751 SSL_get_version(c_ssl),
752 SSL_CIPHER_get_version(ciph),
753 SSL_CIPHER_get_name(ciph));
754 cert=SSL_get_peer_certificate(c_ssl);
757 EVP_PKEY *pkey = X509_get_pubkey(cert);
762 #ifndef OPENSSL_NO_RSA
763 else if (pkey->type == EVP_PKEY_RSA && pkey->pkey.rsa != NULL
764 && pkey->pkey.rsa->n != NULL)
766 BIO_printf(bio_stdout, ", %d bit RSA",
767 BN_num_bits(pkey->pkey.rsa->n));
770 #ifndef OPENSSL_NO_DSA
771 else if (pkey->type == EVP_PKEY_DSA && pkey->pkey.dsa != NULL
772 && pkey->pkey.dsa->p != NULL)
774 BIO_printf(bio_stdout, ", %d bit DSA",
775 BN_num_bits(pkey->pkey.dsa->p));
782 /* The SSL API does not allow us to look at temporary RSA/DH keys,
783 * otherwise we should print their lengths too */
784 BIO_printf(bio_stdout,"\n");
787 static void lock_dbg_cb(int mode, int type, const char *file, int line)
789 static int modes[CRYPTO_NUM_LOCKS]; /* = {0, 0, ... } */
790 const char *errstr = NULL;
793 rw = mode & (CRYPTO_READ|CRYPTO_WRITE);
794 if (!((rw == CRYPTO_READ) || (rw == CRYPTO_WRITE)))
796 errstr = "invalid mode";
800 if (type < 0 || type >= CRYPTO_NUM_LOCKS)
802 errstr = "type out of bounds";
806 if (mode & CRYPTO_LOCK)
810 errstr = "already locked";
811 /* must not happen in a single-threaded program
812 * (would deadlock) */
818 else if (mode & CRYPTO_UNLOCK)
822 errstr = "not locked";
826 if (modes[type] != rw)
828 errstr = (rw == CRYPTO_READ) ?
829 "CRYPTO_r_unlock on write lock" :
830 "CRYPTO_w_unlock on read lock";
837 errstr = "invalid mode";
844 /* we cannot use bio_err here */
845 fprintf(stderr, "openssl (lock_dbg_cb): %s (mode=%d, type=%d) at %s:%d\n",
846 errstr, mode, type, file, line);
850 #ifdef TLSEXT_TYPE_opaque_prf_input
851 struct cb_info_st { void *input; size_t len; int ret; };
852 struct cb_info_st co1 = { "C", 1, 1 }; /* try to negotiate oqaque PRF input */
853 struct cb_info_st co2 = { "C", 1, 2 }; /* insist on oqaque PRF input */
854 struct cb_info_st so1 = { "S", 1, 1 }; /* try to negotiate oqaque PRF input */
855 struct cb_info_st so2 = { "S", 1, 2 }; /* insist on oqaque PRF input */
857 int opaque_prf_input_cb(SSL *ssl, void *peerinput, size_t len, void *arg_)
859 struct cb_info_st *arg = arg_;
864 if (!SSL_set_tlsext_opaque_prf_input(ssl, arg->input, arg->len))
870 int main(int argc, char *argv[])
872 char *CApath=NULL,*CAfile=NULL;
876 int tls1=0,ssl2=0,ssl3=0,ret=1;
879 struct app_verify_arg app_verify_arg =
880 { APP_CALLBACK_STRING, 0, 0, NULL, NULL };
881 char *server_cert=TEST_SERVER_CERT;
882 char *server_key=NULL;
883 char *client_cert=TEST_CLIENT_CERT;
884 char *client_key=NULL;
885 #ifndef OPENSSL_NO_ECDH
886 char *named_curve = NULL;
890 const SSL_METHOD *meth=NULL;
892 int number=1,reuse=0;
894 #ifndef OPENSSL_NO_DH
896 int dhe1024 = 0, dhe1024dsa = 0;
898 #ifndef OPENSSL_NO_ECDH
901 #ifndef OPENSSL_NO_SRP
903 SRP_CLIENT_ARG srp_client_arg = {NULL,NULL};
905 SRP_SERVER_ARG srp_server_arg = {NULL,NULL};
911 clock_t s_time = 0, c_time = 0;
912 #ifndef OPENSSL_NO_COMP
914 COMP_METHOD *cm = NULL;
915 STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
917 int test_cipherlist = 0;
927 bio_err=BIO_new_fp(stderr,BIO_NOCLOSE|BIO_FP_TEXT);
929 CRYPTO_set_locking_callback(lock_dbg_cb);
931 /* enable memory leak checking unless explicitly disabled */
932 if (!((getenv("OPENSSL_DEBUG_MEMORY") != NULL) && (0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off"))))
934 CRYPTO_malloc_debug_init();
935 CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
939 /* OPENSSL_DEBUG_MEMORY=off */
940 CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);
942 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
944 RAND_seed(rnd_seed, sizeof rnd_seed);
946 bio_stdout=BIO_new_fp(stdout,BIO_NOCLOSE|BIO_FP_TEXT);
953 if(!strcmp(*argv,"-F"))
958 fprintf(stderr,"not compiled with FIPS support, so exiting without running.\n");
962 else if (strcmp(*argv,"-server_auth") == 0)
964 else if (strcmp(*argv,"-client_auth") == 0)
966 else if (strcmp(*argv,"-proxy_auth") == 0)
968 if (--argc < 1) goto bad;
969 app_verify_arg.proxy_auth= *(++argv);
971 else if (strcmp(*argv,"-proxy_cond") == 0)
973 if (--argc < 1) goto bad;
974 app_verify_arg.proxy_cond= *(++argv);
976 else if (strcmp(*argv,"-v") == 0)
978 else if (strcmp(*argv,"-d") == 0)
980 else if (strcmp(*argv,"-reuse") == 0)
982 else if (strcmp(*argv,"-dhe1024") == 0)
984 #ifndef OPENSSL_NO_DH
987 fprintf(stderr,"ignoring -dhe1024, since I'm compiled without DH\n");
990 else if (strcmp(*argv,"-dhe1024dsa") == 0)
992 #ifndef OPENSSL_NO_DH
995 fprintf(stderr,"ignoring -dhe1024, since I'm compiled without DH\n");
998 else if (strcmp(*argv,"-no_dhe") == 0)
1000 else if (strcmp(*argv,"-no_ecdhe") == 0)
1002 else if (strcmp(*argv,"-psk") == 0)
1004 if (--argc < 1) goto bad;
1006 #ifndef OPENSSL_NO_PSK
1007 if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key))
1009 BIO_printf(bio_err,"Not a hex number '%s'\n",*argv);
1016 #ifndef OPENSSL_NO_SRP
1017 else if (strcmp(*argv,"-srpuser") == 0)
1019 if (--argc < 1) goto bad;
1020 srp_server_arg.expected_user = srp_client_arg.srplogin= *(++argv);
1023 else if (strcmp(*argv,"-srppass") == 0)
1025 if (--argc < 1) goto bad;
1026 srp_server_arg.pass = srp_client_arg.srppassin= *(++argv);
1030 else if (strcmp(*argv,"-ssl2") == 0)
1032 #ifdef OPENSSL_NO_SSL2
1037 else if (strcmp(*argv,"-tls1") == 0)
1039 #ifdef OPENSSL_NO_TLS1
1044 else if (strcmp(*argv,"-ssl3") == 0)
1046 #ifdef OPENSSL_NO_SSL3_METHOD
1051 else if (strncmp(*argv,"-num",4) == 0)
1053 if (--argc < 1) goto bad;
1054 number= atoi(*(++argv));
1055 if (number == 0) number=1;
1057 else if (strcmp(*argv,"-bytes") == 0)
1059 if (--argc < 1) goto bad;
1060 bytes= atol(*(++argv));
1061 if (bytes == 0L) bytes=1L;
1063 if (argv[0][i-1] == 'k') bytes*=1024L;
1064 if (argv[0][i-1] == 'm') bytes*=1024L*1024L;
1066 else if (strcmp(*argv,"-cert") == 0)
1068 if (--argc < 1) goto bad;
1069 server_cert= *(++argv);
1071 else if (strcmp(*argv,"-s_cert") == 0)
1073 if (--argc < 1) goto bad;
1074 server_cert= *(++argv);
1076 else if (strcmp(*argv,"-key") == 0)
1078 if (--argc < 1) goto bad;
1079 server_key= *(++argv);
1081 else if (strcmp(*argv,"-s_key") == 0)
1083 if (--argc < 1) goto bad;
1084 server_key= *(++argv);
1086 else if (strcmp(*argv,"-c_cert") == 0)
1088 if (--argc < 1) goto bad;
1089 client_cert= *(++argv);
1091 else if (strcmp(*argv,"-c_key") == 0)
1093 if (--argc < 1) goto bad;
1094 client_key= *(++argv);
1096 else if (strcmp(*argv,"-cipher") == 0)
1098 if (--argc < 1) goto bad;
1101 else if (strcmp(*argv,"-CApath") == 0)
1103 if (--argc < 1) goto bad;
1106 else if (strcmp(*argv,"-CAfile") == 0)
1108 if (--argc < 1) goto bad;
1111 else if (strcmp(*argv,"-bio_pair") == 0)
1115 else if (strcmp(*argv,"-f") == 0)
1119 else if (strcmp(*argv,"-time") == 0)
1123 #ifndef OPENSSL_NO_COMP
1124 else if (strcmp(*argv,"-zlib") == 0)
1128 else if (strcmp(*argv,"-rle") == 0)
1133 else if (strcmp(*argv,"-named_curve") == 0)
1135 if (--argc < 1) goto bad;
1136 #ifndef OPENSSL_NO_ECDH
1137 named_curve = *(++argv);
1139 fprintf(stderr,"ignoring -named_curve, since I'm compiled without ECDH\n");
1143 else if (strcmp(*argv,"-app_verify") == 0)
1145 app_verify_arg.app_verify = 1;
1147 else if (strcmp(*argv,"-proxy") == 0)
1149 app_verify_arg.allow_proxy_certs = 1;
1151 else if (strcmp(*argv,"-test_cipherlist") == 0)
1153 test_cipherlist = 1;
1155 else if (strcmp(*argv,"-serverinfo_sct") == 0)
1159 else if (strcmp(*argv,"-serverinfo_tack") == 0)
1161 serverinfo_tack = 1;
1163 else if (strcmp(*argv,"-serverinfo_file") == 0)
1165 if (--argc < 1) goto bad;
1166 serverinfo_file = *(++argv);
1168 else if (strcmp(*argv,"-custom_ext") == 0)
1172 else if (strcmp(*argv,"-alpn_client") == 0)
1174 if (--argc < 1) goto bad;
1175 alpn_client = *(++argv);
1177 else if (strcmp(*argv,"-alpn_server") == 0)
1179 if (--argc < 1) goto bad;
1180 alpn_server = *(++argv);
1182 else if (strcmp(*argv,"-alpn_expected") == 0)
1184 if (--argc < 1) goto bad;
1185 alpn_expected = *(++argv);
1189 fprintf(stderr,"unknown option %s\n",*argv);
1204 * test_cipherlist prevails over protocol switch: we test the cipherlist
1205 * for all enabled protocols.
1207 if (test_cipherlist == 1)
1209 /* ensure that the cipher list are correctly sorted and exit */
1210 fprintf(stdout, "Testing cipherlist order only. Ignoring all "
1211 "other options.\n");
1212 if (do_test_cipherlist() == 0)
1218 if (ssl2 + ssl3 + tls1 > 1)
1220 fprintf(stderr, "At most one of -ssl2, -ssl3, or -tls1 should "
1226 * Testing was requested for a compiled-out protocol (e.g. SSLv2).
1227 * Ideally, we would error out, but the generic test wrapper can't know
1228 * when to expect failure. So we do nothing and return success.
1232 fprintf(stderr, "Testing was requested for a disabled protocol. "
1233 "Skipping tests.\n");
1238 if (!ssl2 && !ssl3 && !tls1 && number > 1 && !reuse && !force)
1240 fprintf(stderr, "This case cannot work. Use -f to perform "
1241 "the test anyway (and\n-d to see what happens), "
1242 "or add one of -ssl2, -ssl3, -tls1, -reuse\n"
1243 "to avoid protocol mismatch.\n");
1250 if(!FIPS_mode_set(1))
1252 ERR_load_crypto_strings();
1253 ERR_print_errors(BIO_new_fp(stderr,BIO_NOCLOSE));
1257 fprintf(stderr,"*** IN FIPS MODE ***\n");
1265 fprintf(stderr, "Using BIO pair (-bio_pair)\n");
1268 if (number < 50 && !force)
1269 fprintf(stderr, "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
1272 /* if (cipher == NULL) cipher=getenv("SSL_CIPHER"); */
1275 SSL_load_error_strings();
1277 #ifndef OPENSSL_NO_COMP
1278 if (comp == COMP_ZLIB) cm = COMP_zlib();
1279 if (comp == COMP_RLE) cm = COMP_rle();
1282 if (cm->type != NID_undef)
1284 if (SSL_COMP_add_compression_method(comp, cm) != 0)
1287 "Failed to add compression method\n");
1288 ERR_print_errors_fp(stderr);
1294 "Warning: %s compression not supported\n",
1295 (comp == COMP_RLE ? "rle" :
1296 (comp == COMP_ZLIB ? "zlib" :
1298 ERR_print_errors_fp(stderr);
1301 ssl_comp_methods = SSL_COMP_get_compression_methods();
1302 fprintf(stderr, "Available compression methods:\n");
1304 int j, n = sk_SSL_COMP_num(ssl_comp_methods);
1306 fprintf(stderr, " NONE\n");
1308 for (j = 0; j < n; j++)
1310 SSL_COMP *c = sk_SSL_COMP_value(ssl_comp_methods, j);
1311 fprintf(stderr, " %d: %s\n", c->id, c->name);
1316 /* At this point, ssl2/ssl3/tls1 is only set if the protocol is available.
1317 * (Otherwise we exit early.)
1318 * However the compiler doesn't know this, so we ifdef. */
1319 #ifndef OPENSSL_NO_SSL2
1321 meth=SSLv2_method();
1324 #ifndef OPENSSL_NO_SSL3
1326 meth=SSLv3_method();
1329 #ifndef OPENSSL_NO_TLS1
1331 meth=TLSv1_method();
1334 meth=SSLv23_method();
1336 c_ctx=SSL_CTX_new(meth);
1337 s_ctx=SSL_CTX_new(meth);
1338 if ((c_ctx == NULL) || (s_ctx == NULL))
1340 ERR_print_errors(bio_err);
1346 SSL_CTX_set_cipher_list(c_ctx,cipher);
1347 SSL_CTX_set_cipher_list(s_ctx,cipher);
1350 #ifndef OPENSSL_NO_DH
1355 /* use SSL_OP_SINGLE_DH_USE to avoid small subgroup attacks */
1356 SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_DH_USE);
1363 SSL_CTX_set_tmp_dh(s_ctx,dh);
1370 #ifndef OPENSSL_NO_ECDH
1375 if (named_curve != NULL)
1377 nid = OBJ_sn2nid(named_curve);
1380 BIO_printf(bio_err, "unknown curve name (%s)\n", named_curve);
1385 #ifdef OPENSSL_NO_EC2M
1386 nid = NID_X9_62_prime256v1;
1388 nid = NID_sect163r2;
1391 ecdh = EC_KEY_new_by_curve_name(nid);
1394 BIO_printf(bio_err, "unable to create curve\n");
1398 SSL_CTX_set_tmp_ecdh(s_ctx, ecdh);
1399 SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_ECDH_USE);
1406 #ifndef OPENSSL_NO_RSA
1407 SSL_CTX_set_tmp_rsa_callback(s_ctx,tmp_rsa_cb);
1410 #ifdef TLSEXT_TYPE_opaque_prf_input
1411 SSL_CTX_set_tlsext_opaque_prf_input_callback(c_ctx, opaque_prf_input_cb);
1412 SSL_CTX_set_tlsext_opaque_prf_input_callback(s_ctx, opaque_prf_input_cb);
1413 SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(c_ctx, &co1); /* or &co2 or NULL */
1414 SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(s_ctx, &so1); /* or &so2 or NULL */
1417 if (!SSL_CTX_use_certificate_file(s_ctx,server_cert,SSL_FILETYPE_PEM))
1419 ERR_print_errors(bio_err);
1421 else if (!SSL_CTX_use_PrivateKey_file(s_ctx,
1422 (server_key?server_key:server_cert), SSL_FILETYPE_PEM))
1424 ERR_print_errors(bio_err);
1430 SSL_CTX_use_certificate_file(c_ctx,client_cert,
1432 SSL_CTX_use_PrivateKey_file(c_ctx,
1433 (client_key?client_key:client_cert),
1437 if ( (!SSL_CTX_load_verify_locations(s_ctx,CAfile,CApath)) ||
1438 (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1439 (!SSL_CTX_load_verify_locations(c_ctx,CAfile,CApath)) ||
1440 (!SSL_CTX_set_default_verify_paths(c_ctx)))
1442 /* fprintf(stderr,"SSL_load_verify_locations\n"); */
1443 ERR_print_errors(bio_err);
1449 BIO_printf(bio_err,"client authentication\n");
1450 SSL_CTX_set_verify(s_ctx,
1451 SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1453 SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback, &app_verify_arg);
1457 BIO_printf(bio_err,"server authentication\n");
1458 SSL_CTX_set_verify(c_ctx,SSL_VERIFY_PEER,
1460 SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback, &app_verify_arg);
1464 int session_id_context = 0;
1465 SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context, sizeof session_id_context);
1468 /* Use PSK only if PSK key is given */
1469 if (psk_key != NULL)
1471 /* no_psk is used to avoid putting psk command to openssl tool */
1474 /* if PSK is not compiled in and psk key is
1475 * given, do nothing and exit successfully */
1479 #ifndef OPENSSL_NO_PSK
1480 SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1481 SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1483 BIO_printf(bio_err,"setting PSK identity hint to s_ctx\n");
1484 if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint"))
1486 BIO_printf(bio_err,"error setting PSK identity hint to s_ctx\n");
1487 ERR_print_errors(bio_err);
1492 #ifndef OPENSSL_NO_SRP
1493 if (srp_client_arg.srplogin)
1495 if (!SSL_CTX_set_srp_username(c_ctx, srp_client_arg.srplogin))
1497 BIO_printf(bio_err,"Unable to set SRP username\n");
1500 SSL_CTX_set_srp_cb_arg(c_ctx,&srp_client_arg);
1501 SSL_CTX_set_srp_client_pwd_callback(c_ctx, ssl_give_srp_client_pwd_cb);
1502 /*SSL_CTX_set_srp_strength(c_ctx, srp_client_arg.strength);*/
1505 if (srp_server_arg.expected_user != NULL)
1507 SSL_CTX_set_verify(s_ctx,SSL_VERIFY_NONE,verify_callback);
1508 SSL_CTX_set_srp_cb_arg(s_ctx, &srp_server_arg);
1509 SSL_CTX_set_srp_username_callback(s_ctx, ssl_srp_server_param_cb);
1514 SSL_CTX_add_client_custom_ext(c_ctx, SCT_EXT_TYPE,
1516 serverinfo_cli_parse_cb, NULL);
1517 if (serverinfo_tack)
1518 SSL_CTX_add_client_custom_ext(c_ctx, TACK_EXT_TYPE,
1520 serverinfo_cli_parse_cb, NULL);
1522 if (serverinfo_file)
1523 if (!SSL_CTX_use_serverinfo_file(s_ctx, serverinfo_file))
1525 BIO_printf(bio_err, "missing serverinfo file\n");
1531 SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_0,
1532 custom_ext_0_cli_add_cb,
1534 custom_ext_0_cli_parse_cb, NULL);
1535 SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_1,
1536 custom_ext_1_cli_add_cb,
1538 custom_ext_1_cli_parse_cb, NULL);
1539 SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_2,
1540 custom_ext_2_cli_add_cb,
1542 custom_ext_2_cli_parse_cb, NULL);
1543 SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_3,
1544 custom_ext_3_cli_add_cb,
1546 custom_ext_3_cli_parse_cb, NULL);
1549 SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_0,
1550 custom_ext_0_srv_add_cb,
1552 custom_ext_0_srv_parse_cb, NULL);
1553 SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_1,
1554 custom_ext_1_srv_add_cb,
1556 custom_ext_1_srv_parse_cb, NULL);
1557 SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_2,
1558 custom_ext_2_srv_add_cb,
1560 custom_ext_2_srv_parse_cb, NULL);
1561 SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_3,
1562 custom_ext_3_srv_add_cb,
1564 custom_ext_3_srv_parse_cb, NULL);
1568 SSL_CTX_set_alpn_select_cb(s_ctx, cb_server_alpn, NULL);
1572 unsigned short alpn_len;
1573 unsigned char *alpn = next_protos_parse(&alpn_len, alpn_client);
1577 BIO_printf(bio_err, "Error parsing -alpn_client argument\n");
1580 SSL_CTX_set_alpn_protos(c_ctx, alpn, alpn_len);
1584 c_ssl=SSL_new(c_ctx);
1585 s_ssl=SSL_new(s_ctx);
1587 #ifndef OPENSSL_NO_KRB5
1588 if (c_ssl && c_ssl->kssl_ctx)
1590 char localhost[MAXHOSTNAMELEN+2];
1592 if (gethostname(localhost, sizeof localhost-1) == 0)
1594 localhost[sizeof localhost-1]='\0';
1595 if(strlen(localhost) == sizeof localhost-1)
1597 BIO_printf(bio_err,"localhost name too long\n");
1600 kssl_ctx_setstring(c_ssl->kssl_ctx, KSSL_SERVER,
1604 #endif /* OPENSSL_NO_KRB5 */
1606 for (i=0; i<number; i++)
1608 if (!reuse) SSL_set_session(c_ssl,NULL);
1610 ret=doit_biopair(s_ssl,c_ssl,bytes,&s_time,&c_time);
1612 ret=doit(s_ssl,c_ssl,bytes);
1617 print_details(c_ssl, "");
1619 if ((number > 1) || (bytes > 1L))
1620 BIO_printf(bio_stdout, "%d handshakes of %ld bytes done\n",number,bytes);
1623 #ifdef CLOCKS_PER_SEC
1624 /* "To determine the time in seconds, the value returned
1625 * by the clock function should be divided by the value
1626 * of the macro CLOCKS_PER_SEC."
1627 * -- ISO/IEC 9899 */
1628 BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1629 "Approximate total client time: %6.2f s\n",
1630 (double)s_time/CLOCKS_PER_SEC,
1631 (double)c_time/CLOCKS_PER_SEC);
1633 /* "`CLOCKS_PER_SEC' undeclared (first use this function)"
1634 * -- cc on NeXTstep/OpenStep */
1635 BIO_printf(bio_stdout,
1636 "Approximate total server time: %6.2f units\n"
1637 "Approximate total client time: %6.2f units\n",
1647 if (s_ctx != NULL) SSL_CTX_free(s_ctx);
1648 if (c_ctx != NULL) SSL_CTX_free(c_ctx);
1650 if (bio_stdout != NULL) BIO_free(bio_stdout);
1652 #ifndef OPENSSL_NO_RSA
1655 #ifndef OPENSSL_NO_ENGINE
1658 CRYPTO_cleanup_all_ex_data();
1660 ERR_remove_thread_state(NULL);
1662 CRYPTO_mem_leaks(bio_err);
1663 if (bio_err != NULL) BIO_free(bio_err);
1668 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
1669 clock_t *s_time, clock_t *c_time)
1671 long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1672 BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1673 BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
1676 size_t bufsiz = 256; /* small buffer for testing */
1678 if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
1680 if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
1683 s_ssl_bio = BIO_new(BIO_f_ssl());
1687 c_ssl_bio = BIO_new(BIO_f_ssl());
1691 SSL_set_connect_state(c_ssl);
1692 SSL_set_bio(c_ssl, client, client);
1693 (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1695 SSL_set_accept_state(s_ssl);
1696 SSL_set_bio(s_ssl, server, server);
1697 (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1702 * c_ssl_bio: SSL filter BIO
1704 * client: pseudo-I/O for SSL library
1706 * client_io: client's SSL communication; usually to be
1707 * relayed over some I/O facility, but in this
1708 * test program, we're the server, too:
1710 * server_io: server's SSL communication
1712 * server: pseudo-I/O for SSL library
1714 * s_ssl_bio: SSL filter BIO
1716 * The client and the server each employ a "BIO pair":
1717 * client + client_io, server + server_io.
1718 * BIO pairs are symmetric. A BIO pair behaves similar
1719 * to a non-blocking socketpair (but both endpoints must
1720 * be handled by the same thread).
1721 * [Here we could connect client and server to the ends
1722 * of a single BIO pair, but then this code would be less
1723 * suitable as an example for BIO pairs in general.]
1725 * Useful functions for querying the state of BIO pair endpoints:
1727 * BIO_ctrl_pending(bio) number of bytes we can read now
1728 * BIO_ctrl_get_read_request(bio) number of bytes needed to fulfil
1729 * other side's read attempt
1730 * BIO_ctrl_get_write_guarantee(bio) number of bytes we can write now
1732 * ..._read_request is never more than ..._write_guarantee;
1733 * it depends on the application which one you should use.
1736 /* We have non-blocking behaviour throughout this test program, but
1737 * can be sure that there is *some* progress in each iteration; so
1738 * we don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE
1739 * -- we just try everything in each iteration
1745 MS_STATIC char cbuf[1024*8];
1747 clock_t c_clock = clock();
1749 memset(cbuf, 0, sizeof(cbuf));
1752 if (SSL_in_init(c_ssl))
1753 printf("client waiting in SSL_connect - %s\n",
1754 SSL_state_string_long(c_ssl));
1758 /* Write to server. */
1760 if (cw_num > (long)sizeof cbuf)
1764 r = BIO_write(c_ssl_bio, cbuf, i);
1767 if (!BIO_should_retry(c_ssl_bio))
1769 fprintf(stderr,"ERROR in CLIENT\n");
1772 /* BIO_should_retry(...) can just be ignored here.
1773 * The library expects us to call BIO_write with
1774 * the same arguments again, and that's what we will
1775 * do in the next iteration. */
1779 fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1785 printf("client wrote %d\n", r);
1792 /* Read from server. */
1794 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1797 if (!BIO_should_retry(c_ssl_bio))
1799 fprintf(stderr,"ERROR in CLIENT\n");
1802 /* Again, "BIO_should_retry" can be ignored. */
1806 fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1812 printf("client read %d\n", r);
1817 /* c_time and s_time increments will typically be very small
1818 * (depending on machine speed and clock tick intervals),
1819 * but sampling over a large number of connections should
1820 * result in fairly accurate figures. We cannot guarantee
1821 * a lot, however -- if each connection lasts for exactly
1822 * one clock tick, it will be counted only for the client
1823 * or only for the server or even not at all.
1825 *c_time += (clock() - c_clock);
1831 MS_STATIC char sbuf[1024*8];
1833 clock_t s_clock = clock();
1835 memset(sbuf, 0, sizeof(sbuf));
1838 if (SSL_in_init(s_ssl))
1839 printf("server waiting in SSL_accept - %s\n",
1840 SSL_state_string_long(s_ssl));
1844 /* Write to client. */
1846 if (sw_num > (long)sizeof sbuf)
1850 r = BIO_write(s_ssl_bio, sbuf, i);
1853 if (!BIO_should_retry(s_ssl_bio))
1855 fprintf(stderr,"ERROR in SERVER\n");
1858 /* Ignore "BIO_should_retry". */
1862 fprintf(stderr,"SSL SERVER STARTUP FAILED\n");
1868 printf("server wrote %d\n", r);
1875 /* Read from client. */
1877 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
1880 if (!BIO_should_retry(s_ssl_bio))
1882 fprintf(stderr,"ERROR in SERVER\n");
1889 fprintf(stderr,"SSL SERVER STARTUP FAILED\n");
1895 printf("server read %d\n", r);
1900 *s_time += (clock() - s_clock);
1904 /* "I/O" BETWEEN CLIENT AND SERVER. */
1907 BIO *io1 = server_io, *io2 = client_io;
1908 /* we use the non-copying interface for io1
1909 * and the standard BIO_write/BIO_read interface for io2
1912 static int prev_progress = 1;
1921 r1 = BIO_ctrl_pending(io1);
1922 r2 = BIO_ctrl_get_write_guarantee(io2);
1931 if (INT_MAX < num) /* yeah, right */
1934 r = BIO_nread(io1, &dataptr, (int)num);
1936 assert(r <= (int)num);
1937 /* possibly r < num (non-contiguous data) */
1939 r = BIO_write(io2, dataptr, (int)num);
1940 if (r != (int)num) /* can't happen */
1942 fprintf(stderr, "ERROR: BIO_write could not write "
1943 "BIO_ctrl_get_write_guarantee() bytes");
1949 printf((io1 == client_io) ?
1950 "C->S relaying: %d bytes\n" :
1951 "S->C relaying: %d bytes\n",
1962 r1 = BIO_ctrl_pending(io2);
1963 r2 = BIO_ctrl_get_read_request(io1);
1964 /* here we could use ..._get_write_guarantee instead of
1965 * ..._get_read_request, but by using the latter
1966 * we test restartability of the SSL implementation
1967 * more thoroughly */
1979 --num; /* test restartability even more thoroughly */
1981 r = BIO_nwrite0(io1, &dataptr);
1985 r = BIO_read(io2, dataptr, (int)num);
1986 if (r != (int)num) /* can't happen */
1988 fprintf(stderr, "ERROR: BIO_read could not read "
1989 "BIO_ctrl_pending() bytes");
1993 r = BIO_nwrite(io1, &dataptr, (int)num);
1994 if (r != (int)num) /* can't happen */
1996 fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
1997 "BIO_nwrite0() bytes");
2002 printf((io2 == client_io) ?
2003 "C->S relaying: %d bytes\n" :
2004 "S->C relaying: %d bytes\n",
2007 } /* no loop, BIO_ctrl_get_read_request now returns 0 anyway */
2009 if (!progress && !prev_progress)
2010 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0)
2012 fprintf(stderr, "ERROR: got stuck\n");
2013 if (strcmp("SSLv2", SSL_get_version(c_ssl)) == 0)
2015 fprintf(stderr, "This can happen for SSL2 because "
2016 "CLIENT-FINISHED and SERVER-VERIFY are written \n"
2017 "concurrently ...");
2018 if (strncmp("2SCF", SSL_state_string(c_ssl), 4) == 0
2019 && strncmp("2SSV", SSL_state_string(s_ssl), 4) == 0)
2021 fprintf(stderr, " ok.\n");
2025 fprintf(stderr, " ERROR.\n");
2028 prev_progress = progress;
2031 while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2034 print_details(c_ssl, "DONE via BIO pair: ");
2036 if (verify_serverinfo() < 0)
2041 if (verify_alpn(c_ssl, s_ssl) < 0)
2047 if (custom_ext_error)
2057 ERR_print_errors(bio_err);
2062 BIO_free(server_io);
2066 BIO_free(client_io);
2068 BIO_free(s_ssl_bio);
2070 BIO_free(c_ssl_bio);
2081 int doit(SSL *s_ssl, SSL *c_ssl, long count)
2083 char *cbuf=NULL,*sbuf=NULL;
2085 long cw_num=count,cr_num=count;
2086 long sw_num=count,sr_num=count;
2092 int c_r,c_w,s_r,s_w;
2095 int c_write,s_write;
2096 int do_server=0,do_client=0;
2097 int max_frag = 5*1024;
2099 bufsiz = count>40*1024 ? 40*1024 : count;
2101 if ((cbuf = OPENSSL_malloc(bufsiz))==NULL) goto err;
2102 if ((sbuf = OPENSSL_malloc(bufsiz))==NULL) goto err;
2104 memset(cbuf,0,bufsiz);
2105 memset(sbuf,0,bufsiz);
2107 c_to_s=BIO_new(BIO_s_mem());
2108 s_to_c=BIO_new(BIO_s_mem());
2109 if ((s_to_c == NULL) || (c_to_s == NULL))
2111 ERR_print_errors(bio_err);
2115 c_bio=BIO_new(BIO_f_ssl());
2116 s_bio=BIO_new(BIO_f_ssl());
2117 if ((c_bio == NULL) || (s_bio == NULL))
2119 ERR_print_errors(bio_err);
2123 SSL_set_connect_state(c_ssl);
2124 SSL_set_bio(c_ssl,s_to_c,c_to_s);
2125 SSL_set_max_send_fragment(c_ssl,max_frag);
2126 BIO_set_ssl(c_bio,c_ssl,BIO_NOCLOSE);
2128 SSL_set_accept_state(s_ssl);
2129 SSL_set_bio(s_ssl,c_to_s,s_to_c);
2130 SSL_set_max_send_fragment(s_ssl,max_frag);
2131 BIO_set_ssl(s_bio,s_ssl,BIO_NOCLOSE);
2135 c_write=1,s_write=0;
2137 /* We can always do writes */
2143 i=(int)BIO_pending(s_bio);
2144 if ((i && s_r) || s_w) do_server=1;
2146 i=(int)BIO_pending(c_bio);
2147 if ((i && c_r) || c_w) do_client=1;
2149 if (do_server && debug)
2151 if (SSL_in_init(s_ssl))
2152 printf("server waiting in SSL_accept - %s\n",
2153 SSL_state_string_long(s_ssl));
2156 printf("server:SSL_write()\n");
2158 printf("server:SSL_read()\n"); */
2161 if (do_client && debug)
2163 if (SSL_in_init(c_ssl))
2164 printf("client waiting in SSL_connect - %s\n",
2165 SSL_state_string_long(c_ssl));
2168 printf("client:SSL_write()\n");
2170 printf("client:SSL_read()\n"); */
2173 if (!do_client && !do_server)
2175 fprintf(stdout,"ERROR IN STARTUP\n");
2176 ERR_print_errors(bio_err);
2179 if (do_client && !(done & C_DONE))
2183 j = (cw_num > bufsiz) ?
2184 (int)bufsiz : (int)cw_num;
2185 i=BIO_write(c_bio,cbuf,j);
2190 if (BIO_should_retry(c_bio))
2192 if (BIO_should_read(c_bio))
2194 if (BIO_should_write(c_bio))
2199 fprintf(stderr,"ERROR in CLIENT\n");
2200 ERR_print_errors(bio_err);
2206 fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
2212 printf("client wrote %d\n",i);
2218 SSL_set_max_send_fragment(c_ssl,max_frag-=5);
2223 i=BIO_read(c_bio,cbuf,bufsiz);
2228 if (BIO_should_retry(c_bio))
2230 if (BIO_should_read(c_bio))
2232 if (BIO_should_write(c_bio))
2237 fprintf(stderr,"ERROR in CLIENT\n");
2238 ERR_print_errors(bio_err);
2244 fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
2250 printf("client read %d\n",i);
2267 if (do_server && !(done & S_DONE))
2271 i=BIO_read(s_bio,sbuf,bufsiz);
2276 if (BIO_should_retry(s_bio))
2278 if (BIO_should_read(s_bio))
2280 if (BIO_should_write(s_bio))
2285 fprintf(stderr,"ERROR in SERVER\n");
2286 ERR_print_errors(bio_err);
2292 ERR_print_errors(bio_err);
2293 fprintf(stderr,"SSL SERVER STARTUP FAILED in SSL_read\n");
2299 printf("server read %d\n",i);
2316 j = (sw_num > bufsiz) ?
2317 (int)bufsiz : (int)sw_num;
2318 i=BIO_write(s_bio,sbuf,j);
2323 if (BIO_should_retry(s_bio))
2325 if (BIO_should_read(s_bio))
2327 if (BIO_should_write(s_bio))
2332 fprintf(stderr,"ERROR in SERVER\n");
2333 ERR_print_errors(bio_err);
2339 ERR_print_errors(bio_err);
2340 fprintf(stderr,"SSL SERVER STARTUP FAILED in SSL_write\n");
2346 printf("server wrote %d\n",i);
2353 SSL_set_max_send_fragment(s_ssl,max_frag-=5);
2358 if ((done & S_DONE) && (done & C_DONE)) break;
2362 print_details(c_ssl, "DONE: ");
2363 if (verify_serverinfo() < 0)
2368 if (custom_ext_error)
2375 /* We have to set the BIO's to NULL otherwise they will be
2376 * OPENSSL_free()ed twice. Once when th s_ssl is SSL_free()ed and
2377 * again when c_ssl is SSL_free()ed.
2378 * This is a hack required because s_ssl and c_ssl are sharing the same
2379 * BIO structure and SSL_set_bio() and SSL_free() automatically
2380 * BIO_free non NULL entries.
2381 * You should not normally do this or be required to do this */
2393 if (c_to_s != NULL) BIO_free(c_to_s);
2394 if (s_to_c != NULL) BIO_free(s_to_c);
2395 if (c_bio != NULL) BIO_free_all(c_bio);
2396 if (s_bio != NULL) BIO_free_all(s_bio);
2398 if (cbuf) OPENSSL_free(cbuf);
2399 if (sbuf) OPENSSL_free(sbuf);
2404 static int get_proxy_auth_ex_data_idx(void)
2406 static volatile int idx = -1;
2409 CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
2412 idx = X509_STORE_CTX_get_ex_new_index(0,
2413 "SSLtest for verify callback", NULL,NULL,NULL);
2415 CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
2420 static int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx)
2424 s=X509_NAME_oneline(X509_get_subject_name(ctx->current_cert),buf,
2429 fprintf(stderr,"depth=%d %s\n",
2430 ctx->error_depth,buf);
2433 fprintf(stderr,"depth=%d error=%d %s\n",
2434 ctx->error_depth,ctx->error,buf);
2440 fprintf(stderr,"Error string: %s\n",
2441 X509_verify_cert_error_string(ctx->error));
2444 case X509_V_ERR_CERT_NOT_YET_VALID:
2445 case X509_V_ERR_CERT_HAS_EXPIRED:
2446 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2447 fprintf(stderr," ... ignored.\n");
2454 X509 *xs = ctx->current_cert;
2456 X509 *xi = ctx->current_issuer;
2459 if (xs->ex_flags & EXFLAG_PROXY)
2461 unsigned int *letters =
2462 X509_STORE_CTX_get_ex_data(ctx,
2463 get_proxy_auth_ex_data_idx());
2469 PROXY_CERT_INFO_EXTENSION *pci =
2470 X509_get_ext_d2i(xs, NID_proxyCertInfo,
2473 switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage))
2475 case NID_Independent:
2476 /* Completely meaningless in this
2477 program, as there's no way to
2478 grant explicit rights to a
2479 specific PrC. Basically, using
2480 id-ppl-Independent is the perfect
2481 way to grant no rights at all. */
2482 fprintf(stderr, " Independent proxy certificate");
2483 for (i = 0; i < 26; i++)
2486 case NID_id_ppl_inheritAll:
2487 /* This is basically a NOP, we
2488 simply let the current rights
2489 stand as they are. */
2490 fprintf(stderr, " Proxy certificate inherits all");
2494 pci->proxyPolicy->policy->data;
2495 i = pci->proxyPolicy->policy->length;
2497 /* The algorithm works as follows:
2498 it is assumed that previous
2499 iterations or the initial granted
2500 rights has already set some elements
2501 of `letters'. What we need to do is
2502 to clear those that weren't granted
2503 by the current PrC as well. The
2504 easiest way to do this is to add 1
2505 to all the elements whose letters
2506 are given with the current policy.
2507 That way, all elements that are set
2508 by the current policy and were
2509 already set by earlier policies and
2510 through the original grant of rights
2511 will get the value 2 or higher.
2512 The last thing to do is to sweep
2513 through `letters' and keep the
2514 elements having the value 2 as set,
2515 and clear all the others. */
2517 fprintf(stderr, " Certificate proxy rights = %*.*s", i, i, s);
2521 if (isascii(c) && isalpha(c))
2528 for (i = 0; i < 26; i++)
2537 ", resulting proxy rights = ");
2538 for(i = 0; i < 26; i++)
2541 fprintf(stderr, "%c", i + 'A');
2545 fprintf(stderr, "none");
2546 fprintf(stderr, "\n");
2548 PROXY_CERT_INFO_EXTENSION_free(pci);
2556 static void process_proxy_debug(int indent, const char *format, ...)
2559 static const char indentation[] =
2560 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
2561 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
2562 char my_format[256];
2565 BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
2566 indent, indent, indentation, format);
2568 va_start(args, format);
2569 vfprintf(stderr, my_format, args);
2578 static int process_proxy_cond_adders(unsigned int letters[26],
2579 const char *cond, const char **cond_end, int *pos, int indent);
2580 static int process_proxy_cond_val(unsigned int letters[26],
2581 const char *cond, const char **cond_end, int *pos, int indent)
2587 while(isspace((int)*cond))
2594 process_proxy_debug(indent,
2595 "Start process_proxy_cond_val at position %d: %s\n",
2602 while(isspace((int)*cond))
2612 ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
2617 while(isspace((int)*cond))
2625 "Weird condition character in position %d: "
2632 else if (isascii(c) && isalpha(c))
2636 ok = letters[c - 'A'];
2642 "Weird condition character in position %d: "
2649 if (ok >= 0 && negate)
2653 process_proxy_debug(indent,
2654 "End process_proxy_cond_val at position %d: %s, returning %d\n",
2659 static int process_proxy_cond_multipliers(unsigned int letters[26],
2660 const char *cond, const char **cond_end, int *pos, int indent)
2666 process_proxy_debug(indent,
2667 "Start process_proxy_cond_multipliers at position %d: %s\n",
2670 ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
2677 while(isspace((int)*cond))
2691 ok = process_proxy_cond_val(letters,
2692 cond, cond_end, pos, indent + 1);
2706 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2718 process_proxy_debug(indent,
2719 "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
2725 static int process_proxy_cond_adders(unsigned int letters[26],
2726 const char *cond, const char **cond_end, int *pos, int indent)
2732 process_proxy_debug(indent,
2733 "Start process_proxy_cond_adders at position %d: %s\n",
2736 ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
2744 while(isspace((int)*cond))
2757 ok = process_proxy_cond_multipliers(letters,
2758 cond, cond_end, pos, indent + 1);
2769 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2781 process_proxy_debug(indent,
2782 "End process_proxy_cond_adders at position %d: %s, returning %d\n",
2789 static int process_proxy_cond(unsigned int letters[26],
2790 const char *cond, const char **cond_end)
2793 return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
2796 static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2799 struct app_verify_arg *cb_arg = arg;
2800 unsigned int letters[26]; /* only used with proxy_auth */
2802 if (cb_arg->app_verify)
2804 char *s = NULL,buf[256];
2806 fprintf(stderr, "In app_verify_callback, allowing cert. ");
2807 fprintf(stderr, "Arg is: %s\n", cb_arg->string);
2808 fprintf(stderr, "Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2809 (void *)ctx, (void *)ctx->cert);
2811 s=X509_NAME_oneline(X509_get_subject_name(ctx->cert),buf,256);
2814 fprintf(stderr,"cert depth=%d %s\n",ctx->error_depth,buf);
2818 if (cb_arg->proxy_auth)
2820 int found_any = 0, i;
2823 for(i = 0; i < 26; i++)
2825 for(sp = cb_arg->proxy_auth; *sp; sp++)
2828 if (isascii(c) && isalpha(c))
2832 letters[c - 'A'] = 1;
2837 " Initial proxy rights = ");
2838 for(i = 0; i < 26; i++)
2841 fprintf(stderr, "%c", i + 'A');
2845 fprintf(stderr, "none");
2846 fprintf(stderr, "\n");
2848 X509_STORE_CTX_set_ex_data(ctx,
2849 get_proxy_auth_ex_data_idx(),letters);
2851 if (cb_arg->allow_proxy_certs)
2853 X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
2856 #ifndef OPENSSL_NO_X509_VERIFY
2857 ok = X509_verify_cert(ctx);
2860 if (cb_arg->proxy_auth)
2864 const char *cond_end = NULL;
2866 ok = process_proxy_cond(letters,
2867 cb_arg->proxy_cond, &cond_end);
2873 fprintf(stderr, "Stopped processing condition before it's end.\n");
2877 fprintf(stderr, "Proxy rights check with condition '%s' proved invalid\n",
2878 cb_arg->proxy_cond);
2880 fprintf(stderr, "Proxy rights check with condition '%s' proved valid\n",
2881 cb_arg->proxy_cond);
2887 #ifndef OPENSSL_NO_RSA
2888 static RSA *rsa_tmp=NULL;
2890 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
2893 if (rsa_tmp == NULL)
2896 rsa_tmp = RSA_new();
2897 if(!bn || !rsa_tmp || !BN_set_word(bn, RSA_F4))
2899 BIO_printf(bio_err, "Memory error...");
2902 BIO_printf(bio_err,"Generating temp (%d bit) RSA key...",keylength);
2903 (void)BIO_flush(bio_err);
2904 if(!RSA_generate_key_ex(rsa_tmp,keylength,bn,NULL))
2906 BIO_printf(bio_err, "Error generating key.");
2911 BIO_printf(bio_err,"\n");
2912 (void)BIO_flush(bio_err);
2918 static void free_tmp_rsa(void)
2920 if (rsa_tmp != NULL)
2928 #ifndef OPENSSL_NO_DH
2930 * These DH parameters have been generated as follows:
2931 * $ openssl dhparam -C -noout 512
2932 * $ openssl dhparam -C -noout 1024
2933 * $ openssl dhparam -C -noout -dsaparam 1024
2934 * (The third function has been renamed to avoid name conflicts.)
2936 static DH *get_dh512()
2938 static unsigned char dh512_p[]={
2939 0xCB,0xC8,0xE1,0x86,0xD0,0x1F,0x94,0x17,0xA6,0x99,0xF0,0xC6,
2940 0x1F,0x0D,0xAC,0xB6,0x25,0x3E,0x06,0x39,0xCA,0x72,0x04,0xB0,
2941 0x6E,0xDA,0xC0,0x61,0xE6,0x7A,0x77,0x25,0xE8,0x3B,0xB9,0x5F,
2942 0x9A,0xB6,0xB5,0xFE,0x99,0x0B,0xA1,0x93,0x4E,0x35,0x33,0xB8,
2943 0xE1,0xF1,0x13,0x4F,0x59,0x1A,0xD2,0x57,0xC0,0x26,0x21,0x33,
2944 0x02,0xC5,0xAE,0x23,
2946 static unsigned char dh512_g[]={
2951 if ((dh=DH_new()) == NULL) return(NULL);
2952 dh->p=BN_bin2bn(dh512_p,sizeof(dh512_p),NULL);
2953 dh->g=BN_bin2bn(dh512_g,sizeof(dh512_g),NULL);
2954 if ((dh->p == NULL) || (dh->g == NULL))
2955 { DH_free(dh); return(NULL); }
2959 static DH *get_dh1024()
2961 static unsigned char dh1024_p[]={
2962 0xF8,0x81,0x89,0x7D,0x14,0x24,0xC5,0xD1,0xE6,0xF7,0xBF,0x3A,
2963 0xE4,0x90,0xF4,0xFC,0x73,0xFB,0x34,0xB5,0xFA,0x4C,0x56,0xA2,
2964 0xEA,0xA7,0xE9,0xC0,0xC0,0xCE,0x89,0xE1,0xFA,0x63,0x3F,0xB0,
2965 0x6B,0x32,0x66,0xF1,0xD1,0x7B,0xB0,0x00,0x8F,0xCA,0x87,0xC2,
2966 0xAE,0x98,0x89,0x26,0x17,0xC2,0x05,0xD2,0xEC,0x08,0xD0,0x8C,
2967 0xFF,0x17,0x52,0x8C,0xC5,0x07,0x93,0x03,0xB1,0xF6,0x2F,0xB8,
2968 0x1C,0x52,0x47,0x27,0x1B,0xDB,0xD1,0x8D,0x9D,0x69,0x1D,0x52,
2969 0x4B,0x32,0x81,0xAA,0x7F,0x00,0xC8,0xDC,0xE6,0xD9,0xCC,0xC1,
2970 0x11,0x2D,0x37,0x34,0x6C,0xEA,0x02,0x97,0x4B,0x0E,0xBB,0xB1,
2971 0x71,0x33,0x09,0x15,0xFD,0xDD,0x23,0x87,0x07,0x5E,0x89,0xAB,
2972 0x6B,0x7C,0x5F,0xEC,0xA6,0x24,0xDC,0x53,
2974 static unsigned char dh1024_g[]={
2979 if ((dh=DH_new()) == NULL) return(NULL);
2980 dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
2981 dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
2982 if ((dh->p == NULL) || (dh->g == NULL))
2983 { DH_free(dh); return(NULL); }
2987 static DH *get_dh1024dsa()
2989 static unsigned char dh1024_p[]={
2990 0xC8,0x00,0xF7,0x08,0x07,0x89,0x4D,0x90,0x53,0xF3,0xD5,0x00,
2991 0x21,0x1B,0xF7,0x31,0xA6,0xA2,0xDA,0x23,0x9A,0xC7,0x87,0x19,
2992 0x3B,0x47,0xB6,0x8C,0x04,0x6F,0xFF,0xC6,0x9B,0xB8,0x65,0xD2,
2993 0xC2,0x5F,0x31,0x83,0x4A,0xA7,0x5F,0x2F,0x88,0x38,0xB6,0x55,
2994 0xCF,0xD9,0x87,0x6D,0x6F,0x9F,0xDA,0xAC,0xA6,0x48,0xAF,0xFC,
2995 0x33,0x84,0x37,0x5B,0x82,0x4A,0x31,0x5D,0xE7,0xBD,0x52,0x97,
2996 0xA1,0x77,0xBF,0x10,0x9E,0x37,0xEA,0x64,0xFA,0xCA,0x28,0x8D,
2997 0x9D,0x3B,0xD2,0x6E,0x09,0x5C,0x68,0xC7,0x45,0x90,0xFD,0xBB,
2998 0x70,0xC9,0x3A,0xBB,0xDF,0xD4,0x21,0x0F,0xC4,0x6A,0x3C,0xF6,
2999 0x61,0xCF,0x3F,0xD6,0x13,0xF1,0x5F,0xBC,0xCF,0xBC,0x26,0x9E,
3000 0xBC,0x0B,0xBD,0xAB,0x5D,0xC9,0x54,0x39,
3002 static unsigned char dh1024_g[]={
3003 0x3B,0x40,0x86,0xE7,0xF3,0x6C,0xDE,0x67,0x1C,0xCC,0x80,0x05,
3004 0x5A,0xDF,0xFE,0xBD,0x20,0x27,0x74,0x6C,0x24,0xC9,0x03,0xF3,
3005 0xE1,0x8D,0xC3,0x7D,0x98,0x27,0x40,0x08,0xB8,0x8C,0x6A,0xE9,
3006 0xBB,0x1A,0x3A,0xD6,0x86,0x83,0x5E,0x72,0x41,0xCE,0x85,0x3C,
3007 0xD2,0xB3,0xFC,0x13,0xCE,0x37,0x81,0x9E,0x4C,0x1C,0x7B,0x65,
3008 0xD3,0xE6,0xA6,0x00,0xF5,0x5A,0x95,0x43,0x5E,0x81,0xCF,0x60,
3009 0xA2,0x23,0xFC,0x36,0xA7,0x5D,0x7A,0x4C,0x06,0x91,0x6E,0xF6,
3010 0x57,0xEE,0x36,0xCB,0x06,0xEA,0xF5,0x3D,0x95,0x49,0xCB,0xA7,
3011 0xDD,0x81,0xDF,0x80,0x09,0x4A,0x97,0x4D,0xA8,0x22,0x72,0xA1,
3012 0x7F,0xC4,0x70,0x56,0x70,0xE8,0x20,0x10,0x18,0x8F,0x2E,0x60,
3013 0x07,0xE7,0x68,0x1A,0x82,0x5D,0x32,0xA2,
3017 if ((dh=DH_new()) == NULL) return(NULL);
3018 dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
3019 dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
3020 if ((dh->p == NULL) || (dh->g == NULL))
3021 { DH_free(dh); return(NULL); }
3027 #ifndef OPENSSL_NO_PSK
3028 /* convert the PSK key (psk_key) in ascii to binary (psk) */
3029 static int psk_key2bn(const char *pskkey, unsigned char *psk,
3030 unsigned int max_psk_len)
3035 ret = BN_hex2bn(&bn, pskkey);
3038 BIO_printf(bio_err,"Could not convert PSK key '%s' to BIGNUM\n", pskkey);
3043 if (BN_num_bytes(bn) > (int)max_psk_len)
3045 BIO_printf(bio_err,"psk buffer of callback is too small (%d) for key (%d)\n",
3046 max_psk_len, BN_num_bytes(bn));
3050 ret = BN_bn2bin(bn, psk);
3055 static unsigned int psk_client_callback(SSL *ssl, const char *hint, char *identity,
3056 unsigned int max_identity_len, unsigned char *psk,
3057 unsigned int max_psk_len)
3060 unsigned int psk_len = 0;
3062 ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3066 fprintf(stderr, "client: created identity '%s' len=%d\n", identity, ret);
3067 ret = psk_key2bn(psk_key, psk, max_psk_len);
3075 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3076 unsigned char *psk, unsigned int max_psk_len)
3078 unsigned int psk_len=0;
3080 if (strcmp(identity, "Client_identity") != 0)
3082 BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3085 psk_len=psk_key2bn(psk_key, psk, max_psk_len);
3090 static int do_test_cipherlist(void)
3093 const SSL_METHOD *meth;
3094 const SSL_CIPHER *ci, *tci = NULL;
3096 #ifndef OPENSSL_NO_SSL2
3097 fprintf(stderr, "testing SSLv2 cipher list order: ");
3098 meth = SSLv2_method();
3099 while ((ci = meth->get_cipher(i++)) != NULL)
3102 if (ci->id >= tci->id)
3104 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3109 fprintf(stderr, "ok\n");
3111 #ifndef OPENSSL_NO_SSL3
3112 fprintf(stderr, "testing SSLv3 cipher list order: ");
3113 meth = SSLv3_method();
3115 while ((ci = meth->get_cipher(i++)) != NULL)
3118 if (ci->id >= tci->id)
3120 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3125 fprintf(stderr, "ok\n");
3127 #ifndef OPENSSL_NO_TLS1
3128 fprintf(stderr, "testing TLSv1 cipher list order: ");
3129 meth = TLSv1_method();
3131 while ((ci = meth->get_cipher(i++)) != NULL)
3134 if (ci->id >= tci->id)
3136 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3141 fprintf(stderr, "ok\n");