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
159 * Or isascii won't be declared properly on VMS (at least with DECompHP C).
161 # define _XOPEN_SOURCE 500
166 #include <openssl/bio.h>
167 #include <openssl/crypto.h>
168 #include <openssl/evp.h>
169 #include <openssl/x509.h>
170 #include <openssl/x509v3.h>
171 #include <openssl/ssl.h>
172 #ifndef OPENSSL_NO_ENGINE
173 # include <openssl/engine.h>
175 #include <openssl/err.h>
176 #include <openssl/rand.h>
177 #ifndef OPENSSL_NO_RSA
178 # include <openssl/rsa.h>
180 #ifndef OPENSSL_NO_DSA
181 # include <openssl/dsa.h>
183 #ifndef OPENSSL_NO_DH
184 # include <openssl/dh.h>
186 #ifndef OPENSSL_NO_SRP
187 # include <openssl/srp.h>
189 #include <openssl/bn.h>
191 #include "../ssl/ssl_locl.h"
194 * Or gethostname won't be declared properly
195 * on Compaq platforms (at least with DEC C).
196 * Do not try to put it earlier, or IPv6 includes
199 #define _XOPEN_SOURCE_EXTENDED 1
201 #ifdef OPENSSL_SYS_WINDOWS
202 # include <winsock.h>
204 # include OPENSSL_UNISTD
207 #ifdef OPENSSL_SYS_VMS
208 # define TEST_SERVER_CERT "SYS$DISK:[-.APPS]SERVER.PEM"
209 # define TEST_CLIENT_CERT "SYS$DISK:[-.APPS]CLIENT.PEM"
210 #elif defined(OPENSSL_SYS_WINCE)
211 # define TEST_SERVER_CERT "\\OpenSSL\\server.pem"
212 # define TEST_CLIENT_CERT "\\OpenSSL\\client.pem"
213 #elif defined(OPENSSL_SYS_NETWARE)
214 # define TEST_SERVER_CERT "\\openssl\\apps\\server.pem"
215 # define TEST_CLIENT_CERT "\\openssl\\apps\\client.pem"
217 # define TEST_SERVER_CERT "../apps/server.pem"
218 # define TEST_CLIENT_CERT "../apps/client.pem"
222 * There is really no standard for this, so let's assign something
227 static int verify_callback(int ok, X509_STORE_CTX *ctx);
228 #ifndef OPENSSL_NO_RSA
229 static RSA *tmp_rsa_cb(SSL *s, int is_export, int keylength);
230 static void free_tmp_rsa(void);
232 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg);
233 #define APP_CALLBACK_STRING "Test Callback Argument"
234 struct app_verify_arg {
237 int allow_proxy_certs;
242 #ifndef OPENSSL_NO_DH
243 static DH *get_dh512(void);
244 static DH *get_dh1024(void);
245 static DH *get_dh1024dsa(void);
248 static char *psk_key = NULL; /* by default PSK is not used */
249 #ifndef OPENSSL_NO_PSK
250 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
252 unsigned int max_identity_len,
254 unsigned int max_psk_len);
255 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
257 unsigned int max_psk_len);
260 #ifndef OPENSSL_NO_SRP
262 /* This is a context that we pass to all callbacks */
263 typedef struct srp_client_arg_st {
268 # define PWD_STRLEN 1024
270 static char *ssl_give_srp_client_pwd_cb(SSL *s, void *arg)
272 SRP_CLIENT_ARG *srp_client_arg = (SRP_CLIENT_ARG *)arg;
273 return BUF_strdup((char *)srp_client_arg->srppassin);
277 /* This is a context that we pass to SRP server callbacks */
278 typedef struct srp_server_arg_st {
283 static int ssl_srp_server_param_cb(SSL *s, int *ad, void *arg)
285 SRP_SERVER_ARG *p = (SRP_SERVER_ARG *)arg;
287 if (strcmp(p->expected_user, SSL_get_srp_username(s)) != 0) {
288 fprintf(stderr, "User %s doesn't exist\n", SSL_get_srp_username(s));
289 return SSL3_AL_FATAL;
291 if (SSL_set_srp_server_param_pw(s, p->expected_user, p->pass, "1024") < 0) {
292 *ad = SSL_AD_INTERNAL_ERROR;
293 return SSL3_AL_FATAL;
295 return SSL_ERROR_NONE;
299 static BIO *bio_err = NULL;
300 static BIO *bio_stdout = NULL;
302 #ifndef OPENSSL_NO_NEXTPROTONEG
303 /* Note that this code assumes that this is only a one element list: */
304 static const char NEXT_PROTO_STRING[] = "\x09testproto";
307 int npn_server_reject = 0;
309 static int cb_client_npn(SSL *s, unsigned char **out, unsigned char *outlen,
310 const unsigned char *in, unsigned int inlen,
314 * This callback only returns the protocol string, rather than a length
315 * prefixed set. We assume that NEXT_PROTO_STRING is a one element list
316 * and remove the first byte to chop off the length prefix.
318 *out = (unsigned char *)NEXT_PROTO_STRING + 1;
319 *outlen = sizeof(NEXT_PROTO_STRING) - 2;
320 return SSL_TLSEXT_ERR_OK;
323 static int cb_server_npn(SSL *s, const unsigned char **data,
324 unsigned int *len, void *arg)
326 *data = (const unsigned char *)NEXT_PROTO_STRING;
327 *len = sizeof(NEXT_PROTO_STRING) - 1;
328 return SSL_TLSEXT_ERR_OK;
331 static int cb_server_rejects_npn(SSL *s, const unsigned char **data,
332 unsigned int *len, void *arg)
334 return SSL_TLSEXT_ERR_NOACK;
337 static int verify_npn(SSL *client, SSL *server)
339 const unsigned char *client_s;
341 const unsigned char *server_s;
344 SSL_get0_next_proto_negotiated(client, &client_s, &client_len);
345 SSL_get0_next_proto_negotiated(server, &server_s, &server_len);
348 BIO_printf(bio_stdout, "Client NPN: ");
349 BIO_write(bio_stdout, client_s, client_len);
350 BIO_printf(bio_stdout, "\n");
354 BIO_printf(bio_stdout, "Server NPN: ");
355 BIO_write(bio_stdout, server_s, server_len);
356 BIO_printf(bio_stdout, "\n");
360 * If an NPN string was returned, it must be the protocol that we
361 * expected to negotiate.
363 if (client_len && (client_len != sizeof(NEXT_PROTO_STRING) - 2 ||
364 memcmp(client_s, NEXT_PROTO_STRING + 1, client_len)))
366 if (server_len && (server_len != sizeof(NEXT_PROTO_STRING) - 2 ||
367 memcmp(server_s, NEXT_PROTO_STRING + 1, server_len)))
370 if (!npn_client && client_len)
372 if (!npn_server && server_len)
374 if (npn_server_reject && server_len)
376 if (npn_client && npn_server && (!client_len || !server_len))
383 static const char *alpn_client;
384 static const char *alpn_server;
385 static const char *alpn_expected;
386 static unsigned char *alpn_selected;
389 * next_protos_parse parses a comma separated list of strings into a string
390 * in a format suitable for passing to SSL_CTX_set_next_protos_advertised.
391 * outlen: (output) set to the length of the resulting buffer on success.
392 * err: (maybe NULL) on failure, an error message line is written to this BIO.
393 * in: a NUL terminated string like "abc,def,ghi"
395 * returns: a malloced buffer or NULL on failure.
397 static unsigned char *next_protos_parse(unsigned short *outlen,
408 out = OPENSSL_malloc(strlen(in) + 1);
412 for (i = 0; i <= len; ++i) {
413 if (i == len || in[i] == ',') {
414 if (i - start > 255) {
418 out[start] = i - start;
428 static int cb_server_alpn(SSL *s, const unsigned char **out,
429 unsigned char *outlen, const unsigned char *in,
430 unsigned int inlen, void *arg)
432 unsigned char *protos;
433 unsigned short protos_len;
435 protos = next_protos_parse(&protos_len, alpn_server);
436 if (protos == NULL) {
437 fprintf(stderr, "failed to parser ALPN server protocol string: %s\n",
442 if (SSL_select_next_proto
443 ((unsigned char **)out, outlen, protos, protos_len, in,
444 inlen) != OPENSSL_NPN_NEGOTIATED) {
445 OPENSSL_free(protos);
446 return SSL_TLSEXT_ERR_NOACK;
450 * Make a copy of the selected protocol which will be freed in
453 alpn_selected = OPENSSL_malloc(*outlen);
454 memcpy(alpn_selected, *out, *outlen);
455 *out = alpn_selected;
457 OPENSSL_free(protos);
458 return SSL_TLSEXT_ERR_OK;
461 static int verify_alpn(SSL *client, SSL *server)
463 const unsigned char *client_proto, *server_proto;
464 unsigned int client_proto_len = 0, server_proto_len = 0;
465 SSL_get0_alpn_selected(client, &client_proto, &client_proto_len);
466 SSL_get0_alpn_selected(server, &server_proto, &server_proto_len);
468 OPENSSL_free(alpn_selected);
469 alpn_selected = NULL;
471 if (client_proto_len != server_proto_len ||
472 memcmp(client_proto, server_proto, client_proto_len) != 0) {
473 BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");
477 if (client_proto_len > 0 && alpn_expected == NULL) {
478 BIO_printf(bio_stdout, "ALPN unexpectedly negotiated\n");
482 if (alpn_expected != NULL &&
483 (client_proto_len != strlen(alpn_expected) ||
484 memcmp(client_proto, alpn_expected, client_proto_len) != 0)) {
485 BIO_printf(bio_stdout,
486 "ALPN selected protocols not equal to expected protocol: %s\n",
494 BIO_printf(bio_stdout, "ALPN results: client: '");
495 BIO_write(bio_stdout, client_proto, client_proto_len);
496 BIO_printf(bio_stdout, "', server: '");
497 BIO_write(bio_stdout, server_proto, server_proto_len);
498 BIO_printf(bio_stdout, "'\n");
499 BIO_printf(bio_stdout, "ALPN configured: client: '%s', server: '%s'\n",
500 alpn_client, alpn_server);
504 #define SCT_EXT_TYPE 18
507 * WARNING : below extension types are *NOT* IETF assigned, and could
508 * conflict if these types are reassigned and handled specially by OpenSSL
511 #define TACK_EXT_TYPE 62208
512 #define CUSTOM_EXT_TYPE_0 1000
513 #define CUSTOM_EXT_TYPE_1 1001
514 #define CUSTOM_EXT_TYPE_2 1002
515 #define CUSTOM_EXT_TYPE_3 1003
517 const char custom_ext_cli_string[] = "abc";
518 const char custom_ext_srv_string[] = "defg";
520 /* These set from cmdline */
521 char *serverinfo_file = NULL;
522 int serverinfo_sct = 0;
523 int serverinfo_tack = 0;
525 /* These set based on extension callbacks */
526 int serverinfo_sct_seen = 0;
527 int serverinfo_tack_seen = 0;
528 int serverinfo_other_seen = 0;
530 /* This set from cmdline */
533 /* This set based on extension callbacks */
534 int custom_ext_error = 0;
536 static int serverinfo_cli_parse_cb(SSL *s, unsigned int ext_type,
537 const unsigned char *in, size_t inlen,
540 if (ext_type == SCT_EXT_TYPE)
541 serverinfo_sct_seen++;
542 else if (ext_type == TACK_EXT_TYPE)
543 serverinfo_tack_seen++;
545 serverinfo_other_seen++;
549 static int verify_serverinfo()
551 if (serverinfo_sct != serverinfo_sct_seen)
553 if (serverinfo_tack != serverinfo_tack_seen)
555 if (serverinfo_other_seen)
561 * Four test cases for custom extensions:
562 * 0 - no ClientHello extension or ServerHello response
563 * 1 - ClientHello with "abc", no response
564 * 2 - ClientHello with "abc", empty response
565 * 3 - ClientHello with "abc", "defg" response
568 static int custom_ext_0_cli_add_cb(SSL *s, unsigned int ext_type,
569 const unsigned char **out,
570 size_t *outlen, int *al, void *arg)
572 if (ext_type != CUSTOM_EXT_TYPE_0)
573 custom_ext_error = 1;
574 return 0; /* Don't send an extension */
577 static int custom_ext_0_cli_parse_cb(SSL *s, unsigned int ext_type,
578 const unsigned char *in,
579 size_t inlen, int *al, void *arg)
584 static int custom_ext_1_cli_add_cb(SSL *s, unsigned int ext_type,
585 const unsigned char **out,
586 size_t *outlen, int *al, void *arg)
588 if (ext_type != CUSTOM_EXT_TYPE_1)
589 custom_ext_error = 1;
590 *out = (const unsigned char *)custom_ext_cli_string;
591 *outlen = strlen(custom_ext_cli_string);
592 return 1; /* Send "abc" */
595 static int custom_ext_1_cli_parse_cb(SSL *s, unsigned int ext_type,
596 const unsigned char *in,
597 size_t inlen, int *al, void *arg)
602 static int custom_ext_2_cli_add_cb(SSL *s, unsigned int ext_type,
603 const unsigned char **out,
604 size_t *outlen, int *al, void *arg)
606 if (ext_type != CUSTOM_EXT_TYPE_2)
607 custom_ext_error = 1;
608 *out = (const unsigned char *)custom_ext_cli_string;
609 *outlen = strlen(custom_ext_cli_string);
610 return 1; /* Send "abc" */
613 static int custom_ext_2_cli_parse_cb(SSL *s, unsigned int ext_type,
614 const unsigned char *in,
615 size_t inlen, int *al, void *arg)
617 if (ext_type != CUSTOM_EXT_TYPE_2)
618 custom_ext_error = 1;
620 custom_ext_error = 1; /* Should be empty response */
624 static int custom_ext_3_cli_add_cb(SSL *s, unsigned int ext_type,
625 const unsigned char **out,
626 size_t *outlen, int *al, void *arg)
628 if (ext_type != CUSTOM_EXT_TYPE_3)
629 custom_ext_error = 1;
630 *out = (const unsigned char *)custom_ext_cli_string;
631 *outlen = strlen(custom_ext_cli_string);
632 return 1; /* Send "abc" */
635 static int custom_ext_3_cli_parse_cb(SSL *s, unsigned int ext_type,
636 const unsigned char *in,
637 size_t inlen, int *al, void *arg)
639 if (ext_type != CUSTOM_EXT_TYPE_3)
640 custom_ext_error = 1;
641 if (inlen != strlen(custom_ext_srv_string))
642 custom_ext_error = 1;
643 if (memcmp(custom_ext_srv_string, in, inlen) != 0)
644 custom_ext_error = 1; /* Check for "defg" */
649 * custom_ext_0_cli_add_cb returns 0 - the server won't receive a callback
652 static int custom_ext_0_srv_parse_cb(SSL *s, unsigned int ext_type,
653 const unsigned char *in,
654 size_t inlen, int *al, void *arg)
656 custom_ext_error = 1;
660 /* 'add' callbacks are only called if the 'parse' callback is called */
661 static int custom_ext_0_srv_add_cb(SSL *s, unsigned int ext_type,
662 const unsigned char **out,
663 size_t *outlen, int *al, void *arg)
665 /* Error: should not have been called */
666 custom_ext_error = 1;
667 return 0; /* Don't send an extension */
670 static int custom_ext_1_srv_parse_cb(SSL *s, unsigned int ext_type,
671 const unsigned char *in,
672 size_t inlen, int *al, void *arg)
674 if (ext_type != CUSTOM_EXT_TYPE_1)
675 custom_ext_error = 1;
676 /* Check for "abc" */
677 if (inlen != strlen(custom_ext_cli_string))
678 custom_ext_error = 1;
679 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
680 custom_ext_error = 1;
684 static int custom_ext_1_srv_add_cb(SSL *s, unsigned int ext_type,
685 const unsigned char **out,
686 size_t *outlen, int *al, void *arg)
688 return 0; /* Don't send an extension */
691 static int custom_ext_2_srv_parse_cb(SSL *s, unsigned int ext_type,
692 const unsigned char *in,
693 size_t inlen, int *al, void *arg)
695 if (ext_type != CUSTOM_EXT_TYPE_2)
696 custom_ext_error = 1;
697 /* Check for "abc" */
698 if (inlen != strlen(custom_ext_cli_string))
699 custom_ext_error = 1;
700 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
701 custom_ext_error = 1;
705 static int custom_ext_2_srv_add_cb(SSL *s, unsigned int ext_type,
706 const unsigned char **out,
707 size_t *outlen, int *al, void *arg)
711 return 1; /* Send empty extension */
714 static int custom_ext_3_srv_parse_cb(SSL *s, unsigned int ext_type,
715 const unsigned char *in,
716 size_t inlen, int *al, void *arg)
718 if (ext_type != CUSTOM_EXT_TYPE_3)
719 custom_ext_error = 1;
720 /* Check for "abc" */
721 if (inlen != strlen(custom_ext_cli_string))
722 custom_ext_error = 1;
723 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
724 custom_ext_error = 1;
728 static int custom_ext_3_srv_add_cb(SSL *s, unsigned int ext_type,
729 const unsigned char **out,
730 size_t *outlen, int *al, void *arg)
732 *out = (const unsigned char *)custom_ext_srv_string;
733 *outlen = strlen(custom_ext_srv_string);
734 return 1; /* Send "defg" */
737 static char *cipher = NULL;
738 static int verbose = 0;
739 static int debug = 0;
740 static const char rnd_seed[] =
741 "string to make the random number generator think it has entropy";
743 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long bytes, clock_t *s_time,
745 int doit(SSL *s_ssl, SSL *c_ssl, long bytes);
746 static int do_test_cipherlist(void);
748 static void sv_usage(void)
750 fprintf(stderr, "usage: ssltest [args ...]\n");
751 fprintf(stderr, "\n");
753 fprintf(stderr, "-F - run test in FIPS mode\n");
755 fprintf(stderr, " -server_auth - check server certificate\n");
756 fprintf(stderr, " -client_auth - do client authentication\n");
757 fprintf(stderr, " -proxy - allow proxy certificates\n");
758 fprintf(stderr, " -proxy_auth <val> - set proxy policy rights\n");
760 " -proxy_cond <val> - expression to test proxy policy rights\n");
761 fprintf(stderr, " -v - more output\n");
762 fprintf(stderr, " -d - debug output\n");
763 fprintf(stderr, " -reuse - use session-id reuse\n");
764 fprintf(stderr, " -num <val> - number of connections to perform\n");
766 " -bytes <val> - number of bytes to swap between client/server\n");
767 #ifndef OPENSSL_NO_DH
769 " -dhe512 - use 512 bit key for DHE (to test failure)\n");
771 " -dhe1024 - use 1024 bit key (safe prime) for DHE (default, no-op)\n");
773 " -dhe1024dsa - use 1024 bit key (with 160-bit subprime) for DHE\n");
774 fprintf(stderr, " -no_dhe - disable DHE\n");
776 #ifndef OPENSSL_NO_EC
777 fprintf(stderr, " -no_ecdhe - disable ECDHE\n");
779 #ifndef OPENSSL_NO_PSK
780 fprintf(stderr, " -psk arg - PSK in hex (without 0x)\n");
782 #ifndef OPENSSL_NO_SRP
783 fprintf(stderr, " -srpuser user - SRP username to use\n");
784 fprintf(stderr, " -srppass arg - password for 'user'\n");
786 #ifndef OPENSSL_NO_SSL3_METHOD
787 fprintf(stderr, " -ssl3 - use SSLv3\n");
789 fprintf(stderr, " -tls1 - use TLSv1\n");
790 #ifndef OPENSSL_NO_DTLS
791 fprintf(stderr, " -dtls1 - use DTLSv1\n");
792 fprintf(stderr, " -dtls12 - use DTLSv1.2\n");
794 fprintf(stderr, " -CApath arg - PEM format directory of CA's\n");
795 fprintf(stderr, " -CAfile arg - PEM format file of CA's\n");
796 fprintf(stderr, " -cert arg - Server certificate file\n");
798 " -key arg - Server key file (default: same as -cert)\n");
799 fprintf(stderr, " -c_cert arg - Client certificate file\n");
801 " -c_key arg - Client key file (default: same as -c_cert)\n");
802 fprintf(stderr, " -cipher arg - The cipher list\n");
803 fprintf(stderr, " -bio_pair - Use BIO pairs\n");
804 fprintf(stderr, " -f - Test even cases that can't work\n");
806 " -time - measure processor time used by client and server\n");
807 fprintf(stderr, " -zlib - use zlib compression\n");
808 #ifndef OPENSSL_NO_EC
810 " -named_curve arg - Elliptic curve name to use for ephemeral ECDH keys.\n"
811 " Use \"openssl ecparam -list_curves\" for all names\n"
812 " (default is sect163r2).\n");
815 " -test_cipherlist - Verifies the order of the ssl cipher lists.\n"
816 " When this option is requested, the cipherlist\n"
817 " tests are run instead of handshake tests.\n");
818 #ifndef OPENSSL_NO_NEXTPROTONEG
819 fprintf(stderr, " -npn_client - have client side offer NPN\n");
820 fprintf(stderr, " -npn_server - have server side offer NPN\n");
821 fprintf(stderr, " -npn_server_reject - have server reject NPN\n");
823 fprintf(stderr, " -serverinfo_file file - have server use this file\n");
824 fprintf(stderr, " -serverinfo_sct - have client offer and expect SCT\n");
826 " -serverinfo_tack - have client offer and expect TACK\n");
828 " -custom_ext - try various custom extension callbacks\n");
829 fprintf(stderr, " -alpn_client <string> - have client side offer ALPN\n");
830 fprintf(stderr, " -alpn_server <string> - have server side offer ALPN\n");
832 " -alpn_expected <string> - the ALPN protocol that should be negotiated\n");
835 static void print_key_details(BIO *out, EVP_PKEY *key)
837 int keyid = EVP_PKEY_id(key);
838 #ifndef OPENSSL_NO_EC
839 if (keyid == EVP_PKEY_EC) {
840 EC_KEY *ec = EVP_PKEY_get1_EC_KEY(key);
843 nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
845 cname = EC_curve_nid2nist(nid);
847 cname = OBJ_nid2sn(nid);
848 BIO_printf(out, "%d bits EC (%s)", EVP_PKEY_bits(key), cname);
864 algname = OBJ_nid2sn(keyid);
867 BIO_printf(out, "%d bits %s", EVP_PKEY_bits(key), algname);
871 static void print_details(SSL *c_ssl, const char *prefix)
873 const SSL_CIPHER *ciph;
878 ciph = SSL_get_current_cipher(c_ssl);
879 BIO_printf(bio_stdout, "%s%s, cipher %s %s",
881 SSL_get_version(c_ssl),
882 SSL_CIPHER_get_version(ciph), SSL_CIPHER_get_name(ciph));
883 cert = SSL_get_peer_certificate(c_ssl);
885 pkey = X509_get_pubkey(cert);
887 BIO_puts(bio_stdout, ", ");
888 print_key_details(bio_stdout, pkey);
893 if (SSL_get_server_tmp_key(c_ssl, &pkey)) {
894 BIO_puts(bio_stdout, ", temp key: ");
895 print_key_details(bio_stdout, pkey);
898 if (SSL_get_peer_signature_nid(c_ssl, &mdnid))
899 BIO_printf(bio_stdout, ", digest=%s", OBJ_nid2sn(mdnid));
900 BIO_printf(bio_stdout, "\n");
903 static void lock_dbg_cb(int mode, int type, const char *file, int line)
905 static int modes[CRYPTO_NUM_LOCKS]; /* = {0, 0, ... } */
906 const char *errstr = NULL;
909 rw = mode & (CRYPTO_READ | CRYPTO_WRITE);
910 if (!((rw == CRYPTO_READ) || (rw == CRYPTO_WRITE))) {
911 errstr = "invalid mode";
915 if (type < 0 || type >= CRYPTO_NUM_LOCKS) {
916 errstr = "type out of bounds";
920 if (mode & CRYPTO_LOCK) {
922 errstr = "already locked";
924 * must not happen in a single-threaded program (would deadlock)
930 } else if (mode & CRYPTO_UNLOCK) {
932 errstr = "not locked";
936 if (modes[type] != rw) {
937 errstr = (rw == CRYPTO_READ) ?
938 "CRYPTO_r_unlock on write lock" :
939 "CRYPTO_w_unlock on read lock";
944 errstr = "invalid mode";
950 /* we cannot use bio_err here */
952 "openssl (lock_dbg_cb): %s (mode=%d, type=%d) at %s:%d\n",
953 errstr, mode, type, file, line);
957 int main(int argc, char *argv[])
959 char *CApath = NULL, *CAfile = NULL;
963 int dtls1 = 0, dtls12 = 0, tls1 = 0, ssl3 = 0, ret = 1;
965 int server_auth = 0, i;
966 struct app_verify_arg app_verify_arg =
967 { APP_CALLBACK_STRING, 0, 0, NULL, NULL };
968 char *server_cert = TEST_SERVER_CERT;
969 char *server_key = NULL;
970 char *client_cert = TEST_CLIENT_CERT;
971 char *client_key = NULL;
972 #ifndef OPENSSL_NO_EC
973 char *named_curve = NULL;
975 SSL_CTX *s_ctx = NULL;
976 SSL_CTX *c_ctx = NULL;
977 const SSL_METHOD *meth = NULL;
979 int number = 1, reuse = 0;
981 #ifndef OPENSSL_NO_DH
983 int dhe512 = 0, dhe1024dsa = 0;
985 #ifndef OPENSSL_NO_EC
988 #ifndef OPENSSL_NO_SRP
990 SRP_CLIENT_ARG srp_client_arg = { NULL, NULL };
992 SRP_SERVER_ARG srp_server_arg = { NULL, NULL };
998 clock_t s_time = 0, c_time = 0;
999 #ifndef OPENSSL_NO_COMP
1001 COMP_METHOD *cm = NULL;
1002 STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
1004 int test_cipherlist = 0;
1008 int no_protocol = 0;
1010 SSL_CONF_CTX *s_cctx = NULL, *c_cctx = NULL;
1011 STACK_OF(OPENSSL_STRING) *conf_args = NULL;
1012 const char *arg = NULL, *argn = NULL;
1018 bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
1020 CRYPTO_set_locking_callback(lock_dbg_cb);
1022 /* enable memory leak checking unless explicitly disabled */
1023 if (!((getenv("OPENSSL_DEBUG_MEMORY") != NULL)
1024 && (0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off")))) {
1025 CRYPTO_malloc_debug_init();
1026 CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
1028 /* OPENSSL_DEBUG_MEMORY=off */
1029 CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);
1031 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
1033 RAND_seed(rnd_seed, sizeof rnd_seed);
1035 bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);
1037 s_cctx = SSL_CONF_CTX_new();
1038 c_cctx = SSL_CONF_CTX_new();
1040 if (!s_cctx || !c_cctx) {
1041 ERR_print_errors(bio_err);
1045 SSL_CONF_CTX_set_flags(s_cctx,
1046 SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_SERVER);
1047 if (!SSL_CONF_CTX_set1_prefix(s_cctx, "-s_")) {
1048 ERR_print_errors(bio_err);
1052 SSL_CONF_CTX_set_flags(c_cctx,
1053 SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_CLIENT);
1054 if (!SSL_CONF_CTX_set1_prefix(c_cctx, "-c_")) {
1055 ERR_print_errors(bio_err);
1063 if (strcmp(*argv, "-F") == 0) {
1068 "not compiled with FIPS support, so exiting without running.\n");
1071 } else if (strcmp(*argv, "-server_auth") == 0)
1073 else if (strcmp(*argv, "-client_auth") == 0)
1075 else if (strcmp(*argv, "-proxy_auth") == 0) {
1078 app_verify_arg.proxy_auth = *(++argv);
1079 } else if (strcmp(*argv, "-proxy_cond") == 0) {
1082 app_verify_arg.proxy_cond = *(++argv);
1083 } else if (strcmp(*argv, "-v") == 0)
1085 else if (strcmp(*argv, "-d") == 0)
1087 else if (strcmp(*argv, "-reuse") == 0)
1089 else if (strcmp(*argv, "-dhe512") == 0) {
1090 #ifndef OPENSSL_NO_DH
1094 "ignoring -dhe512, since I'm compiled without DH\n");
1096 } else if (strcmp(*argv, "-dhe1024dsa") == 0) {
1097 #ifndef OPENSSL_NO_DH
1101 "ignoring -dhe1024dsa, since I'm compiled without DH\n");
1103 } else if (strcmp(*argv, "-no_dhe") == 0)
1105 else if (strcmp(*argv, "-no_ecdhe") == 0)
1107 else if (strcmp(*argv, "-psk") == 0) {
1110 psk_key = *(++argv);
1111 #ifndef OPENSSL_NO_PSK
1112 if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key)) {
1113 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
1120 #ifndef OPENSSL_NO_SRP
1121 else if (strcmp(*argv, "-srpuser") == 0) {
1124 srp_server_arg.expected_user = srp_client_arg.srplogin =
1127 } else if (strcmp(*argv, "-srppass") == 0) {
1130 srp_server_arg.pass = srp_client_arg.srppassin = *(++argv);
1134 else if (strcmp(*argv, "-tls1") == 0) {
1136 } else if (strcmp(*argv, "-ssl3") == 0) {
1137 #ifdef OPENSSL_NO_SSL3_METHOD
1141 } else if (strcmp(*argv, "-dtls1") == 0) {
1142 #ifdef OPENSSL_NO_DTLS
1146 } else if (strcmp(*argv, "-dtls12") == 0) {
1147 #ifdef OPENSSL_NO_DTLS
1151 } else if (strncmp(*argv, "-num", 4) == 0) {
1154 number = atoi(*(++argv));
1157 } else if (strcmp(*argv, "-bytes") == 0) {
1160 bytes = atol(*(++argv));
1163 i = strlen(argv[0]);
1164 if (argv[0][i - 1] == 'k')
1166 if (argv[0][i - 1] == 'm')
1167 bytes *= 1024L * 1024L;
1168 } else if (strcmp(*argv, "-cert") == 0) {
1171 server_cert = *(++argv);
1172 } else if (strcmp(*argv, "-s_cert") == 0) {
1175 server_cert = *(++argv);
1176 } else if (strcmp(*argv, "-key") == 0) {
1179 server_key = *(++argv);
1180 } else if (strcmp(*argv, "-s_key") == 0) {
1183 server_key = *(++argv);
1184 } else if (strcmp(*argv, "-c_cert") == 0) {
1187 client_cert = *(++argv);
1188 } else if (strcmp(*argv, "-c_key") == 0) {
1191 client_key = *(++argv);
1192 } else if (strcmp(*argv, "-cipher") == 0) {
1196 } else if (strcmp(*argv, "-CApath") == 0) {
1200 } else if (strcmp(*argv, "-CAfile") == 0) {
1204 } else if (strcmp(*argv, "-bio_pair") == 0) {
1206 } else if (strcmp(*argv, "-f") == 0) {
1208 } else if (strcmp(*argv, "-time") == 0) {
1211 #ifndef OPENSSL_NO_COMP
1212 else if (strcmp(*argv, "-zlib") == 0) {
1216 else if (strcmp(*argv, "-named_curve") == 0) {
1219 #ifndef OPENSSL_NO_EC
1220 named_curve = *(++argv);
1223 "ignoring -named_curve, since I'm compiled without ECDH\n");
1226 } else if (strcmp(*argv, "-app_verify") == 0) {
1227 app_verify_arg.app_verify = 1;
1228 } else if (strcmp(*argv, "-proxy") == 0) {
1229 app_verify_arg.allow_proxy_certs = 1;
1230 } else if (strcmp(*argv, "-test_cipherlist") == 0) {
1231 test_cipherlist = 1;
1233 #ifndef OPENSSL_NO_NEXTPROTONEG
1234 else if (strcmp(*argv, "-npn_client") == 0) {
1236 } else if (strcmp(*argv, "-npn_server") == 0) {
1238 } else if (strcmp(*argv, "-npn_server_reject") == 0) {
1239 npn_server_reject = 1;
1242 else if (strcmp(*argv, "-serverinfo_sct") == 0) {
1244 } else if (strcmp(*argv, "-serverinfo_tack") == 0) {
1245 serverinfo_tack = 1;
1246 } else if (strcmp(*argv, "-serverinfo_file") == 0) {
1249 serverinfo_file = *(++argv);
1250 } else if (strcmp(*argv, "-custom_ext") == 0) {
1252 } else if (strcmp(*argv, "-alpn_client") == 0) {
1255 alpn_client = *(++argv);
1256 } else if (strcmp(*argv, "-alpn_server") == 0) {
1259 alpn_server = *(++argv);
1260 } else if (strcmp(*argv, "-alpn_expected") == 0) {
1263 alpn_expected = *(++argv);
1268 /* Try to process command using SSL_CONF */
1269 rv = SSL_CONF_cmd_argv(c_cctx, &argc, &argv);
1270 /* If not processed try server */
1272 rv = SSL_CONF_cmd_argv(s_cctx, &argc, &argv);
1273 /* Recognised: store it for later use */
1278 conf_args = sk_OPENSSL_STRING_new_null();
1282 if (!sk_OPENSSL_STRING_push(conf_args, arg))
1284 if (!sk_OPENSSL_STRING_push(conf_args, argn))
1289 BIO_printf(bio_err, "Missing argument for %s\n", arg);
1291 BIO_printf(bio_err, "Error with command %s\n", arg);
1293 BIO_printf(bio_err, "unknown option %s\n", arg);
1307 * test_cipherlist prevails over protocol switch: we test the cipherlist
1308 * for all enabled protocols.
1310 if (test_cipherlist == 1) {
1312 * ensure that the cipher list are correctly sorted and exit
1314 fprintf(stdout, "Testing cipherlist order only. Ignoring all "
1315 "other options.\n");
1316 if (do_test_cipherlist() == 0)
1322 if (ssl3 + tls1 + dtls1 + dtls12 > 1) {
1323 fprintf(stderr, "At most one of -ssl3, -tls1, -dtls1 or -dtls12 should "
1329 * Testing was requested for a compiled-out protocol (e.g. SSLv3).
1330 * Ideally, we would error out, but the generic test wrapper can't know
1331 * when to expect failure. So we do nothing and return success.
1334 fprintf(stderr, "Testing was requested for a disabled protocol. "
1335 "Skipping tests.\n");
1340 if (!ssl3 && !tls1 && !dtls1 && !dtls12 && number > 1 && !reuse && !force) {
1341 fprintf(stderr, "This case cannot work. Use -f to perform "
1342 "the test anyway (and\n-d to see what happens), "
1343 "or add one of -ssl3, -tls1, -dtls1, -dtls12, -reuse\n"
1344 "to avoid protocol mismatch.\n");
1349 if (!FIPS_mode_set(1)) {
1350 ERR_load_crypto_strings();
1351 ERR_print_errors(BIO_new_fp(stderr, BIO_NOCLOSE));
1354 fprintf(stderr, "*** IN FIPS MODE ***\n");
1360 fprintf(stderr, "Using BIO pair (-bio_pair)\n");
1363 if (number < 50 && !force)
1365 "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
1368 /* if (cipher == NULL) cipher=getenv("SSL_CIPHER"); */
1371 SSL_load_error_strings();
1373 #ifndef OPENSSL_NO_COMP
1374 if (comp == COMP_ZLIB)
1377 if (COMP_get_type(cm) != NID_undef) {
1378 if (SSL_COMP_add_compression_method(comp, cm) != 0) {
1379 fprintf(stderr, "Failed to add compression method\n");
1380 ERR_print_errors_fp(stderr);
1384 "Warning: %s compression not supported\n",
1385 comp == COMP_ZLIB ? "zlib" : "unknown");
1386 ERR_print_errors_fp(stderr);
1389 ssl_comp_methods = SSL_COMP_get_compression_methods();
1390 n = sk_SSL_COMP_num(ssl_comp_methods);
1393 printf("Available compression methods:");
1394 for (j = 0; j < n; j++) {
1395 SSL_COMP *c = sk_SSL_COMP_value(ssl_comp_methods, j);
1396 printf(" %s:%d", c->name, c->id);
1403 * At this point, ssl3/tls1 is only set if the protocol is available.
1404 * (Otherwise we exit early.) However the compiler doesn't know this, so
1407 #ifndef OPENSSL_NO_SSL3
1409 meth = SSLv3_method();
1412 #ifndef OPENSSL_NO_DTLS
1414 meth = DTLSv1_method();
1416 meth = DTLSv1_2_method();
1420 meth = TLSv1_method();
1422 meth = TLS_method();
1424 c_ctx = SSL_CTX_new(meth);
1425 s_ctx = SSL_CTX_new(meth);
1426 if ((c_ctx == NULL) || (s_ctx == NULL)) {
1427 ERR_print_errors(bio_err);
1431 * Since we will use low security ciphersuites and keys for testing set
1432 * security level to zero by default. Tests can override this by adding
1433 * "@SECLEVEL=n" to the cipher string.
1435 SSL_CTX_set_security_level(c_ctx, 0);
1436 SSL_CTX_set_security_level(s_ctx, 0);
1438 if (cipher != NULL) {
1439 if (!SSL_CTX_set_cipher_list(c_ctx, cipher)
1440 || !SSL_CTX_set_cipher_list(s_ctx, cipher)) {
1441 ERR_print_errors(bio_err);
1446 /* Process SSL_CONF arguments */
1447 SSL_CONF_CTX_set_ssl_ctx(c_cctx, c_ctx);
1448 SSL_CONF_CTX_set_ssl_ctx(s_cctx, s_ctx);
1450 for (i = 0; i < sk_OPENSSL_STRING_num(conf_args); i += 2) {
1452 arg = sk_OPENSSL_STRING_value(conf_args, i);
1453 argn = sk_OPENSSL_STRING_value(conf_args, i + 1);
1454 rv = SSL_CONF_cmd(c_cctx, arg, argn);
1455 /* If not recognised use server context */
1457 rv = SSL_CONF_cmd(s_cctx, arg, argn);
1459 BIO_printf(bio_err, "Error processing %s %s\n",
1460 arg, argn ? argn : "");
1461 ERR_print_errors(bio_err);
1466 if (!SSL_CONF_CTX_finish(s_cctx) || !SSL_CONF_CTX_finish(c_cctx)) {
1467 BIO_puts(bio_err, "Error finishing context\n");
1468 ERR_print_errors(bio_err);
1471 #ifndef OPENSSL_NO_DH
1475 * use SSL_OP_SINGLE_DH_USE to avoid small subgroup attacks
1477 SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_DH_USE);
1478 dh = get_dh1024dsa();
1483 SSL_CTX_set_tmp_dh(s_ctx, dh);
1490 #ifndef OPENSSL_NO_EC
1494 if (named_curve != NULL) {
1495 nid = OBJ_sn2nid(named_curve);
1497 BIO_printf(bio_err, "unknown curve name (%s)\n", named_curve);
1501 nid = NID_X9_62_prime256v1;
1504 ecdh = EC_KEY_new_by_curve_name(nid);
1506 BIO_printf(bio_err, "unable to create curve\n");
1510 SSL_CTX_set_tmp_ecdh(s_ctx, ecdh);
1511 SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_ECDH_USE);
1518 #ifndef OPENSSL_NO_RSA
1519 SSL_CTX_set_tmp_rsa_callback(s_ctx, tmp_rsa_cb);
1522 if (!SSL_CTX_use_certificate_file(s_ctx, server_cert, SSL_FILETYPE_PEM)) {
1523 ERR_print_errors(bio_err);
1524 } else if (!SSL_CTX_use_PrivateKey_file(s_ctx,
1525 (server_key ? server_key :
1527 SSL_FILETYPE_PEM)) {
1528 ERR_print_errors(bio_err);
1533 if (!SSL_CTX_use_certificate_file(c_ctx, client_cert, SSL_FILETYPE_PEM)
1534 || !SSL_CTX_use_PrivateKey_file(c_ctx,
1535 (client_key ? client_key : client_cert),
1536 SSL_FILETYPE_PEM)) {
1537 ERR_print_errors(bio_err);
1542 if ((!SSL_CTX_load_verify_locations(s_ctx, CAfile, CApath)) ||
1543 (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1544 (!SSL_CTX_load_verify_locations(c_ctx, CAfile, CApath)) ||
1545 (!SSL_CTX_set_default_verify_paths(c_ctx))) {
1546 /* fprintf(stderr,"SSL_load_verify_locations\n"); */
1547 ERR_print_errors(bio_err);
1552 printf("client authentication\n");
1553 SSL_CTX_set_verify(s_ctx,
1554 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1556 SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback,
1560 printf("server authentication\n");
1561 SSL_CTX_set_verify(c_ctx, SSL_VERIFY_PEER, verify_callback);
1562 SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback,
1567 int session_id_context = 0;
1568 if (!SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context,
1569 sizeof session_id_context)) {
1570 ERR_print_errors(bio_err);
1575 /* Use PSK only if PSK key is given */
1576 if (psk_key != NULL) {
1578 * no_psk is used to avoid putting psk command to openssl tool
1582 * if PSK is not compiled in and psk key is given, do nothing and
1588 #ifndef OPENSSL_NO_PSK
1589 SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1590 SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1592 BIO_printf(bio_err, "setting PSK identity hint to s_ctx\n");
1593 if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint")) {
1594 BIO_printf(bio_err, "error setting PSK identity hint to s_ctx\n");
1595 ERR_print_errors(bio_err);
1600 #ifndef OPENSSL_NO_SRP
1601 if (srp_client_arg.srplogin) {
1602 if (!SSL_CTX_set_srp_username(c_ctx, srp_client_arg.srplogin)) {
1603 BIO_printf(bio_err, "Unable to set SRP username\n");
1606 SSL_CTX_set_srp_cb_arg(c_ctx, &srp_client_arg);
1607 SSL_CTX_set_srp_client_pwd_callback(c_ctx,
1608 ssl_give_srp_client_pwd_cb);
1610 * SSL_CTX_set_srp_strength(c_ctx, srp_client_arg.strength);
1614 if (srp_server_arg.expected_user != NULL) {
1615 SSL_CTX_set_verify(s_ctx, SSL_VERIFY_NONE, verify_callback);
1616 SSL_CTX_set_srp_cb_arg(s_ctx, &srp_server_arg);
1617 SSL_CTX_set_srp_username_callback(s_ctx, ssl_srp_server_param_cb);
1621 #ifndef OPENSSL_NO_NEXTPROTONEG
1623 SSL_CTX_set_next_proto_select_cb(c_ctx, cb_client_npn, NULL);
1626 if (npn_server_reject) {
1628 "Can't have both -npn_server and -npn_server_reject\n");
1631 SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_npn, NULL);
1633 if (npn_server_reject) {
1634 SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_rejects_npn,
1639 if (serverinfo_sct) {
1640 if (!SSL_CTX_add_client_custom_ext(c_ctx, SCT_EXT_TYPE,
1642 serverinfo_cli_parse_cb, NULL)) {
1643 BIO_printf(bio_err, "Error adding SCT extension\n");
1647 if (serverinfo_tack) {
1648 if (!SSL_CTX_add_client_custom_ext(c_ctx, TACK_EXT_TYPE,
1650 serverinfo_cli_parse_cb, NULL)) {
1651 BIO_printf(bio_err, "Error adding TACK extension\n");
1655 if (serverinfo_file)
1656 if (!SSL_CTX_use_serverinfo_file(s_ctx, serverinfo_file)) {
1657 BIO_printf(bio_err, "missing serverinfo file\n");
1662 if (!SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_0,
1663 custom_ext_0_cli_add_cb,
1665 custom_ext_0_cli_parse_cb, NULL)
1666 || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_1,
1667 custom_ext_1_cli_add_cb,
1669 custom_ext_1_cli_parse_cb, NULL)
1670 || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_2,
1671 custom_ext_2_cli_add_cb,
1673 custom_ext_2_cli_parse_cb, NULL)
1674 || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_3,
1675 custom_ext_3_cli_add_cb,
1677 custom_ext_3_cli_parse_cb, NULL)
1678 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_0,
1679 custom_ext_0_srv_add_cb,
1681 custom_ext_0_srv_parse_cb, NULL)
1682 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_1,
1683 custom_ext_1_srv_add_cb,
1685 custom_ext_1_srv_parse_cb, NULL)
1686 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_2,
1687 custom_ext_2_srv_add_cb,
1689 custom_ext_2_srv_parse_cb, NULL)
1690 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_3,
1691 custom_ext_3_srv_add_cb,
1693 custom_ext_3_srv_parse_cb, NULL)) {
1694 BIO_printf(bio_err, "Error setting custom extensions\n");
1700 SSL_CTX_set_alpn_select_cb(s_ctx, cb_server_alpn, NULL);
1703 unsigned short alpn_len;
1704 unsigned char *alpn = next_protos_parse(&alpn_len, alpn_client);
1707 BIO_printf(bio_err, "Error parsing -alpn_client argument\n");
1710 /* Returns 0 on success!! */
1711 if (SSL_CTX_set_alpn_protos(c_ctx, alpn, alpn_len)) {
1712 BIO_printf(bio_err, "Error setting ALPN\n");
1719 c_ssl = SSL_new(c_ctx);
1720 s_ssl = SSL_new(s_ctx);
1722 BIO_printf(bio_stdout, "Doing handshakes=%d bytes=%ld\n", number, bytes);
1723 for (i = 0; i < number; i++) {
1725 if (!SSL_set_session(c_ssl, NULL)) {
1726 BIO_printf(bio_err, "Failed to set session\n");
1731 ret = doit_biopair(s_ssl, c_ssl, bytes, &s_time, &c_time);
1733 ret = doit(s_ssl, c_ssl, bytes);
1738 print_details(c_ssl, "");
1741 #ifdef CLOCKS_PER_SEC
1743 * "To determine the time in seconds, the value returned by the clock
1744 * function should be divided by the value of the macro
1745 * CLOCKS_PER_SEC." -- ISO/IEC 9899
1747 BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1748 "Approximate total client time: %6.2f s\n",
1749 (double)s_time / CLOCKS_PER_SEC,
1750 (double)c_time / CLOCKS_PER_SEC);
1752 BIO_printf(bio_stdout,
1753 "Approximate total server time: %6.2f units\n"
1754 "Approximate total client time: %6.2f units\n",
1755 (double)s_time, (double)c_time);
1763 SSL_CTX_free(s_ctx);
1764 SSL_CTX_free(c_ctx);
1765 SSL_CONF_CTX_free(s_cctx);
1766 SSL_CONF_CTX_free(c_cctx);
1767 sk_OPENSSL_STRING_free(conf_args);
1769 BIO_free(bio_stdout);
1771 #ifndef OPENSSL_NO_RSA
1774 #ifndef OPENSSL_NO_ENGINE
1777 CRYPTO_cleanup_all_ex_data();
1779 ERR_remove_thread_state(NULL);
1781 CRYPTO_mem_leaks(bio_err);
1786 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
1787 clock_t *s_time, clock_t *c_time)
1789 long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1790 BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1791 BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
1794 size_t bufsiz = 256; /* small buffer for testing */
1796 if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
1798 if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
1801 s_ssl_bio = BIO_new(BIO_f_ssl());
1805 c_ssl_bio = BIO_new(BIO_f_ssl());
1809 SSL_set_connect_state(c_ssl);
1810 SSL_set_bio(c_ssl, client, client);
1811 (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1813 SSL_set_accept_state(s_ssl);
1814 SSL_set_bio(s_ssl, server, server);
1815 (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1819 * c_ssl_bio: SSL filter BIO
1821 * client: pseudo-I/O for SSL library
1823 * client_io: client's SSL communication; usually to be
1824 * relayed over some I/O facility, but in this
1825 * test program, we're the server, too:
1827 * server_io: server's SSL communication
1829 * server: pseudo-I/O for SSL library
1831 * s_ssl_bio: SSL filter BIO
1833 * The client and the server each employ a "BIO pair":
1834 * client + client_io, server + server_io.
1835 * BIO pairs are symmetric. A BIO pair behaves similar
1836 * to a non-blocking socketpair (but both endpoints must
1837 * be handled by the same thread).
1838 * [Here we could connect client and server to the ends
1839 * of a single BIO pair, but then this code would be less
1840 * suitable as an example for BIO pairs in general.]
1842 * Useful functions for querying the state of BIO pair endpoints:
1844 * BIO_ctrl_pending(bio) number of bytes we can read now
1845 * BIO_ctrl_get_read_request(bio) number of bytes needed to fulfil
1846 * other side's read attempt
1847 * BIO_ctrl_get_write_guarantee(bio) number of bytes we can write now
1849 * ..._read_request is never more than ..._write_guarantee;
1850 * it depends on the application which one you should use.
1854 * We have non-blocking behaviour throughout this test program, but
1855 * can be sure that there is *some* progress in each iteration; so we
1856 * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
1857 * we just try everything in each iteration
1863 char cbuf[1024 * 8];
1865 clock_t c_clock = clock();
1867 memset(cbuf, 0, sizeof(cbuf));
1870 if (SSL_in_init(c_ssl))
1871 printf("client waiting in SSL_connect - %s\n",
1872 SSL_state_string_long(c_ssl));
1875 /* Write to server. */
1877 if (cw_num > (long)sizeof cbuf)
1881 r = BIO_write(c_ssl_bio, cbuf, i);
1883 if (!BIO_should_retry(c_ssl_bio)) {
1884 fprintf(stderr, "ERROR in CLIENT\n");
1888 * BIO_should_retry(...) can just be ignored here. The
1889 * library expects us to call BIO_write with the same
1890 * arguments again, and that's what we will do in the
1893 } else if (r == 0) {
1894 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1898 printf("client wrote %d\n", r);
1904 /* Read from server. */
1906 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1908 if (!BIO_should_retry(c_ssl_bio)) {
1909 fprintf(stderr, "ERROR in CLIENT\n");
1913 * Again, "BIO_should_retry" can be ignored.
1915 } else if (r == 0) {
1916 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1920 printf("client read %d\n", r);
1926 * c_time and s_time increments will typically be very small
1927 * (depending on machine speed and clock tick intervals), but
1928 * sampling over a large number of connections should result in
1929 * fairly accurate figures. We cannot guarantee a lot, however
1930 * -- if each connection lasts for exactly one clock tick, it
1931 * will be counted only for the client or only for the server or
1934 *c_time += (clock() - c_clock);
1940 char sbuf[1024 * 8];
1942 clock_t s_clock = clock();
1944 memset(sbuf, 0, sizeof(sbuf));
1947 if (SSL_in_init(s_ssl))
1948 printf("server waiting in SSL_accept - %s\n",
1949 SSL_state_string_long(s_ssl));
1952 /* Write to client. */
1954 if (sw_num > (long)sizeof sbuf)
1958 r = BIO_write(s_ssl_bio, sbuf, i);
1960 if (!BIO_should_retry(s_ssl_bio)) {
1961 fprintf(stderr, "ERROR in SERVER\n");
1964 /* Ignore "BIO_should_retry". */
1965 } else if (r == 0) {
1966 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
1970 printf("server wrote %d\n", r);
1976 /* Read from client. */
1978 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
1980 if (!BIO_should_retry(s_ssl_bio)) {
1981 fprintf(stderr, "ERROR in SERVER\n");
1985 } else if (r == 0) {
1986 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
1990 printf("server read %d\n", r);
1995 *s_time += (clock() - s_clock);
1999 /* "I/O" BETWEEN CLIENT AND SERVER. */
2002 BIO *io1 = server_io, *io2 = client_io;
2004 * we use the non-copying interface for io1 and the standard
2005 * BIO_write/BIO_read interface for io2
2008 static int prev_progress = 1;
2016 r1 = BIO_ctrl_pending(io1);
2017 r2 = BIO_ctrl_get_write_guarantee(io2);
2025 if (INT_MAX < num) /* yeah, right */
2028 r = BIO_nread(io1, &dataptr, (int)num);
2030 assert(r <= (int)num);
2032 * possibly r < num (non-contiguous data)
2035 r = BIO_write(io2, dataptr, (int)num);
2036 if (r != (int)num) { /* can't happen */
2037 fprintf(stderr, "ERROR: BIO_write could not write "
2038 "BIO_ctrl_get_write_guarantee() bytes");
2044 printf((io1 == client_io) ?
2045 "C->S relaying: %d bytes\n" :
2046 "S->C relaying: %d bytes\n", (int)num);
2056 r1 = BIO_ctrl_pending(io2);
2057 r2 = BIO_ctrl_get_read_request(io1);
2059 * here we could use ..._get_write_guarantee instead of
2060 * ..._get_read_request, but by using the latter we test
2061 * restartability of the SSL implementation more thoroughly
2073 --num; /* test restartability even more thoroughly */
2075 r = BIO_nwrite0(io1, &dataptr);
2079 r = BIO_read(io2, dataptr, (int)num);
2080 if (r != (int)num) { /* can't happen */
2081 fprintf(stderr, "ERROR: BIO_read could not read "
2082 "BIO_ctrl_pending() bytes");
2086 r = BIO_nwrite(io1, &dataptr, (int)num);
2087 if (r != (int)num) { /* can't happen */
2088 fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
2089 "BIO_nwrite0() bytes");
2094 printf((io2 == client_io) ?
2095 "C->S relaying: %d bytes\n" :
2096 "S->C relaying: %d bytes\n", (int)num);
2098 } /* no loop, BIO_ctrl_get_read_request now
2099 * returns 0 anyway */
2101 if (!progress && !prev_progress)
2102 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0) {
2103 fprintf(stderr, "ERROR: got stuck\n");
2104 fprintf(stderr, " ERROR.\n");
2107 prev_progress = progress;
2110 while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2113 print_details(c_ssl, "DONE via BIO pair: ");
2114 #ifndef OPENSSL_NO_NEXTPROTONEG
2115 if (verify_npn(c_ssl, s_ssl) < 0) {
2120 if (verify_serverinfo() < 0) {
2121 fprintf(stderr, "Server info verify error\n");
2125 if (verify_alpn(c_ssl, s_ssl) < 0) {
2130 if (custom_ext_error) {
2131 fprintf(stderr, "Custom extension error\n");
2140 ERR_print_errors(bio_err);
2143 BIO_free(server_io);
2145 BIO_free(client_io);
2146 BIO_free(s_ssl_bio);
2147 BIO_free(c_ssl_bio);
2157 int doit(SSL *s_ssl, SSL *c_ssl, long count)
2159 char *cbuf = NULL, *sbuf = NULL;
2161 long cw_num = count, cr_num = count;
2162 long sw_num = count, sr_num = count;
2168 int c_r, c_w, s_r, s_w;
2171 int c_write, s_write;
2172 int do_server = 0, do_client = 0;
2173 int max_frag = 5 * 1024;
2175 bufsiz = count > 40 * 1024 ? 40 * 1024 : count;
2177 if ((cbuf = OPENSSL_malloc(bufsiz)) == NULL)
2179 if ((sbuf = OPENSSL_malloc(bufsiz)) == NULL)
2182 memset(cbuf, 0, bufsiz);
2183 memset(sbuf, 0, bufsiz);
2185 c_to_s = BIO_new(BIO_s_mem());
2186 s_to_c = BIO_new(BIO_s_mem());
2187 if ((s_to_c == NULL) || (c_to_s == NULL)) {
2188 ERR_print_errors(bio_err);
2192 c_bio = BIO_new(BIO_f_ssl());
2193 s_bio = BIO_new(BIO_f_ssl());
2194 if ((c_bio == NULL) || (s_bio == NULL)) {
2195 ERR_print_errors(bio_err);
2199 SSL_set_connect_state(c_ssl);
2200 SSL_set_bio(c_ssl, s_to_c, c_to_s);
2201 SSL_set_max_send_fragment(c_ssl, max_frag);
2202 BIO_set_ssl(c_bio, c_ssl, BIO_NOCLOSE);
2204 SSL_set_accept_state(s_ssl);
2205 SSL_set_bio(s_ssl, c_to_s, s_to_c);
2206 SSL_set_max_send_fragment(s_ssl, max_frag);
2207 BIO_set_ssl(s_bio, s_ssl, BIO_NOCLOSE);
2213 c_write = 1, s_write = 0;
2215 /* We can always do writes */
2220 i = (int)BIO_pending(s_bio);
2221 if ((i && s_r) || s_w)
2224 i = (int)BIO_pending(c_bio);
2225 if ((i && c_r) || c_w)
2228 if (do_server && debug) {
2229 if (SSL_in_init(s_ssl))
2230 printf("server waiting in SSL_accept - %s\n",
2231 SSL_state_string_long(s_ssl));
2234 printf("server:SSL_write()\n");
2236 printf("server:SSL_read()\n"); */
2239 if (do_client && debug) {
2240 if (SSL_in_init(c_ssl))
2241 printf("client waiting in SSL_connect - %s\n",
2242 SSL_state_string_long(c_ssl));
2245 printf("client:SSL_write()\n");
2247 printf("client:SSL_read()\n"); */
2250 if (!do_client && !do_server) {
2251 fprintf(stdout, "ERROR IN STARTUP\n");
2252 ERR_print_errors(bio_err);
2255 if (do_client && !(done & C_DONE)) {
2257 j = (cw_num > bufsiz) ? (int)bufsiz : (int)cw_num;
2258 i = BIO_write(c_bio, cbuf, j);
2262 if (BIO_should_retry(c_bio)) {
2263 if (BIO_should_read(c_bio))
2265 if (BIO_should_write(c_bio))
2268 fprintf(stderr, "ERROR in CLIENT\n");
2269 ERR_print_errors(bio_err);
2272 } else if (i == 0) {
2273 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2277 printf("client wrote %d\n", i);
2282 if (max_frag > 1029)
2283 SSL_set_max_send_fragment(c_ssl, max_frag -= 5);
2286 i = BIO_read(c_bio, cbuf, bufsiz);
2290 if (BIO_should_retry(c_bio)) {
2291 if (BIO_should_read(c_bio))
2293 if (BIO_should_write(c_bio))
2296 fprintf(stderr, "ERROR in CLIENT\n");
2297 ERR_print_errors(bio_err);
2300 } else if (i == 0) {
2301 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2305 printf("client read %d\n", i);
2314 done = S_DONE | C_DONE;
2320 if (do_server && !(done & S_DONE)) {
2322 i = BIO_read(s_bio, sbuf, bufsiz);
2326 if (BIO_should_retry(s_bio)) {
2327 if (BIO_should_read(s_bio))
2329 if (BIO_should_write(s_bio))
2332 fprintf(stderr, "ERROR in SERVER\n");
2333 ERR_print_errors(bio_err);
2336 } else if (i == 0) {
2337 ERR_print_errors(bio_err);
2339 "SSL SERVER STARTUP FAILED in SSL_read\n");
2343 printf("server read %d\n", i);
2356 j = (sw_num > bufsiz) ? (int)bufsiz : (int)sw_num;
2357 i = BIO_write(s_bio, sbuf, j);
2361 if (BIO_should_retry(s_bio)) {
2362 if (BIO_should_read(s_bio))
2364 if (BIO_should_write(s_bio))
2367 fprintf(stderr, "ERROR in SERVER\n");
2368 ERR_print_errors(bio_err);
2371 } else if (i == 0) {
2372 ERR_print_errors(bio_err);
2374 "SSL SERVER STARTUP FAILED in SSL_write\n");
2378 printf("server wrote %d\n", i);
2384 if (max_frag > 1029)
2385 SSL_set_max_send_fragment(s_ssl, max_frag -= 5);
2390 if ((done & S_DONE) && (done & C_DONE))
2395 print_details(c_ssl, "DONE: ");
2396 #ifndef OPENSSL_NO_NEXTPROTONEG
2397 if (verify_npn(c_ssl, s_ssl) < 0) {
2402 if (verify_serverinfo() < 0) {
2403 fprintf(stderr, "Server info verify error\n");
2407 if (custom_ext_error) {
2408 fprintf(stderr, "Custom extension error\n");
2415 * We have to set the BIO's to NULL otherwise they will be
2416 * OPENSSL_free()ed twice. Once when th s_ssl is SSL_free()ed and again
2417 * when c_ssl is SSL_free()ed. This is a hack required because s_ssl and
2418 * c_ssl are sharing the same BIO structure and SSL_set_bio() and
2419 * SSL_free() automatically BIO_free non NULL entries. You should not
2420 * normally do this or be required to do this
2422 if (s_ssl != NULL) {
2426 if (c_ssl != NULL) {
2433 BIO_free_all(c_bio);
2434 BIO_free_all(s_bio);
2441 static int get_proxy_auth_ex_data_idx(void)
2443 static volatile int idx = -1;
2445 CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
2447 idx = X509_STORE_CTX_get_ex_new_index(0,
2448 "SSLtest for verify callback",
2451 CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
2456 static int verify_callback(int ok, X509_STORE_CTX *ctx)
2460 s = X509_NAME_oneline(X509_get_subject_name(ctx->current_cert), buf,
2464 printf("depth=%d %s\n", ctx->error_depth, buf);
2466 fprintf(stderr, "depth=%d error=%d %s\n",
2467 ctx->error_depth, ctx->error, buf);
2472 switch (ctx->error) {
2474 fprintf(stderr, "Error string: %s\n",
2475 X509_verify_cert_error_string(ctx->error));
2477 case X509_V_ERR_CERT_NOT_YET_VALID:
2478 case X509_V_ERR_CERT_HAS_EXPIRED:
2479 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2485 X509 *xs = ctx->current_cert;
2486 if (xs->ex_flags & EXFLAG_PROXY) {
2487 unsigned int *letters = X509_STORE_CTX_get_ex_data(ctx,
2488 get_proxy_auth_ex_data_idx
2494 PROXY_CERT_INFO_EXTENSION *pci =
2495 X509_get_ext_d2i(xs, NID_proxyCertInfo,
2498 switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage)) {
2499 case NID_Independent:
2501 * Completely meaningless in this program, as there's no
2502 * way to grant explicit rights to a specific PrC.
2503 * Basically, using id-ppl-Independent is the perfect way
2504 * to grant no rights at all.
2506 fprintf(stderr, " Independent proxy certificate");
2507 for (i = 0; i < 26; i++)
2510 case NID_id_ppl_inheritAll:
2512 * This is basically a NOP, we simply let the current
2513 * rights stand as they are.
2515 fprintf(stderr, " Proxy certificate inherits all");
2519 pci->proxyPolicy->policy->data;
2520 i = pci->proxyPolicy->policy->length;
2523 * The algorithm works as follows: it is assumed that
2524 * previous iterations or the initial granted rights has
2525 * already set some elements of `letters'. What we need
2526 * to do is to clear those that weren't granted by the
2527 * current PrC as well. The easiest way to do this is to
2528 * add 1 to all the elements whose letters are given with
2529 * the current policy. That way, all elements that are
2530 * set by the current policy and were already set by
2531 * earlier policies and through the original grant of
2532 * rights will get the value 2 or higher. The last thing
2533 * to do is to sweep through `letters' and keep the
2534 * elements having the value 2 as set, and clear all the
2538 printf(" Certificate proxy rights = %*.*s", i,
2542 if (isascii(c) && isalpha(c)) {
2548 for (i = 0; i < 26; i++)
2556 printf(", resulting proxy rights = ");
2557 for (i = 0; i < 26; i++)
2559 printf("%c", i + 'A');
2566 PROXY_CERT_INFO_EXTENSION_free(pci);
2574 static void process_proxy_debug(int indent, const char *format, ...)
2577 static const char indentation[] =
2578 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
2579 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
2580 char my_format[256];
2583 BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
2584 indent, indent, indentation, format);
2586 va_start(args, format);
2587 vfprintf(stderr, my_format, args);
2597 static int process_proxy_cond_adders(unsigned int letters[26],
2598 const char *cond, const char **cond_end,
2599 int *pos, int indent);
2600 static int process_proxy_cond_val(unsigned int letters[26], const char *cond,
2601 const char **cond_end, int *pos, int indent)
2607 while (isspace((int)*cond)) {
2614 process_proxy_debug(indent,
2615 "Start process_proxy_cond_val at position %d: %s\n",
2622 while (isspace((int)*cond)) {
2632 ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
2637 while (isspace((int)*cond)) {
2644 "Weird condition character in position %d: "
2651 } else if (isascii(c) && isalpha(c)) {
2654 ok = letters[c - 'A'];
2659 "Weird condition character in position %d: " "%c\n", *pos, c);
2665 if (ok >= 0 && negate)
2669 process_proxy_debug(indent,
2670 "End process_proxy_cond_val at position %d: %s, returning %d\n",
2676 static int process_proxy_cond_multipliers(unsigned int letters[26],
2678 const char **cond_end, int *pos,
2685 process_proxy_debug(indent,
2686 "Start process_proxy_cond_multipliers at position %d: %s\n",
2689 ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
2695 while (isspace((int)*cond)) {
2709 ok = process_proxy_cond_val(letters,
2710 cond, cond_end, pos, indent + 1);
2723 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2735 process_proxy_debug(indent,
2736 "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
2743 static int process_proxy_cond_adders(unsigned int letters[26],
2744 const char *cond, const char **cond_end,
2745 int *pos, int indent)
2751 process_proxy_debug(indent,
2752 "Start process_proxy_cond_adders at position %d: %s\n",
2755 ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
2762 while (isspace((int)*cond)) {
2775 ok = process_proxy_cond_multipliers(letters,
2776 cond, cond_end, pos,
2787 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2799 process_proxy_debug(indent,
2800 "End process_proxy_cond_adders at position %d: %s, returning %d\n",
2807 static int process_proxy_cond(unsigned int letters[26],
2808 const char *cond, const char **cond_end)
2811 return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
2814 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2817 struct app_verify_arg *cb_arg = arg;
2818 unsigned int letters[26]; /* only used with proxy_auth */
2820 if (cb_arg->app_verify) {
2821 char *s = NULL, buf[256];
2823 printf("In app_verify_callback, allowing cert. ");
2824 printf("Arg is: %s\n", cb_arg->string);
2825 printf("Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2826 (void *)ctx, (void *)ctx->cert);
2828 s = X509_NAME_oneline(X509_get_subject_name(ctx->cert), buf, 256);
2830 printf("cert depth=%d %s\n", ctx->error_depth, buf);
2834 if (cb_arg->proxy_auth) {
2835 int found_any = 0, i;
2838 for (i = 0; i < 26; i++)
2840 for (sp = cb_arg->proxy_auth; *sp; sp++) {
2842 if (isascii(c) && isalpha(c)) {
2845 letters[c - 'A'] = 1;
2849 printf(" Initial proxy rights = ");
2850 for (i = 0; i < 26; i++)
2852 printf("%c", i + 'A');
2859 X509_STORE_CTX_set_ex_data(ctx,
2860 get_proxy_auth_ex_data_idx(), letters);
2862 if (cb_arg->allow_proxy_certs) {
2863 X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
2865 ok = X509_verify_cert(ctx);
2867 if (cb_arg->proxy_auth) {
2869 const char *cond_end = NULL;
2871 ok = process_proxy_cond(letters, cb_arg->proxy_cond, &cond_end);
2877 "Stopped processing condition before it's end.\n");
2882 "Proxy rights check with condition '%s' invalid\n",
2883 cb_arg->proxy_cond);
2885 printf("Proxy rights check with condition '%s' ok\n",
2886 cb_arg->proxy_cond);
2892 #ifndef OPENSSL_NO_RSA
2893 static RSA *rsa_tmp = NULL;
2895 static RSA *tmp_rsa_cb(SSL *s, int is_export, int keylength)
2898 if (rsa_tmp == NULL) {
2900 rsa_tmp = RSA_new();
2901 if (!bn || !rsa_tmp || !BN_set_word(bn, RSA_F4)) {
2902 BIO_printf(bio_err, "Memory error...");
2905 printf("Generating temp (%d bit) RSA key...", keylength);
2906 if (!RSA_generate_key_ex(rsa_tmp, keylength, bn, NULL)) {
2907 BIO_printf(bio_err, "Error generating key.");
2918 static void free_tmp_rsa(void)
2925 #ifndef OPENSSL_NO_DH
2927 * These DH parameters have been generated as follows:
2928 * $ openssl dhparam -C -noout 512
2929 * $ openssl dhparam -C -noout 1024
2930 * $ openssl dhparam -C -noout -dsaparam 1024
2931 * (The third function has been renamed to avoid name conflicts.)
2933 static DH *get_dh512()
2935 static unsigned char dh512_p[] = {
2936 0xCB, 0xC8, 0xE1, 0x86, 0xD0, 0x1F, 0x94, 0x17, 0xA6, 0x99, 0xF0,
2938 0x1F, 0x0D, 0xAC, 0xB6, 0x25, 0x3E, 0x06, 0x39, 0xCA, 0x72, 0x04,
2940 0x6E, 0xDA, 0xC0, 0x61, 0xE6, 0x7A, 0x77, 0x25, 0xE8, 0x3B, 0xB9,
2942 0x9A, 0xB6, 0xB5, 0xFE, 0x99, 0x0B, 0xA1, 0x93, 0x4E, 0x35, 0x33,
2944 0xE1, 0xF1, 0x13, 0x4F, 0x59, 0x1A, 0xD2, 0x57, 0xC0, 0x26, 0x21,
2946 0x02, 0xC5, 0xAE, 0x23,
2948 static unsigned char dh512_g[] = {
2953 if ((dh = DH_new()) == NULL)
2955 dh->p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
2956 dh->g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
2957 if ((dh->p == NULL) || (dh->g == NULL)) {
2964 static DH *get_dh1024()
2966 static unsigned char dh1024_p[] = {
2967 0xF8, 0x81, 0x89, 0x7D, 0x14, 0x24, 0xC5, 0xD1, 0xE6, 0xF7, 0xBF,
2969 0xE4, 0x90, 0xF4, 0xFC, 0x73, 0xFB, 0x34, 0xB5, 0xFA, 0x4C, 0x56,
2971 0xEA, 0xA7, 0xE9, 0xC0, 0xC0, 0xCE, 0x89, 0xE1, 0xFA, 0x63, 0x3F,
2973 0x6B, 0x32, 0x66, 0xF1, 0xD1, 0x7B, 0xB0, 0x00, 0x8F, 0xCA, 0x87,
2975 0xAE, 0x98, 0x89, 0x26, 0x17, 0xC2, 0x05, 0xD2, 0xEC, 0x08, 0xD0,
2977 0xFF, 0x17, 0x52, 0x8C, 0xC5, 0x07, 0x93, 0x03, 0xB1, 0xF6, 0x2F,
2979 0x1C, 0x52, 0x47, 0x27, 0x1B, 0xDB, 0xD1, 0x8D, 0x9D, 0x69, 0x1D,
2981 0x4B, 0x32, 0x81, 0xAA, 0x7F, 0x00, 0xC8, 0xDC, 0xE6, 0xD9, 0xCC,
2983 0x11, 0x2D, 0x37, 0x34, 0x6C, 0xEA, 0x02, 0x97, 0x4B, 0x0E, 0xBB,
2985 0x71, 0x33, 0x09, 0x15, 0xFD, 0xDD, 0x23, 0x87, 0x07, 0x5E, 0x89,
2987 0x6B, 0x7C, 0x5F, 0xEC, 0xA6, 0x24, 0xDC, 0x53,
2989 static unsigned char dh1024_g[] = {
2994 if ((dh = DH_new()) == NULL)
2996 dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
2997 dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
2998 if ((dh->p == NULL) || (dh->g == NULL)) {
3005 static DH *get_dh1024dsa()
3007 static unsigned char dh1024_p[] = {
3008 0xC8, 0x00, 0xF7, 0x08, 0x07, 0x89, 0x4D, 0x90, 0x53, 0xF3, 0xD5,
3010 0x21, 0x1B, 0xF7, 0x31, 0xA6, 0xA2, 0xDA, 0x23, 0x9A, 0xC7, 0x87,
3012 0x3B, 0x47, 0xB6, 0x8C, 0x04, 0x6F, 0xFF, 0xC6, 0x9B, 0xB8, 0x65,
3014 0xC2, 0x5F, 0x31, 0x83, 0x4A, 0xA7, 0x5F, 0x2F, 0x88, 0x38, 0xB6,
3016 0xCF, 0xD9, 0x87, 0x6D, 0x6F, 0x9F, 0xDA, 0xAC, 0xA6, 0x48, 0xAF,
3018 0x33, 0x84, 0x37, 0x5B, 0x82, 0x4A, 0x31, 0x5D, 0xE7, 0xBD, 0x52,
3020 0xA1, 0x77, 0xBF, 0x10, 0x9E, 0x37, 0xEA, 0x64, 0xFA, 0xCA, 0x28,
3022 0x9D, 0x3B, 0xD2, 0x6E, 0x09, 0x5C, 0x68, 0xC7, 0x45, 0x90, 0xFD,
3024 0x70, 0xC9, 0x3A, 0xBB, 0xDF, 0xD4, 0x21, 0x0F, 0xC4, 0x6A, 0x3C,
3026 0x61, 0xCF, 0x3F, 0xD6, 0x13, 0xF1, 0x5F, 0xBC, 0xCF, 0xBC, 0x26,
3028 0xBC, 0x0B, 0xBD, 0xAB, 0x5D, 0xC9, 0x54, 0x39,
3030 static unsigned char dh1024_g[] = {
3031 0x3B, 0x40, 0x86, 0xE7, 0xF3, 0x6C, 0xDE, 0x67, 0x1C, 0xCC, 0x80,
3033 0x5A, 0xDF, 0xFE, 0xBD, 0x20, 0x27, 0x74, 0x6C, 0x24, 0xC9, 0x03,
3035 0xE1, 0x8D, 0xC3, 0x7D, 0x98, 0x27, 0x40, 0x08, 0xB8, 0x8C, 0x6A,
3037 0xBB, 0x1A, 0x3A, 0xD6, 0x86, 0x83, 0x5E, 0x72, 0x41, 0xCE, 0x85,
3039 0xD2, 0xB3, 0xFC, 0x13, 0xCE, 0x37, 0x81, 0x9E, 0x4C, 0x1C, 0x7B,
3041 0xD3, 0xE6, 0xA6, 0x00, 0xF5, 0x5A, 0x95, 0x43, 0x5E, 0x81, 0xCF,
3043 0xA2, 0x23, 0xFC, 0x36, 0xA7, 0x5D, 0x7A, 0x4C, 0x06, 0x91, 0x6E,
3045 0x57, 0xEE, 0x36, 0xCB, 0x06, 0xEA, 0xF5, 0x3D, 0x95, 0x49, 0xCB,
3047 0xDD, 0x81, 0xDF, 0x80, 0x09, 0x4A, 0x97, 0x4D, 0xA8, 0x22, 0x72,
3049 0x7F, 0xC4, 0x70, 0x56, 0x70, 0xE8, 0x20, 0x10, 0x18, 0x8F, 0x2E,
3051 0x07, 0xE7, 0x68, 0x1A, 0x82, 0x5D, 0x32, 0xA2,
3055 if ((dh = DH_new()) == NULL)
3057 dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
3058 dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
3059 if ((dh->p == NULL) || (dh->g == NULL)) {
3068 #ifndef OPENSSL_NO_PSK
3069 /* convert the PSK key (psk_key) in ascii to binary (psk) */
3070 static int psk_key2bn(const char *pskkey, unsigned char *psk,
3071 unsigned int max_psk_len)
3076 ret = BN_hex2bn(&bn, pskkey);
3078 BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
3083 if (BN_num_bytes(bn) > (int)max_psk_len) {
3085 "psk buffer of callback is too small (%d) for key (%d)\n",
3086 max_psk_len, BN_num_bytes(bn));
3090 ret = BN_bn2bin(bn, psk);
3095 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
3097 unsigned int max_identity_len,
3099 unsigned int max_psk_len)
3102 unsigned int psk_len = 0;
3104 ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3108 fprintf(stderr, "client: created identity '%s' len=%d\n", identity,
3110 ret = psk_key2bn(psk_key, psk, max_psk_len);
3118 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3120 unsigned int max_psk_len)
3122 unsigned int psk_len = 0;
3124 if (strcmp(identity, "Client_identity") != 0) {
3125 BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3128 psk_len = psk_key2bn(psk_key, psk, max_psk_len);
3133 static int do_test_cipherlist(void)
3136 const SSL_METHOD *meth;
3137 const SSL_CIPHER *ci, *tci = NULL;
3139 #ifndef OPENSSL_NO_SSL3
3140 meth = SSLv3_method();
3142 while ((ci = meth->get_cipher(i++)) != NULL) {
3144 if (ci->id >= tci->id) {
3145 fprintf(stderr, "testing SSLv3 cipher list order: ");
3146 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3152 meth = TLSv1_method();
3154 while ((ci = meth->get_cipher(i++)) != NULL) {
3156 if (ci->id >= tci->id) {
3157 fprintf(stderr, "testing TLSv1 cipher list order: ");
3158 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);