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 #define _BSD_SOURCE 1 /* Or gethostname won't be declared properly
144 on Linux and GNU platforms. */
157 #ifdef OPENSSL_SYS_VMS
158 #define _XOPEN_SOURCE 500 /* Or isascii won't be declared properly on
159 VMS (at least with DECompHP C). */
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>
189 #define _XOPEN_SOURCE_EXTENDED 1 /* Or gethostname won't be declared properly
190 on Compaq platforms (at least with DEC C).
191 Do not try to put it earlier, or IPv6 includes
195 #ifdef OPENSSL_SYS_WINDOWS
198 #include OPENSSL_UNISTD
201 #ifdef OPENSSL_SYS_VMS
202 # define TEST_SERVER_CERT "SYS$DISK:[-.APPS]SERVER.PEM"
203 # define TEST_CLIENT_CERT "SYS$DISK:[-.APPS]CLIENT.PEM"
204 #elif defined(OPENSSL_SYS_WINCE)
205 # define TEST_SERVER_CERT "\\OpenSSL\\server.pem"
206 # define TEST_CLIENT_CERT "\\OpenSSL\\client.pem"
207 #elif defined(OPENSSL_SYS_NETWARE)
208 # define TEST_SERVER_CERT "\\openssl\\apps\\server.pem"
209 # define TEST_CLIENT_CERT "\\openssl\\apps\\client.pem"
211 # define TEST_SERVER_CERT "../apps/server.pem"
212 # define TEST_CLIENT_CERT "../apps/client.pem"
215 /* There is really no standard for this, so let's assign some tentative
216 numbers. In any case, these numbers are only for this test */
220 static int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx);
221 #ifndef OPENSSL_NO_RSA
222 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export,int keylength);
223 static void free_tmp_rsa(void);
225 static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg);
226 #define APP_CALLBACK_STRING "Test Callback Argument"
227 struct app_verify_arg
231 int allow_proxy_certs;
236 #ifndef OPENSSL_NO_DH
237 static DH *get_dh512(void);
238 static DH *get_dh1024(void);
239 static DH *get_dh1024dsa(void);
243 static char *psk_key=NULL; /* by default PSK is not used */
244 #ifndef OPENSSL_NO_PSK
245 static unsigned int psk_client_callback(SSL *ssl, const char *hint, char *identity,
246 unsigned int max_identity_len, unsigned char *psk,
247 unsigned int max_psk_len);
248 static unsigned int psk_server_callback(SSL *ssl, const char *identity, unsigned char *psk,
249 unsigned int max_psk_len);
252 #ifndef OPENSSL_NO_SRP
254 /* This is a context that we pass to all callbacks */
255 typedef struct srp_client_arg_st
261 #define PWD_STRLEN 1024
263 static char * MS_CALLBACK ssl_give_srp_client_pwd_cb(SSL *s, void *arg)
265 SRP_CLIENT_ARG *srp_client_arg = (SRP_CLIENT_ARG *)arg;
266 return BUF_strdup((char *)srp_client_arg->srppassin);
270 /* This is a context that we pass to SRP server callbacks */
271 typedef struct srp_server_arg_st
277 static int MS_CALLBACK ssl_srp_server_param_cb(SSL *s, int *ad, void *arg)
279 SRP_SERVER_ARG * p = (SRP_SERVER_ARG *) arg;
281 if (strcmp(p->expected_user, SSL_get_srp_username(s)) != 0)
283 fprintf(stderr, "User %s doesn't exist\n", SSL_get_srp_username(s));
284 return SSL3_AL_FATAL;
286 if (SSL_set_srp_server_param_pw(s,p->expected_user,p->pass,"1024")<0)
288 *ad = SSL_AD_INTERNAL_ERROR;
289 return SSL3_AL_FATAL;
291 return SSL_ERROR_NONE;
295 static BIO *bio_err=NULL;
296 static BIO *bio_stdout=NULL;
298 static const char *alpn_client;
299 static const char *alpn_server;
300 static const char *alpn_expected;
301 static unsigned char *alpn_selected;
303 /* next_protos_parse parses a comma separated list of strings into a string
304 * in a format suitable for passing to SSL_CTX_set_next_protos_advertised.
305 * outlen: (output) set to the length of the resulting buffer on success.
306 * err: (maybe NULL) on failure, an error message line is written to this BIO.
307 * in: a NUL termianted string like "abc,def,ghi"
309 * returns: a malloced buffer or NULL on failure.
311 static unsigned char *next_protos_parse(unsigned short *outlen, const char *in)
321 out = OPENSSL_malloc(strlen(in) + 1);
325 for (i = 0; i <= len; ++i)
327 if (i == len || in[i] == ',')
334 out[start] = i - start;
345 static int cb_server_alpn(SSL *s, const unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg)
347 unsigned char *protos;
348 unsigned short protos_len;
350 protos = next_protos_parse(&protos_len, alpn_server);
353 fprintf(stderr, "failed to parser ALPN server protocol string: %s\n", alpn_server);
357 if (SSL_select_next_proto((unsigned char**) out, outlen, protos, protos_len, in, inlen) !=
358 OPENSSL_NPN_NEGOTIATED)
360 OPENSSL_free(protos);
361 return SSL_TLSEXT_ERR_NOACK;
364 /* Make a copy of the selected protocol which will be freed in verify_alpn. */
365 alpn_selected = OPENSSL_malloc(*outlen);
366 memcpy(alpn_selected, *out, *outlen);
367 *out = alpn_selected;
369 OPENSSL_free(protos);
370 return SSL_TLSEXT_ERR_OK;
373 static int verify_alpn(SSL *client, SSL *server)
375 const unsigned char *client_proto, *server_proto;
376 unsigned int client_proto_len = 0, server_proto_len = 0;
377 SSL_get0_alpn_selected(client, &client_proto, &client_proto_len);
378 SSL_get0_alpn_selected(server, &server_proto, &server_proto_len);
380 if (alpn_selected != NULL)
382 OPENSSL_free(alpn_selected);
383 alpn_selected = NULL;
386 if (client_proto_len != server_proto_len ||
387 memcmp(client_proto, server_proto, client_proto_len) != 0)
389 BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");
393 if (client_proto_len > 0 && alpn_expected == NULL)
395 BIO_printf(bio_stdout, "ALPN unexpectedly negotiated\n");
399 if (alpn_expected != NULL &&
400 (client_proto_len != strlen(alpn_expected) ||
401 memcmp(client_proto, alpn_expected, client_proto_len) != 0))
403 BIO_printf(bio_stdout, "ALPN selected protocols not equal to expected protocol: %s\n", alpn_expected);
410 BIO_printf(bio_stdout, "ALPN results: client: '");
411 BIO_write(bio_stdout, client_proto, client_proto_len);
412 BIO_printf(bio_stdout, "', server: '");
413 BIO_write(bio_stdout, server_proto, server_proto_len);
414 BIO_printf(bio_stdout, "'\n");
415 BIO_printf(bio_stdout, "ALPN configured: client: '%s', server: '%s'\n", alpn_client, alpn_server);
419 #define SCT_EXT_TYPE 18
421 /* WARNING : below extension types are *NOT* IETF assigned, and
422 could conflict if these types are reassigned and handled
423 specially by OpenSSL in the future */
424 #define TACK_EXT_TYPE 62208
425 #define CUSTOM_EXT_TYPE_0 1000
426 #define CUSTOM_EXT_TYPE_1 1001
427 #define CUSTOM_EXT_TYPE_2 1002
428 #define CUSTOM_EXT_TYPE_3 1003
430 const char custom_ext_cli_string[] = "abc";
431 const char custom_ext_srv_string[] = "defg";
433 /* These set from cmdline */
434 char* serverinfo_file = NULL;
435 int serverinfo_sct = 0;
436 int serverinfo_tack = 0;
438 /* These set based on extension callbacks */
439 int serverinfo_sct_seen = 0;
440 int serverinfo_tack_seen = 0;
441 int serverinfo_other_seen = 0;
443 /* This set from cmdline */
446 /* This set based on extension callbacks */
447 int custom_ext_error = 0;
449 static int serverinfo_cli_cb(SSL* s, unsigned short ext_type,
450 const unsigned char* in, unsigned short inlen,
453 if (ext_type == SCT_EXT_TYPE)
454 serverinfo_sct_seen++;
455 else if (ext_type == TACK_EXT_TYPE)
456 serverinfo_tack_seen++;
458 serverinfo_other_seen++;
462 static int verify_serverinfo()
464 if (serverinfo_sct != serverinfo_sct_seen)
466 if (serverinfo_tack != serverinfo_tack_seen)
468 if (serverinfo_other_seen)
473 /* Four test cases for custom extensions:
474 * 0 - no ClientHello extension or ServerHello response
475 * 1 - ClientHello with "abc", no response
476 * 2 - ClientHello with "abc", empty response
477 * 3 - ClientHello with "abc", "defg" response
480 static int custom_ext_0_cli_first_cb(SSL *s, unsigned short ext_type,
481 const unsigned char **out,
482 unsigned short *outlen, void *arg)
484 if (ext_type != CUSTOM_EXT_TYPE_0)
485 custom_ext_error = 1;
486 return -1; /* Don't send an extension */
489 static int custom_ext_0_cli_second_cb(SSL *s, unsigned short ext_type,
490 const unsigned char *in,
491 unsigned short inlen, int *al,
494 custom_ext_error = 1; /* Shouldn't be called */
498 static int custom_ext_1_cli_first_cb(SSL *s, unsigned short ext_type,
499 const unsigned char **out,
500 unsigned short *outlen, void *arg)
502 if (ext_type != CUSTOM_EXT_TYPE_1)
503 custom_ext_error = 1;
504 *out = (const unsigned char*)custom_ext_cli_string;
505 *outlen = strlen(custom_ext_cli_string);
506 return 1; /* Send "abc" */
509 static int custom_ext_1_cli_second_cb(SSL *s, unsigned short ext_type,
510 const unsigned char *in,
511 unsigned short inlen, int *al,
514 custom_ext_error = 1; /* Shouldn't be called */
518 static int custom_ext_2_cli_first_cb(SSL *s, unsigned short ext_type,
519 const unsigned char **out,
520 unsigned short *outlen, void *arg)
522 if (ext_type != CUSTOM_EXT_TYPE_2)
523 custom_ext_error = 1;
524 *out = (const unsigned char*)custom_ext_cli_string;
525 *outlen = strlen(custom_ext_cli_string);
526 return 1; /* Send "abc" */
529 static int custom_ext_2_cli_second_cb(SSL *s, unsigned short ext_type,
530 const unsigned char *in,
531 unsigned short inlen, int *al,
534 if (ext_type != CUSTOM_EXT_TYPE_2)
535 custom_ext_error = 1;
537 custom_ext_error = 1; /* Should be empty response */
541 static int custom_ext_3_cli_first_cb(SSL *s, unsigned short ext_type,
542 const unsigned char **out,
543 unsigned short *outlen, void *arg)
545 if (ext_type != CUSTOM_EXT_TYPE_3)
546 custom_ext_error = 1;
547 *out = (const unsigned char*)custom_ext_cli_string;
548 *outlen = strlen(custom_ext_cli_string);
549 return 1; /* Send "abc" */
552 static int custom_ext_3_cli_second_cb(SSL *s, unsigned short ext_type,
553 const unsigned char *in,
554 unsigned short inlen, int *al,
557 if (ext_type != CUSTOM_EXT_TYPE_3)
558 custom_ext_error = 1;
559 if (inlen != strlen(custom_ext_srv_string))
560 custom_ext_error = 1;
561 if (memcmp(custom_ext_srv_string, in, inlen) != 0)
562 custom_ext_error = 1; /* Check for "defg" */
567 static int custom_ext_0_srv_first_cb(SSL *s, unsigned short ext_type,
568 const unsigned char *in,
569 unsigned short inlen, int *al,
572 custom_ext_error = 1;
573 return 0; /* Shouldn't be called */
576 static int custom_ext_0_srv_second_cb(SSL *s, unsigned short ext_type,
577 const unsigned char **out,
578 unsigned short *outlen, void *arg)
580 custom_ext_error = 1;
581 return 0; /* Shouldn't be called */
584 static int custom_ext_1_srv_first_cb(SSL *s, unsigned short ext_type,
585 const unsigned char *in,
586 unsigned short inlen, int *al,
589 if (ext_type != CUSTOM_EXT_TYPE_1)
590 custom_ext_error = 1;
591 /* Check for "abc" */
592 if (inlen != strlen(custom_ext_cli_string))
593 custom_ext_error = 1;
594 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
595 custom_ext_error = 1;
599 static int custom_ext_1_srv_second_cb(SSL *s, unsigned short ext_type,
600 const unsigned char **out,
601 unsigned short *outlen, void *arg)
603 return -1; /* Don't send an extension */
606 static int custom_ext_2_srv_first_cb(SSL *s, unsigned short ext_type,
607 const unsigned char *in,
608 unsigned short inlen, int *al,
611 if (ext_type != CUSTOM_EXT_TYPE_2)
612 custom_ext_error = 1;
613 /* Check for "abc" */
614 if (inlen != strlen(custom_ext_cli_string))
615 custom_ext_error = 1;
616 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
617 custom_ext_error = 1;
621 static int custom_ext_2_srv_second_cb(SSL *s, unsigned short ext_type,
622 const unsigned char **out,
623 unsigned short *outlen, void *arg)
627 return 1; /* Send empty extension */
630 static int custom_ext_3_srv_first_cb(SSL *s, unsigned short ext_type,
631 const unsigned char *in,
632 unsigned short inlen, int *al,
635 if (ext_type != CUSTOM_EXT_TYPE_3)
636 custom_ext_error = 1;
637 /* Check for "abc" */
638 if (inlen != strlen(custom_ext_cli_string))
639 custom_ext_error = 1;
640 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
641 custom_ext_error = 1;
645 static int custom_ext_3_srv_second_cb(SSL *s, unsigned short ext_type,
646 const unsigned char **out,
647 unsigned short *outlen, void *arg)
649 *out = (const unsigned char*)custom_ext_srv_string;
650 *outlen = strlen(custom_ext_srv_string);
651 return 1; /* Send "defg" */
655 static char *cipher=NULL;
656 static int verbose=0;
665 static const char rnd_seed[] = "string to make the random number generator think it has entropy";
667 int doit_biopair(SSL *s_ssl,SSL *c_ssl,long bytes,clock_t *s_time,clock_t *c_time);
668 int doit(SSL *s_ssl,SSL *c_ssl,long bytes);
669 static int do_test_cipherlist(void);
670 static void sv_usage(void)
672 fprintf(stderr,"usage: ssltest [args ...]\n");
673 fprintf(stderr,"\n");
675 fprintf(stderr,"-F - run test in FIPS mode\n");
677 fprintf(stderr," -server_auth - check server certificate\n");
678 fprintf(stderr," -client_auth - do client authentication\n");
679 fprintf(stderr," -proxy - allow proxy certificates\n");
680 fprintf(stderr," -proxy_auth <val> - set proxy policy rights\n");
681 fprintf(stderr," -proxy_cond <val> - experssion to test proxy policy rights\n");
682 fprintf(stderr," -v - more output\n");
683 fprintf(stderr," -d - debug output\n");
684 fprintf(stderr," -reuse - use session-id reuse\n");
685 fprintf(stderr," -num <val> - number of connections to perform\n");
686 fprintf(stderr," -bytes <val> - number of bytes to swap between client/server\n");
687 #ifndef OPENSSL_NO_DH
688 fprintf(stderr," -dhe1024 - use 1024 bit key (safe prime) for DHE\n");
689 fprintf(stderr," -dhe1024dsa - use 1024 bit key (with 160-bit subprime) for DHE\n");
690 fprintf(stderr," -no_dhe - disable DHE\n");
692 #ifndef OPENSSL_NO_ECDH
693 fprintf(stderr," -no_ecdhe - disable ECDHE\n");
695 #ifndef OPENSSL_NO_PSK
696 fprintf(stderr," -psk arg - PSK in hex (without 0x)\n");
698 #ifndef OPENSSL_NO_SRP
699 fprintf(stderr," -srpuser user - SRP username to use\n");
700 fprintf(stderr," -srppass arg - password for 'user'\n");
702 #ifndef OPENSSL_NO_SSL2
703 fprintf(stderr," -ssl2 - use SSLv2\n");
705 #ifndef OPENSSL_NO_SSL3
706 fprintf(stderr," -ssl3 - use SSLv3\n");
708 #ifndef OPENSSL_NO_TLS1
709 fprintf(stderr," -tls1 - use TLSv1\n");
711 fprintf(stderr," -CApath arg - PEM format directory of CA's\n");
712 fprintf(stderr," -CAfile arg - PEM format file of CA's\n");
713 fprintf(stderr," -cert arg - Server certificate file\n");
714 fprintf(stderr," -key arg - Server key file (default: same as -cert)\n");
715 fprintf(stderr," -c_cert arg - Client certificate file\n");
716 fprintf(stderr," -c_key arg - Client key file (default: same as -c_cert)\n");
717 fprintf(stderr," -cipher arg - The cipher list\n");
718 fprintf(stderr," -bio_pair - Use BIO pairs\n");
719 fprintf(stderr," -f - Test even cases that can't work\n");
720 fprintf(stderr," -time - measure processor time used by client and server\n");
721 fprintf(stderr," -zlib - use zlib compression\n");
722 fprintf(stderr," -rle - use rle compression\n");
723 #ifndef OPENSSL_NO_ECDH
724 fprintf(stderr," -named_curve arg - Elliptic curve name to use for ephemeral ECDH keys.\n" \
725 " Use \"openssl ecparam -list_curves\" for all names\n" \
726 " (default is sect163r2).\n");
728 fprintf(stderr," -test_cipherlist - verifies the order of the ssl cipher lists\n");
729 #ifndef OPENSSL_NO_TLSEXT
730 fprintf(stderr," -server_authz arg - binary authz file for certificate\n");
731 fprintf(stderr," -c_support_proof - indicate client support for server_authz audit proofs\n");
732 fprintf(stderr," -c_require_proof - fail if no audit proof is sent\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 #ifndef OPENSSL_NO_TLSEXT
871 struct audit_proof_cb_arg_st
873 unsigned char *expected_proof;
874 size_t expected_proof_length;
878 struct audit_proof_cb_arg_st c_expected = { NULL, 0, 0 };
880 static int audit_proof_cb(SSL *s, void *arg)
882 const unsigned char *proof;
884 SSL_SESSION *sess = SSL_get_session(s);
885 struct audit_proof_cb_arg_st *cb_arg = (struct audit_proof_cb_arg_st*)arg;
887 proof = SSL_SESSION_get_tlsext_authz_server_audit_proof(sess,
891 if (proof_len == cb_arg->expected_proof_length &&
892 cb_arg->expected_proof != NULL &&
893 memcmp(proof, cb_arg->expected_proof, proof_len) == 0)
895 BIO_printf(bio_stdout, "Audit proof OK (%lu bytes).\n",
901 BIO_printf(bio_stdout, "Audit proof mismatch.\n");
902 /* Cause handshake failure. */
907 else /* proof == NULL */
909 BIO_printf(bio_stdout, "No audit proof found.\n");
912 /* Cause handshake failure. */
920 int main(int argc, char *argv[])
922 char *CApath=NULL,*CAfile=NULL;
926 int tls1=0,ssl2=0,ssl3=0,ret=1;
929 struct app_verify_arg app_verify_arg =
930 { APP_CALLBACK_STRING, 0, 0, NULL, NULL };
931 char *server_cert=TEST_SERVER_CERT;
932 char *server_key=NULL;
933 char *client_cert=TEST_CLIENT_CERT;
934 char *client_key=NULL;
935 #ifndef OPENSSL_NO_ECDH
936 char *named_curve = NULL;
940 const SSL_METHOD *meth=NULL;
942 int number=1,reuse=0;
944 #ifndef OPENSSL_NO_DH
946 int dhe1024 = 0, dhe1024dsa = 0;
948 #ifndef OPENSSL_NO_ECDH
951 #ifndef OPENSSL_NO_SRP
953 SRP_CLIENT_ARG srp_client_arg = {NULL,NULL};
955 SRP_SERVER_ARG srp_server_arg = {NULL,NULL};
961 clock_t s_time = 0, c_time = 0;
962 #ifndef OPENSSL_NO_COMP
964 COMP_METHOD *cm = NULL;
965 STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
967 int test_cipherlist = 0;
971 #ifndef OPENSSL_NO_TLSEXT
972 char *s_authz_file = NULL;
973 int c_support_proof = 0;
974 int c_require_proof = 0;
981 bio_err=BIO_new_fp(stderr,BIO_NOCLOSE|BIO_FP_TEXT);
983 CRYPTO_set_locking_callback(lock_dbg_cb);
985 /* enable memory leak checking unless explicitly disabled */
986 if (!((getenv("OPENSSL_DEBUG_MEMORY") != NULL) && (0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off"))))
988 CRYPTO_malloc_debug_init();
989 CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
993 /* OPENSSL_DEBUG_MEMORY=off */
994 CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);
996 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
998 RAND_seed(rnd_seed, sizeof rnd_seed);
1000 bio_stdout=BIO_new_fp(stdout,BIO_NOCLOSE|BIO_FP_TEXT);
1007 if(!strcmp(*argv,"-F"))
1012 fprintf(stderr,"not compiled with FIPS support, so exitting without running.\n");
1016 else if (strcmp(*argv,"-server_auth") == 0)
1018 else if (strcmp(*argv,"-client_auth") == 0)
1020 else if (strcmp(*argv,"-proxy_auth") == 0)
1022 if (--argc < 1) goto bad;
1023 app_verify_arg.proxy_auth= *(++argv);
1025 else if (strcmp(*argv,"-proxy_cond") == 0)
1027 if (--argc < 1) goto bad;
1028 app_verify_arg.proxy_cond= *(++argv);
1030 else if (strcmp(*argv,"-v") == 0)
1032 else if (strcmp(*argv,"-d") == 0)
1034 else if (strcmp(*argv,"-reuse") == 0)
1036 else if (strcmp(*argv,"-dhe1024") == 0)
1038 #ifndef OPENSSL_NO_DH
1041 fprintf(stderr,"ignoring -dhe1024, since I'm compiled without DH\n");
1044 else if (strcmp(*argv,"-dhe1024dsa") == 0)
1046 #ifndef OPENSSL_NO_DH
1049 fprintf(stderr,"ignoring -dhe1024, since I'm compiled without DH\n");
1052 else if (strcmp(*argv,"-no_dhe") == 0)
1054 else if (strcmp(*argv,"-no_ecdhe") == 0)
1056 else if (strcmp(*argv,"-psk") == 0)
1058 if (--argc < 1) goto bad;
1060 #ifndef OPENSSL_NO_PSK
1061 if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key))
1063 BIO_printf(bio_err,"Not a hex number '%s'\n",*argv);
1070 #ifndef OPENSSL_NO_SRP
1071 else if (strcmp(*argv,"-srpuser") == 0)
1073 if (--argc < 1) goto bad;
1074 srp_server_arg.expected_user = srp_client_arg.srplogin= *(++argv);
1077 else if (strcmp(*argv,"-srppass") == 0)
1079 if (--argc < 1) goto bad;
1080 srp_server_arg.pass = srp_client_arg.srppassin= *(++argv);
1084 else if (strcmp(*argv,"-ssl2") == 0)
1086 else if (strcmp(*argv,"-tls1") == 0)
1088 else if (strcmp(*argv,"-ssl3") == 0)
1090 else if (strncmp(*argv,"-num",4) == 0)
1092 if (--argc < 1) goto bad;
1093 number= atoi(*(++argv));
1094 if (number == 0) number=1;
1096 else if (strcmp(*argv,"-bytes") == 0)
1098 if (--argc < 1) goto bad;
1099 bytes= atol(*(++argv));
1100 if (bytes == 0L) bytes=1L;
1102 if (argv[0][i-1] == 'k') bytes*=1024L;
1103 if (argv[0][i-1] == 'm') bytes*=1024L*1024L;
1105 else if (strcmp(*argv,"-cert") == 0)
1107 if (--argc < 1) goto bad;
1108 server_cert= *(++argv);
1110 else if (strcmp(*argv,"-s_cert") == 0)
1112 if (--argc < 1) goto bad;
1113 server_cert= *(++argv);
1115 else if (strcmp(*argv,"-key") == 0)
1117 if (--argc < 1) goto bad;
1118 server_key= *(++argv);
1120 else if (strcmp(*argv,"-s_key") == 0)
1122 if (--argc < 1) goto bad;
1123 server_key= *(++argv);
1125 else if (strcmp(*argv,"-c_cert") == 0)
1127 if (--argc < 1) goto bad;
1128 client_cert= *(++argv);
1130 else if (strcmp(*argv,"-c_key") == 0)
1132 if (--argc < 1) goto bad;
1133 client_key= *(++argv);
1135 else if (strcmp(*argv,"-cipher") == 0)
1137 if (--argc < 1) goto bad;
1140 else if (strcmp(*argv,"-CApath") == 0)
1142 if (--argc < 1) goto bad;
1145 else if (strcmp(*argv,"-CAfile") == 0)
1147 if (--argc < 1) goto bad;
1150 else if (strcmp(*argv,"-bio_pair") == 0)
1154 else if (strcmp(*argv,"-f") == 0)
1158 else if (strcmp(*argv,"-time") == 0)
1162 #ifndef OPENSSL_NO_COMP
1163 else if (strcmp(*argv,"-zlib") == 0)
1167 else if (strcmp(*argv,"-rle") == 0)
1172 else if (strcmp(*argv,"-named_curve") == 0)
1174 if (--argc < 1) goto bad;
1175 #ifndef OPENSSL_NO_ECDH
1176 named_curve = *(++argv);
1178 fprintf(stderr,"ignoring -named_curve, since I'm compiled without ECDH\n");
1182 else if (strcmp(*argv,"-app_verify") == 0)
1184 app_verify_arg.app_verify = 1;
1186 else if (strcmp(*argv,"-proxy") == 0)
1188 app_verify_arg.allow_proxy_certs = 1;
1190 else if (strcmp(*argv,"-test_cipherlist") == 0)
1192 test_cipherlist = 1;
1194 #ifndef OPENSSL_NO_TLSEXT
1195 else if(strcmp(*argv,"-server_authz") == 0)
1197 if (--argc < 1) goto bad;
1198 s_authz_file = *(++argv);
1201 else if (strcmp(*argv,"-c_support_proof") == 0)
1203 c_support_proof = 1;
1206 else if (strcmp(*argv,"-c_require_proof") == 0)
1208 c_require_proof = 1;
1212 else if (strcmp(*argv,"-serverinfo_sct") == 0)
1216 else if (strcmp(*argv,"-serverinfo_tack") == 0)
1218 serverinfo_tack = 1;
1220 else if (strcmp(*argv,"-serverinfo_file") == 0)
1222 if (--argc < 1) goto bad;
1223 serverinfo_file = *(++argv);
1225 else if (strcmp(*argv,"-custom_ext") == 0)
1229 else if (strcmp(*argv,"-alpn_client") == 0)
1231 if (--argc < 1) goto bad;
1232 alpn_client = *(++argv);
1234 else if (strcmp(*argv,"-alpn_server") == 0)
1236 if (--argc < 1) goto bad;
1237 alpn_server = *(++argv);
1239 else if (strcmp(*argv,"-alpn_expected") == 0)
1241 if (--argc < 1) goto bad;
1242 alpn_expected = *(++argv);
1246 fprintf(stderr,"unknown option %s\n",*argv);
1260 if (test_cipherlist == 1)
1262 /* ensure that the cipher list are correctly sorted and exit */
1263 if (do_test_cipherlist() == 0)
1269 if (!ssl2 && !ssl3 && !tls1 && number > 1 && !reuse && !force)
1271 fprintf(stderr, "This case cannot work. Use -f to perform "
1272 "the test anyway (and\n-d to see what happens), "
1273 "or add one of -ssl2, -ssl3, -tls1, -reuse\n"
1274 "to avoid protocol mismatch.\n");
1277 if (c_require_proof && s_authz_file == NULL && !force)
1279 fprintf(stderr, "This case cannot work. -c_require_proof "
1280 "requires an audit proof, but none was supplied. "
1281 "Use -f to perform the test anyway (and\n-d to see "
1282 "what happens), or use -server_authz to supply an "
1290 if(!FIPS_mode_set(1))
1292 ERR_load_crypto_strings();
1293 ERR_print_errors(BIO_new_fp(stderr,BIO_NOCLOSE));
1297 fprintf(stderr,"*** IN FIPS MODE ***\n");
1305 fprintf(stderr, "Using BIO pair (-bio_pair)\n");
1308 if (number < 50 && !force)
1309 fprintf(stderr, "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
1312 /* if (cipher == NULL) cipher=getenv("SSL_CIPHER"); */
1315 SSL_load_error_strings();
1317 #ifndef OPENSSL_NO_COMP
1318 if (comp == COMP_ZLIB) cm = COMP_zlib();
1319 if (comp == COMP_RLE) cm = COMP_rle();
1322 if (cm->type != NID_undef)
1324 if (SSL_COMP_add_compression_method(comp, cm) != 0)
1327 "Failed to add compression method\n");
1328 ERR_print_errors_fp(stderr);
1334 "Warning: %s compression not supported\n",
1335 (comp == COMP_RLE ? "rle" :
1336 (comp == COMP_ZLIB ? "zlib" :
1338 ERR_print_errors_fp(stderr);
1341 ssl_comp_methods = SSL_COMP_get_compression_methods();
1342 fprintf(stderr, "Available compression methods:\n");
1344 int j, n = sk_SSL_COMP_num(ssl_comp_methods);
1346 fprintf(stderr, " NONE\n");
1348 for (j = 0; j < n; j++)
1350 SSL_COMP *c = sk_SSL_COMP_value(ssl_comp_methods, j);
1351 fprintf(stderr, " %d: %s\n", c->id, c->name);
1356 #if !defined(OPENSSL_NO_SSL2) && !defined(OPENSSL_NO_SSL3)
1358 meth=SSLv2_method();
1361 meth=TLSv1_method();
1364 meth=SSLv3_method();
1366 meth=SSLv23_method();
1368 #ifdef OPENSSL_NO_SSL2
1370 meth=TLSv1_method();
1373 meth=SSLv3_method();
1375 meth=SSLv23_method();
1377 meth=SSLv2_method();
1381 c_ctx=SSL_CTX_new(meth);
1382 s_ctx=SSL_CTX_new(meth);
1383 if ((c_ctx == NULL) || (s_ctx == NULL))
1385 ERR_print_errors(bio_err);
1391 SSL_CTX_set_cipher_list(c_ctx,cipher);
1392 SSL_CTX_set_cipher_list(s_ctx,cipher);
1395 #ifndef OPENSSL_NO_DH
1400 /* use SSL_OP_SINGLE_DH_USE to avoid small subgroup attacks */
1401 SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_DH_USE);
1408 SSL_CTX_set_tmp_dh(s_ctx,dh);
1415 #ifndef OPENSSL_NO_ECDH
1420 if (named_curve != NULL)
1422 nid = OBJ_sn2nid(named_curve);
1425 BIO_printf(bio_err, "unknown curve name (%s)\n", named_curve);
1430 #ifdef OPENSSL_NO_EC2M
1431 nid = NID_X9_62_prime256v1;
1433 nid = NID_sect163r2;
1436 ecdh = EC_KEY_new_by_curve_name(nid);
1439 BIO_printf(bio_err, "unable to create curve\n");
1443 SSL_CTX_set_tmp_ecdh(s_ctx, ecdh);
1444 SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_ECDH_USE);
1451 #ifndef OPENSSL_NO_RSA
1452 SSL_CTX_set_tmp_rsa_callback(s_ctx,tmp_rsa_cb);
1455 #ifdef TLSEXT_TYPE_opaque_prf_input
1456 SSL_CTX_set_tlsext_opaque_prf_input_callback(c_ctx, opaque_prf_input_cb);
1457 SSL_CTX_set_tlsext_opaque_prf_input_callback(s_ctx, opaque_prf_input_cb);
1458 SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(c_ctx, &co1); /* or &co2 or NULL */
1459 SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(s_ctx, &so1); /* or &so2 or NULL */
1462 if (!SSL_CTX_use_certificate_file(s_ctx,server_cert,SSL_FILETYPE_PEM))
1464 ERR_print_errors(bio_err);
1466 else if (!SSL_CTX_use_PrivateKey_file(s_ctx,
1467 (server_key?server_key:server_cert), SSL_FILETYPE_PEM))
1469 ERR_print_errors(bio_err);
1475 SSL_CTX_use_certificate_file(c_ctx,client_cert,
1477 SSL_CTX_use_PrivateKey_file(c_ctx,
1478 (client_key?client_key:client_cert),
1482 if ( (!SSL_CTX_load_verify_locations(s_ctx,CAfile,CApath)) ||
1483 (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1484 (!SSL_CTX_load_verify_locations(c_ctx,CAfile,CApath)) ||
1485 (!SSL_CTX_set_default_verify_paths(c_ctx)))
1487 /* fprintf(stderr,"SSL_load_verify_locations\n"); */
1488 ERR_print_errors(bio_err);
1494 BIO_printf(bio_err,"client authentication\n");
1495 SSL_CTX_set_verify(s_ctx,
1496 SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1498 SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback, &app_verify_arg);
1502 BIO_printf(bio_err,"server authentication\n");
1503 SSL_CTX_set_verify(c_ctx,SSL_VERIFY_PEER,
1505 SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback, &app_verify_arg);
1509 int session_id_context = 0;
1510 SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context, sizeof session_id_context);
1513 /* Use PSK only if PSK key is given */
1514 if (psk_key != NULL)
1516 /* no_psk is used to avoid putting psk command to openssl tool */
1519 /* if PSK is not compiled in and psk key is
1520 * given, do nothing and exit successfully */
1524 #ifndef OPENSSL_NO_PSK
1525 SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1526 SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1528 BIO_printf(bio_err,"setting PSK identity hint to s_ctx\n");
1529 if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint"))
1531 BIO_printf(bio_err,"error setting PSK identity hint to s_ctx\n");
1532 ERR_print_errors(bio_err);
1537 #ifndef OPENSSL_NO_SRP
1538 if (srp_client_arg.srplogin)
1540 if (!SSL_CTX_set_srp_username(c_ctx, srp_client_arg.srplogin))
1542 BIO_printf(bio_err,"Unable to set SRP username\n");
1545 SSL_CTX_set_srp_cb_arg(c_ctx,&srp_client_arg);
1546 SSL_CTX_set_srp_client_pwd_callback(c_ctx, ssl_give_srp_client_pwd_cb);
1547 /*SSL_CTX_set_srp_strength(c_ctx, srp_client_arg.strength);*/
1550 if (srp_server_arg.expected_user != NULL)
1552 SSL_CTX_set_verify(s_ctx,SSL_VERIFY_NONE,verify_callback);
1553 SSL_CTX_set_srp_cb_arg(s_ctx, &srp_server_arg);
1554 SSL_CTX_set_srp_username_callback(s_ctx, ssl_srp_server_param_cb);
1557 #ifndef OPENSSL_NO_TLSEXT
1558 if (s_authz_file != NULL)
1560 if(!SSL_CTX_use_authz_file(s_ctx, s_authz_file))
1562 BIO_printf(bio_err, "Unable to set authz data\n");
1566 if (c_support_proof || c_require_proof)
1568 size_t proof_length;
1569 const unsigned char *proof = SSL_CTX_get_authz_data(s_ctx,
1570 TLSEXT_AUTHZDATAFORMAT_audit_proof, &proof_length);
1573 /* Store a local copy. */
1574 c_expected.expected_proof = OPENSSL_malloc(proof_length);
1575 c_expected.expected_proof_length = proof_length;
1576 memcpy(c_expected.expected_proof, proof, proof_length);
1578 c_expected.require = c_require_proof;
1579 SSL_CTX_set_tlsext_authz_server_audit_proof_cb(c_ctx,
1581 SSL_CTX_set_tlsext_authz_server_audit_proof_cb_arg(c_ctx,
1587 SSL_CTX_set_custom_cli_ext(c_ctx, SCT_EXT_TYPE, NULL,
1588 serverinfo_cli_cb, NULL);
1589 if (serverinfo_tack)
1590 SSL_CTX_set_custom_cli_ext(c_ctx, TACK_EXT_TYPE, NULL,
1591 serverinfo_cli_cb, NULL);
1593 if (serverinfo_file)
1594 if (!SSL_CTX_use_serverinfo_file(s_ctx, serverinfo_file))
1596 BIO_printf(bio_err, "missing serverinfo file\n");
1602 SSL_CTX_set_custom_cli_ext(c_ctx, CUSTOM_EXT_TYPE_0,
1603 custom_ext_0_cli_first_cb,
1604 custom_ext_0_cli_second_cb, NULL);
1605 SSL_CTX_set_custom_cli_ext(c_ctx, CUSTOM_EXT_TYPE_1,
1606 custom_ext_1_cli_first_cb,
1607 custom_ext_1_cli_second_cb, NULL);
1608 SSL_CTX_set_custom_cli_ext(c_ctx, CUSTOM_EXT_TYPE_2,
1609 custom_ext_2_cli_first_cb,
1610 custom_ext_2_cli_second_cb, NULL);
1611 SSL_CTX_set_custom_cli_ext(c_ctx, CUSTOM_EXT_TYPE_3,
1612 custom_ext_3_cli_first_cb,
1613 custom_ext_3_cli_second_cb, NULL);
1616 SSL_CTX_set_custom_srv_ext(s_ctx, CUSTOM_EXT_TYPE_0,
1617 custom_ext_0_srv_first_cb,
1618 custom_ext_0_srv_second_cb, NULL);
1619 SSL_CTX_set_custom_srv_ext(s_ctx, CUSTOM_EXT_TYPE_1,
1620 custom_ext_1_srv_first_cb,
1621 custom_ext_1_srv_second_cb, NULL);
1622 SSL_CTX_set_custom_srv_ext(s_ctx, CUSTOM_EXT_TYPE_2,
1623 custom_ext_2_srv_first_cb,
1624 custom_ext_2_srv_second_cb, NULL);
1625 SSL_CTX_set_custom_srv_ext(s_ctx, CUSTOM_EXT_TYPE_3,
1626 custom_ext_3_srv_first_cb,
1627 custom_ext_3_srv_second_cb, NULL);
1631 SSL_CTX_set_alpn_select_cb(s_ctx, cb_server_alpn, NULL);
1635 unsigned short alpn_len;
1636 unsigned char *alpn = next_protos_parse(&alpn_len, alpn_client);
1640 BIO_printf(bio_err, "Error parsing -alpn_client argument\n");
1643 SSL_CTX_set_alpn_protos(c_ctx, alpn, alpn_len);
1647 c_ssl=SSL_new(c_ctx);
1648 s_ssl=SSL_new(s_ctx);
1650 #ifndef OPENSSL_NO_KRB5
1651 if (c_ssl && c_ssl->kssl_ctx)
1653 char localhost[MAXHOSTNAMELEN+2];
1655 if (gethostname(localhost, sizeof localhost-1) == 0)
1657 localhost[sizeof localhost-1]='\0';
1658 if(strlen(localhost) == sizeof localhost-1)
1660 BIO_printf(bio_err,"localhost name too long\n");
1663 kssl_ctx_setstring(c_ssl->kssl_ctx, KSSL_SERVER,
1667 #endif /* OPENSSL_NO_KRB5 */
1669 for (i=0; i<number; i++)
1671 if (!reuse) SSL_set_session(c_ssl,NULL);
1673 ret=doit_biopair(s_ssl,c_ssl,bytes,&s_time,&c_time);
1675 ret=doit(s_ssl,c_ssl,bytes);
1680 print_details(c_ssl, "");
1682 if ((number > 1) || (bytes > 1L))
1683 BIO_printf(bio_stdout, "%d handshakes of %ld bytes done\n",number,bytes);
1686 #ifdef CLOCKS_PER_SEC
1687 /* "To determine the time in seconds, the value returned
1688 * by the clock function should be divided by the value
1689 * of the macro CLOCKS_PER_SEC."
1690 * -- ISO/IEC 9899 */
1691 BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1692 "Approximate total client time: %6.2f s\n",
1693 (double)s_time/CLOCKS_PER_SEC,
1694 (double)c_time/CLOCKS_PER_SEC);
1696 /* "`CLOCKS_PER_SEC' undeclared (first use this function)"
1697 * -- cc on NeXTstep/OpenStep */
1698 BIO_printf(bio_stdout,
1699 "Approximate total server time: %6.2f units\n"
1700 "Approximate total client time: %6.2f units\n",
1710 if (s_ctx != NULL) SSL_CTX_free(s_ctx);
1711 if (c_ctx != NULL) SSL_CTX_free(c_ctx);
1713 if (bio_stdout != NULL) BIO_free(bio_stdout);
1715 #ifndef OPENSSL_NO_RSA
1718 #ifndef OPENSSL_NO_ENGINE
1721 #ifndef OPENSSL_NO_TLSEXT
1722 if (c_expected.expected_proof != NULL)
1723 OPENSSL_free(c_expected.expected_proof);
1725 CRYPTO_cleanup_all_ex_data();
1727 ERR_remove_thread_state(NULL);
1729 CRYPTO_mem_leaks(bio_err);
1730 if (bio_err != NULL) BIO_free(bio_err);
1735 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
1736 clock_t *s_time, clock_t *c_time)
1738 long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1739 BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1740 BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
1743 size_t bufsiz = 256; /* small buffer for testing */
1745 if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
1747 if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
1750 s_ssl_bio = BIO_new(BIO_f_ssl());
1754 c_ssl_bio = BIO_new(BIO_f_ssl());
1758 SSL_set_connect_state(c_ssl);
1759 SSL_set_bio(c_ssl, client, client);
1760 (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1762 SSL_set_accept_state(s_ssl);
1763 SSL_set_bio(s_ssl, server, server);
1764 (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1768 /* c_ssl_bio: SSL filter BIO
1770 * client: pseudo-I/O for SSL library
1772 * client_io: client's SSL communication; usually to be
1773 * relayed over some I/O facility, but in this
1774 * test program, we're the server, too:
1776 * server_io: server's SSL communication
1778 * server: pseudo-I/O for SSL library
1780 * s_ssl_bio: SSL filter BIO
1782 * The client and the server each employ a "BIO pair":
1783 * client + client_io, server + server_io.
1784 * BIO pairs are symmetric. A BIO pair behaves similar
1785 * to a non-blocking socketpair (but both endpoints must
1786 * be handled by the same thread).
1787 * [Here we could connect client and server to the ends
1788 * of a single BIO pair, but then this code would be less
1789 * suitable as an example for BIO pairs in general.]
1791 * Useful functions for querying the state of BIO pair endpoints:
1793 * BIO_ctrl_pending(bio) number of bytes we can read now
1794 * BIO_ctrl_get_read_request(bio) number of bytes needed to fulfil
1795 * other side's read attempt
1796 * BIO_ctrl_get_write_guarantee(bio) number of bytes we can write now
1798 * ..._read_request is never more than ..._write_guarantee;
1799 * it depends on the application which one you should use.
1802 /* We have non-blocking behaviour throughout this test program, but
1803 * can be sure that there is *some* progress in each iteration; so
1804 * we don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE
1805 * -- we just try everything in each iteration
1811 MS_STATIC char cbuf[1024*8];
1813 clock_t c_clock = clock();
1815 memset(cbuf, 0, sizeof(cbuf));
1818 if (SSL_in_init(c_ssl))
1819 printf("client waiting in SSL_connect - %s\n",
1820 SSL_state_string_long(c_ssl));
1824 /* Write to server. */
1826 if (cw_num > (long)sizeof cbuf)
1830 r = BIO_write(c_ssl_bio, cbuf, i);
1833 if (!BIO_should_retry(c_ssl_bio))
1835 fprintf(stderr,"ERROR in CLIENT\n");
1838 /* BIO_should_retry(...) can just be ignored here.
1839 * The library expects us to call BIO_write with
1840 * the same arguments again, and that's what we will
1841 * do in the next iteration. */
1845 fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1851 printf("client wrote %d\n", r);
1858 /* Read from server. */
1860 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1863 if (!BIO_should_retry(c_ssl_bio))
1865 fprintf(stderr,"ERROR in CLIENT\n");
1868 /* Again, "BIO_should_retry" can be ignored. */
1872 fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1878 printf("client read %d\n", r);
1883 /* c_time and s_time increments will typically be very small
1884 * (depending on machine speed and clock tick intervals),
1885 * but sampling over a large number of connections should
1886 * result in fairly accurate figures. We cannot guarantee
1887 * a lot, however -- if each connection lasts for exactly
1888 * one clock tick, it will be counted only for the client
1889 * or only for the server or even not at all.
1891 *c_time += (clock() - c_clock);
1897 MS_STATIC char sbuf[1024*8];
1899 clock_t s_clock = clock();
1901 memset(sbuf, 0, sizeof(sbuf));
1904 if (SSL_in_init(s_ssl))
1905 printf("server waiting in SSL_accept - %s\n",
1906 SSL_state_string_long(s_ssl));
1910 /* Write to client. */
1912 if (sw_num > (long)sizeof sbuf)
1916 r = BIO_write(s_ssl_bio, sbuf, i);
1919 if (!BIO_should_retry(s_ssl_bio))
1921 fprintf(stderr,"ERROR in SERVER\n");
1924 /* Ignore "BIO_should_retry". */
1928 fprintf(stderr,"SSL SERVER STARTUP FAILED\n");
1934 printf("server wrote %d\n", r);
1941 /* Read from client. */
1943 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
1946 if (!BIO_should_retry(s_ssl_bio))
1948 fprintf(stderr,"ERROR in SERVER\n");
1955 fprintf(stderr,"SSL SERVER STARTUP FAILED\n");
1961 printf("server read %d\n", r);
1966 *s_time += (clock() - s_clock);
1970 /* "I/O" BETWEEN CLIENT AND SERVER. */
1973 BIO *io1 = server_io, *io2 = client_io;
1974 /* we use the non-copying interface for io1
1975 * and the standard BIO_write/BIO_read interface for io2
1978 static int prev_progress = 1;
1987 r1 = BIO_ctrl_pending(io1);
1988 r2 = BIO_ctrl_get_write_guarantee(io2);
1997 if (INT_MAX < num) /* yeah, right */
2000 r = BIO_nread(io1, &dataptr, (int)num);
2002 assert(r <= (int)num);
2003 /* possibly r < num (non-contiguous data) */
2005 r = BIO_write(io2, dataptr, (int)num);
2006 if (r != (int)num) /* can't happen */
2008 fprintf(stderr, "ERROR: BIO_write could not write "
2009 "BIO_ctrl_get_write_guarantee() bytes");
2015 printf((io1 == client_io) ?
2016 "C->S relaying: %d bytes\n" :
2017 "S->C relaying: %d bytes\n",
2028 r1 = BIO_ctrl_pending(io2);
2029 r2 = BIO_ctrl_get_read_request(io1);
2030 /* here we could use ..._get_write_guarantee instead of
2031 * ..._get_read_request, but by using the latter
2032 * we test restartability of the SSL implementation
2033 * more thoroughly */
2045 --num; /* test restartability even more thoroughly */
2047 r = BIO_nwrite0(io1, &dataptr);
2051 r = BIO_read(io2, dataptr, (int)num);
2052 if (r != (int)num) /* can't happen */
2054 fprintf(stderr, "ERROR: BIO_read could not read "
2055 "BIO_ctrl_pending() bytes");
2059 r = BIO_nwrite(io1, &dataptr, (int)num);
2060 if (r != (int)num) /* can't happen */
2062 fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
2063 "BIO_nwrite0() bytes");
2068 printf((io2 == client_io) ?
2069 "C->S relaying: %d bytes\n" :
2070 "S->C relaying: %d bytes\n",
2073 } /* no loop, BIO_ctrl_get_read_request now returns 0 anyway */
2075 if (!progress && !prev_progress)
2076 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0)
2078 fprintf(stderr, "ERROR: got stuck\n");
2079 if (strcmp("SSLv2", SSL_get_version(c_ssl)) == 0)
2081 fprintf(stderr, "This can happen for SSL2 because "
2082 "CLIENT-FINISHED and SERVER-VERIFY are written \n"
2083 "concurrently ...");
2084 if (strncmp("2SCF", SSL_state_string(c_ssl), 4) == 0
2085 && strncmp("2SSV", SSL_state_string(s_ssl), 4) == 0)
2087 fprintf(stderr, " ok.\n");
2091 fprintf(stderr, " ERROR.\n");
2094 prev_progress = progress;
2097 while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2100 print_details(c_ssl, "DONE via BIO pair: ");
2102 if (verify_serverinfo() < 0)
2107 if (verify_alpn(c_ssl, s_ssl) < 0)
2113 if (custom_ext_error)
2123 ERR_print_errors(bio_err);
2128 BIO_free(server_io);
2132 BIO_free(client_io);
2134 BIO_free(s_ssl_bio);
2136 BIO_free(c_ssl_bio);
2147 int doit(SSL *s_ssl, SSL *c_ssl, long count)
2149 MS_STATIC char cbuf[1024*8],sbuf[1024*8];
2150 long cw_num=count,cr_num=count;
2151 long sw_num=count,sr_num=count;
2157 int c_r,c_w,s_r,s_w;
2160 int c_write,s_write;
2161 int do_server=0,do_client=0;
2163 memset(cbuf,0,sizeof(cbuf));
2164 memset(sbuf,0,sizeof(sbuf));
2166 c_to_s=BIO_new(BIO_s_mem());
2167 s_to_c=BIO_new(BIO_s_mem());
2168 if ((s_to_c == NULL) || (c_to_s == NULL))
2170 ERR_print_errors(bio_err);
2174 c_bio=BIO_new(BIO_f_ssl());
2175 s_bio=BIO_new(BIO_f_ssl());
2176 if ((c_bio == NULL) || (s_bio == NULL))
2178 ERR_print_errors(bio_err);
2182 SSL_set_connect_state(c_ssl);
2183 SSL_set_bio(c_ssl,s_to_c,c_to_s);
2184 BIO_set_ssl(c_bio,c_ssl,BIO_NOCLOSE);
2186 SSL_set_accept_state(s_ssl);
2187 SSL_set_bio(s_ssl,c_to_s,s_to_c);
2188 BIO_set_ssl(s_bio,s_ssl,BIO_NOCLOSE);
2192 c_write=1,s_write=0;
2194 /* We can always do writes */
2200 i=(int)BIO_pending(s_bio);
2201 if ((i && s_r) || s_w) do_server=1;
2203 i=(int)BIO_pending(c_bio);
2204 if ((i && c_r) || c_w) do_client=1;
2206 if (do_server && debug)
2208 if (SSL_in_init(s_ssl))
2209 printf("server waiting in SSL_accept - %s\n",
2210 SSL_state_string_long(s_ssl));
2211 /* else if (s_write)
2212 printf("server:SSL_write()\n");
2214 printf("server:SSL_read()\n"); */
2217 if (do_client && debug)
2219 if (SSL_in_init(c_ssl))
2220 printf("client waiting in SSL_connect - %s\n",
2221 SSL_state_string_long(c_ssl));
2222 /* else if (c_write)
2223 printf("client:SSL_write()\n");
2225 printf("client:SSL_read()\n"); */
2228 if (!do_client && !do_server)
2230 fprintf(stdout,"ERROR IN STARTUP\n");
2231 ERR_print_errors(bio_err);
2234 if (do_client && !(done & C_DONE))
2238 j = (cw_num > (long)sizeof(cbuf)) ?
2239 (int)sizeof(cbuf) : (int)cw_num;
2240 i=BIO_write(c_bio,cbuf,j);
2245 if (BIO_should_retry(c_bio))
2247 if (BIO_should_read(c_bio))
2249 if (BIO_should_write(c_bio))
2254 fprintf(stderr,"ERROR in CLIENT\n");
2255 ERR_print_errors(bio_err);
2261 fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
2267 printf("client wrote %d\n",i);
2276 i=BIO_read(c_bio,cbuf,sizeof(cbuf));
2281 if (BIO_should_retry(c_bio))
2283 if (BIO_should_read(c_bio))
2285 if (BIO_should_write(c_bio))
2290 fprintf(stderr,"ERROR in CLIENT\n");
2291 ERR_print_errors(bio_err);
2297 fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
2303 printf("client read %d\n",i);
2320 if (do_server && !(done & S_DONE))
2324 i=BIO_read(s_bio,sbuf,sizeof(cbuf));
2329 if (BIO_should_retry(s_bio))
2331 if (BIO_should_read(s_bio))
2333 if (BIO_should_write(s_bio))
2338 fprintf(stderr,"ERROR in SERVER\n");
2339 ERR_print_errors(bio_err);
2345 ERR_print_errors(bio_err);
2346 fprintf(stderr,"SSL SERVER STARTUP FAILED in SSL_read\n");
2352 printf("server read %d\n",i);
2369 j = (sw_num > (long)sizeof(sbuf)) ?
2370 (int)sizeof(sbuf) : (int)sw_num;
2371 i=BIO_write(s_bio,sbuf,j);
2376 if (BIO_should_retry(s_bio))
2378 if (BIO_should_read(s_bio))
2380 if (BIO_should_write(s_bio))
2385 fprintf(stderr,"ERROR in SERVER\n");
2386 ERR_print_errors(bio_err);
2392 ERR_print_errors(bio_err);
2393 fprintf(stderr,"SSL SERVER STARTUP FAILED in SSL_write\n");
2399 printf("server wrote %d\n",i);
2409 if ((done & S_DONE) && (done & C_DONE)) break;
2413 print_details(c_ssl, "DONE: ");
2415 if (verify_serverinfo() < 0)
2420 if (custom_ext_error)
2427 /* We have to set the BIO's to NULL otherwise they will be
2428 * OPENSSL_free()ed twice. Once when th s_ssl is SSL_free()ed and
2429 * again when c_ssl is SSL_free()ed.
2430 * This is a hack required because s_ssl and c_ssl are sharing the same
2431 * BIO structure and SSL_set_bio() and SSL_free() automatically
2432 * BIO_free non NULL entries.
2433 * You should not normally do this or be required to do this */
2445 if (c_to_s != NULL) BIO_free(c_to_s);
2446 if (s_to_c != NULL) BIO_free(s_to_c);
2447 if (c_bio != NULL) BIO_free_all(c_bio);
2448 if (s_bio != NULL) BIO_free_all(s_bio);
2452 static int get_proxy_auth_ex_data_idx(void)
2454 static volatile int idx = -1;
2457 CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
2460 idx = X509_STORE_CTX_get_ex_new_index(0,
2461 "SSLtest for verify callback", NULL,NULL,NULL);
2463 CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
2468 static int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx)
2472 s=X509_NAME_oneline(X509_get_subject_name(ctx->current_cert),buf,
2477 fprintf(stderr,"depth=%d %s\n",
2478 ctx->error_depth,buf);
2481 fprintf(stderr,"depth=%d error=%d %s\n",
2482 ctx->error_depth,ctx->error,buf);
2488 fprintf(stderr,"Error string: %s\n",
2489 X509_verify_cert_error_string(ctx->error));
2492 case X509_V_ERR_CERT_NOT_YET_VALID:
2493 case X509_V_ERR_CERT_HAS_EXPIRED:
2494 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2495 fprintf(stderr," ... ignored.\n");
2502 X509 *xs = ctx->current_cert;
2504 X509 *xi = ctx->current_issuer;
2507 if (xs->ex_flags & EXFLAG_PROXY)
2509 unsigned int *letters =
2510 X509_STORE_CTX_get_ex_data(ctx,
2511 get_proxy_auth_ex_data_idx());
2517 PROXY_CERT_INFO_EXTENSION *pci =
2518 X509_get_ext_d2i(xs, NID_proxyCertInfo,
2521 switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage))
2523 case NID_Independent:
2524 /* Completely meaningless in this
2525 program, as there's no way to
2526 grant explicit rights to a
2527 specific PrC. Basically, using
2528 id-ppl-Independent is the perfect
2529 way to grant no rights at all. */
2530 fprintf(stderr, " Independent proxy certificate");
2531 for (i = 0; i < 26; i++)
2534 case NID_id_ppl_inheritAll:
2535 /* This is basically a NOP, we
2536 simply let the current rights
2537 stand as they are. */
2538 fprintf(stderr, " Proxy certificate inherits all");
2542 pci->proxyPolicy->policy->data;
2543 i = pci->proxyPolicy->policy->length;
2545 /* The algorithm works as follows:
2546 it is assumed that previous
2547 iterations or the initial granted
2548 rights has already set some elements
2549 of `letters'. What we need to do is
2550 to clear those that weren't granted
2551 by the current PrC as well. The
2552 easiest way to do this is to add 1
2553 to all the elements whose letters
2554 are given with the current policy.
2555 That way, all elements that are set
2556 by the current policy and were
2557 already set by earlier policies and
2558 through the original grant of rights
2559 will get the value 2 or higher.
2560 The last thing to do is to sweep
2561 through `letters' and keep the
2562 elements having the value 2 as set,
2563 and clear all the others. */
2565 fprintf(stderr, " Certificate proxy rights = %*.*s", i, i, s);
2569 if (isascii(c) && isalpha(c))
2576 for (i = 0; i < 26; i++)
2585 ", resulting proxy rights = ");
2586 for(i = 0; i < 26; i++)
2589 fprintf(stderr, "%c", i + 'A');
2593 fprintf(stderr, "none");
2594 fprintf(stderr, "\n");
2596 PROXY_CERT_INFO_EXTENSION_free(pci);
2604 static void process_proxy_debug(int indent, const char *format, ...)
2606 static const char indentation[] =
2607 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
2608 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"; /* That's 80 > */
2609 char my_format[256];
2612 BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
2613 indent, indent, indentation, format);
2615 va_start(args, format);
2616 vfprintf(stderr, my_format, args);
2624 static int process_proxy_cond_adders(unsigned int letters[26],
2625 const char *cond, const char **cond_end, int *pos, int indent);
2626 static int process_proxy_cond_val(unsigned int letters[26],
2627 const char *cond, const char **cond_end, int *pos, int indent)
2633 while(isspace((int)*cond))
2640 process_proxy_debug(indent,
2641 "Start process_proxy_cond_val at position %d: %s\n",
2648 while(isspace((int)*cond))
2658 ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
2663 while(isspace((int)*cond))
2671 "Weird condition character in position %d: "
2678 else if (isascii(c) && isalpha(c))
2682 ok = letters[c - 'A'];
2688 "Weird condition character in position %d: "
2695 if (ok >= 0 && negate)
2699 process_proxy_debug(indent,
2700 "End process_proxy_cond_val at position %d: %s, returning %d\n",
2705 static int process_proxy_cond_multipliers(unsigned int letters[26],
2706 const char *cond, const char **cond_end, int *pos, int indent)
2712 process_proxy_debug(indent,
2713 "Start process_proxy_cond_multipliers at position %d: %s\n",
2716 ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
2723 while(isspace((int)*cond))
2737 ok = process_proxy_cond_val(letters,
2738 cond, cond_end, pos, indent + 1);
2752 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2764 process_proxy_debug(indent,
2765 "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
2771 static int process_proxy_cond_adders(unsigned int letters[26],
2772 const char *cond, const char **cond_end, int *pos, int indent)
2778 process_proxy_debug(indent,
2779 "Start process_proxy_cond_adders at position %d: %s\n",
2782 ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
2790 while(isspace((int)*cond))
2803 ok = process_proxy_cond_multipliers(letters,
2804 cond, cond_end, pos, indent + 1);
2815 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2827 process_proxy_debug(indent,
2828 "End process_proxy_cond_adders at position %d: %s, returning %d\n",
2835 static int process_proxy_cond(unsigned int letters[26],
2836 const char *cond, const char **cond_end)
2839 return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
2842 static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2845 struct app_verify_arg *cb_arg = arg;
2846 unsigned int letters[26]; /* only used with proxy_auth */
2848 if (cb_arg->app_verify)
2850 char *s = NULL,buf[256];
2852 fprintf(stderr, "In app_verify_callback, allowing cert. ");
2853 fprintf(stderr, "Arg is: %s\n", cb_arg->string);
2854 fprintf(stderr, "Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2855 (void *)ctx, (void *)ctx->cert);
2857 s=X509_NAME_oneline(X509_get_subject_name(ctx->cert),buf,256);
2860 fprintf(stderr,"cert depth=%d %s\n",ctx->error_depth,buf);
2864 if (cb_arg->proxy_auth)
2866 int found_any = 0, i;
2869 for(i = 0; i < 26; i++)
2871 for(sp = cb_arg->proxy_auth; *sp; sp++)
2874 if (isascii(c) && isalpha(c))
2878 letters[c - 'A'] = 1;
2883 " Initial proxy rights = ");
2884 for(i = 0; i < 26; i++)
2887 fprintf(stderr, "%c", i + 'A');
2891 fprintf(stderr, "none");
2892 fprintf(stderr, "\n");
2894 X509_STORE_CTX_set_ex_data(ctx,
2895 get_proxy_auth_ex_data_idx(),letters);
2897 if (cb_arg->allow_proxy_certs)
2899 X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
2902 #ifndef OPENSSL_NO_X509_VERIFY
2903 ok = X509_verify_cert(ctx);
2906 if (cb_arg->proxy_auth)
2910 const char *cond_end = NULL;
2912 ok = process_proxy_cond(letters,
2913 cb_arg->proxy_cond, &cond_end);
2919 fprintf(stderr, "Stopped processing condition before it's end.\n");
2923 fprintf(stderr, "Proxy rights check with condition '%s' proved invalid\n",
2924 cb_arg->proxy_cond);
2926 fprintf(stderr, "Proxy rights check with condition '%s' proved valid\n",
2927 cb_arg->proxy_cond);
2933 #ifndef OPENSSL_NO_RSA
2934 static RSA *rsa_tmp=NULL;
2936 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
2939 if (rsa_tmp == NULL)
2942 rsa_tmp = RSA_new();
2943 if(!bn || !rsa_tmp || !BN_set_word(bn, RSA_F4))
2945 BIO_printf(bio_err, "Memory error...");
2948 BIO_printf(bio_err,"Generating temp (%d bit) RSA key...",keylength);
2949 (void)BIO_flush(bio_err);
2950 if(!RSA_generate_key_ex(rsa_tmp,keylength,bn,NULL))
2952 BIO_printf(bio_err, "Error generating key.");
2957 BIO_printf(bio_err,"\n");
2958 (void)BIO_flush(bio_err);
2964 static void free_tmp_rsa(void)
2966 if (rsa_tmp != NULL)
2974 #ifndef OPENSSL_NO_DH
2975 /* These DH parameters have been generated as follows:
2976 * $ openssl dhparam -C -noout 512
2977 * $ openssl dhparam -C -noout 1024
2978 * $ openssl dhparam -C -noout -dsaparam 1024
2979 * (The third function has been renamed to avoid name conflicts.)
2981 static DH *get_dh512()
2983 static unsigned char dh512_p[]={
2984 0xCB,0xC8,0xE1,0x86,0xD0,0x1F,0x94,0x17,0xA6,0x99,0xF0,0xC6,
2985 0x1F,0x0D,0xAC,0xB6,0x25,0x3E,0x06,0x39,0xCA,0x72,0x04,0xB0,
2986 0x6E,0xDA,0xC0,0x61,0xE6,0x7A,0x77,0x25,0xE8,0x3B,0xB9,0x5F,
2987 0x9A,0xB6,0xB5,0xFE,0x99,0x0B,0xA1,0x93,0x4E,0x35,0x33,0xB8,
2988 0xE1,0xF1,0x13,0x4F,0x59,0x1A,0xD2,0x57,0xC0,0x26,0x21,0x33,
2989 0x02,0xC5,0xAE,0x23,
2991 static unsigned char dh512_g[]={
2996 if ((dh=DH_new()) == NULL) return(NULL);
2997 dh->p=BN_bin2bn(dh512_p,sizeof(dh512_p),NULL);
2998 dh->g=BN_bin2bn(dh512_g,sizeof(dh512_g),NULL);
2999 if ((dh->p == NULL) || (dh->g == NULL))
3000 { DH_free(dh); return(NULL); }
3004 static DH *get_dh1024()
3006 static unsigned char dh1024_p[]={
3007 0xF8,0x81,0x89,0x7D,0x14,0x24,0xC5,0xD1,0xE6,0xF7,0xBF,0x3A,
3008 0xE4,0x90,0xF4,0xFC,0x73,0xFB,0x34,0xB5,0xFA,0x4C,0x56,0xA2,
3009 0xEA,0xA7,0xE9,0xC0,0xC0,0xCE,0x89,0xE1,0xFA,0x63,0x3F,0xB0,
3010 0x6B,0x32,0x66,0xF1,0xD1,0x7B,0xB0,0x00,0x8F,0xCA,0x87,0xC2,
3011 0xAE,0x98,0x89,0x26,0x17,0xC2,0x05,0xD2,0xEC,0x08,0xD0,0x8C,
3012 0xFF,0x17,0x52,0x8C,0xC5,0x07,0x93,0x03,0xB1,0xF6,0x2F,0xB8,
3013 0x1C,0x52,0x47,0x27,0x1B,0xDB,0xD1,0x8D,0x9D,0x69,0x1D,0x52,
3014 0x4B,0x32,0x81,0xAA,0x7F,0x00,0xC8,0xDC,0xE6,0xD9,0xCC,0xC1,
3015 0x11,0x2D,0x37,0x34,0x6C,0xEA,0x02,0x97,0x4B,0x0E,0xBB,0xB1,
3016 0x71,0x33,0x09,0x15,0xFD,0xDD,0x23,0x87,0x07,0x5E,0x89,0xAB,
3017 0x6B,0x7C,0x5F,0xEC,0xA6,0x24,0xDC,0x53,
3019 static unsigned char dh1024_g[]={
3024 if ((dh=DH_new()) == NULL) return(NULL);
3025 dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
3026 dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
3027 if ((dh->p == NULL) || (dh->g == NULL))
3028 { DH_free(dh); return(NULL); }
3032 static DH *get_dh1024dsa()
3034 static unsigned char dh1024_p[]={
3035 0xC8,0x00,0xF7,0x08,0x07,0x89,0x4D,0x90,0x53,0xF3,0xD5,0x00,
3036 0x21,0x1B,0xF7,0x31,0xA6,0xA2,0xDA,0x23,0x9A,0xC7,0x87,0x19,
3037 0x3B,0x47,0xB6,0x8C,0x04,0x6F,0xFF,0xC6,0x9B,0xB8,0x65,0xD2,
3038 0xC2,0x5F,0x31,0x83,0x4A,0xA7,0x5F,0x2F,0x88,0x38,0xB6,0x55,
3039 0xCF,0xD9,0x87,0x6D,0x6F,0x9F,0xDA,0xAC,0xA6,0x48,0xAF,0xFC,
3040 0x33,0x84,0x37,0x5B,0x82,0x4A,0x31,0x5D,0xE7,0xBD,0x52,0x97,
3041 0xA1,0x77,0xBF,0x10,0x9E,0x37,0xEA,0x64,0xFA,0xCA,0x28,0x8D,
3042 0x9D,0x3B,0xD2,0x6E,0x09,0x5C,0x68,0xC7,0x45,0x90,0xFD,0xBB,
3043 0x70,0xC9,0x3A,0xBB,0xDF,0xD4,0x21,0x0F,0xC4,0x6A,0x3C,0xF6,
3044 0x61,0xCF,0x3F,0xD6,0x13,0xF1,0x5F,0xBC,0xCF,0xBC,0x26,0x9E,
3045 0xBC,0x0B,0xBD,0xAB,0x5D,0xC9,0x54,0x39,
3047 static unsigned char dh1024_g[]={
3048 0x3B,0x40,0x86,0xE7,0xF3,0x6C,0xDE,0x67,0x1C,0xCC,0x80,0x05,
3049 0x5A,0xDF,0xFE,0xBD,0x20,0x27,0x74,0x6C,0x24,0xC9,0x03,0xF3,
3050 0xE1,0x8D,0xC3,0x7D,0x98,0x27,0x40,0x08,0xB8,0x8C,0x6A,0xE9,
3051 0xBB,0x1A,0x3A,0xD6,0x86,0x83,0x5E,0x72,0x41,0xCE,0x85,0x3C,
3052 0xD2,0xB3,0xFC,0x13,0xCE,0x37,0x81,0x9E,0x4C,0x1C,0x7B,0x65,
3053 0xD3,0xE6,0xA6,0x00,0xF5,0x5A,0x95,0x43,0x5E,0x81,0xCF,0x60,
3054 0xA2,0x23,0xFC,0x36,0xA7,0x5D,0x7A,0x4C,0x06,0x91,0x6E,0xF6,
3055 0x57,0xEE,0x36,0xCB,0x06,0xEA,0xF5,0x3D,0x95,0x49,0xCB,0xA7,
3056 0xDD,0x81,0xDF,0x80,0x09,0x4A,0x97,0x4D,0xA8,0x22,0x72,0xA1,
3057 0x7F,0xC4,0x70,0x56,0x70,0xE8,0x20,0x10,0x18,0x8F,0x2E,0x60,
3058 0x07,0xE7,0x68,0x1A,0x82,0x5D,0x32,0xA2,
3062 if ((dh=DH_new()) == NULL) return(NULL);
3063 dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
3064 dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
3065 if ((dh->p == NULL) || (dh->g == NULL))
3066 { DH_free(dh); return(NULL); }
3072 #ifndef OPENSSL_NO_PSK
3073 /* convert the PSK key (psk_key) in ascii to binary (psk) */
3074 static int psk_key2bn(const char *pskkey, unsigned char *psk,
3075 unsigned int max_psk_len)
3080 ret = BN_hex2bn(&bn, pskkey);
3083 BIO_printf(bio_err,"Could not convert PSK key '%s' to BIGNUM\n", pskkey);
3088 if (BN_num_bytes(bn) > (int)max_psk_len)
3090 BIO_printf(bio_err,"psk buffer of callback is too small (%d) for key (%d)\n",
3091 max_psk_len, BN_num_bytes(bn));
3095 ret = BN_bn2bin(bn, psk);
3100 static unsigned int psk_client_callback(SSL *ssl, const char *hint, char *identity,
3101 unsigned int max_identity_len, unsigned char *psk,
3102 unsigned int max_psk_len)
3105 unsigned int psk_len = 0;
3107 ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3111 fprintf(stderr, "client: created identity '%s' len=%d\n", identity, ret);
3112 ret = psk_key2bn(psk_key, psk, max_psk_len);
3120 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3121 unsigned char *psk, unsigned int max_psk_len)
3123 unsigned int psk_len=0;
3125 if (strcmp(identity, "Client_identity") != 0)
3127 BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3130 psk_len=psk_key2bn(psk_key, psk, max_psk_len);
3135 static int do_test_cipherlist(void)
3138 const SSL_METHOD *meth;
3139 const SSL_CIPHER *ci, *tci = NULL;
3141 #ifndef OPENSSL_NO_SSL2
3142 fprintf(stderr, "testing SSLv2 cipher list order: ");
3143 meth = SSLv2_method();
3144 while ((ci = meth->get_cipher(i++)) != NULL)
3147 if (ci->id >= tci->id)
3149 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3154 fprintf(stderr, "ok\n");
3156 #ifndef OPENSSL_NO_SSL3
3157 fprintf(stderr, "testing SSLv3 cipher list order: ");
3158 meth = SSLv3_method();
3160 while ((ci = meth->get_cipher(i++)) != NULL)
3163 if (ci->id >= tci->id)
3165 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3170 fprintf(stderr, "ok\n");
3172 #ifndef OPENSSL_NO_TLS1
3173 fprintf(stderr, "testing TLSv1 cipher list order: ");
3174 meth = TLSv1_method();
3176 while ((ci = meth->get_cipher(i++)) != NULL)
3179 if (ci->id >= tci->id)
3181 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3186 fprintf(stderr, "ok\n");