2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
5 * This package is an SSL implementation written
6 * by Eric Young (eay@cryptsoft.com).
7 * The implementation was written so as to conform with Netscapes SSL.
9 * This library is free for commercial and non-commercial use as long as
10 * the following conditions are aheared to. The following conditions
11 * apply to all code found in this distribution, be it the RC4, RSA,
12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
13 * included with this distribution is covered by the same copyright terms
14 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
16 * Copyright remains Eric Young's, and as such any Copyright notices in
17 * the code are not to be removed.
18 * If this package is used in a product, Eric Young should be given attribution
19 * as the author of the parts of the library used.
20 * This can be in the form of a textual message at program startup or
21 * in documentation (online or textual) provided with the package.
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
26 * 1. Redistributions of source code must retain the copyright
27 * notice, this list of conditions and the following disclaimer.
28 * 2. Redistributions in binary form must reproduce the above copyright
29 * notice, this list of conditions and the following disclaimer in the
30 * documentation and/or other materials provided with the distribution.
31 * 3. All advertising materials mentioning features or use of this software
32 * must display the following acknowledgement:
33 * "This product includes cryptographic software written by
34 * Eric Young (eay@cryptsoft.com)"
35 * The word 'cryptographic' can be left out if the rouines from the library
36 * being used are not cryptographic related :-).
37 * 4. If you include any Windows specific code (or a derivative thereof) from
38 * the apps directory (application code) you must include an acknowledgement:
39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53 * The licence and distribution terms for any publically available version or
54 * derivative of this code cannot be changed. i.e. this code cannot simply be
55 * copied and put under another distribution licence
56 * [including the GNU Public Licence.]
58 /* ====================================================================
59 * Copyright (c) 1998-2000 The OpenSSL Project. All rights reserved.
61 * Redistribution and use in source and binary forms, with or without
62 * modification, are permitted provided that the following conditions
65 * 1. Redistributions of source code must retain the above copyright
66 * notice, this list of conditions and the following disclaimer.
68 * 2. Redistributions in binary form must reproduce the above copyright
69 * notice, this list of conditions and the following disclaimer in
70 * the documentation and/or other materials provided with the
73 * 3. All advertising materials mentioning features or use of this
74 * software must display the following acknowledgment:
75 * "This product includes software developed by the OpenSSL Project
76 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
78 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79 * endorse or promote products derived from this software without
80 * prior written permission. For written permission, please contact
81 * openssl-core@openssl.org.
83 * 5. Products derived from this software may not be called "OpenSSL"
84 * nor may "OpenSSL" appear in their names without prior written
85 * permission of the OpenSSL Project.
87 * 6. Redistributions of any form whatsoever must retain the following
89 * "This product includes software developed by the OpenSSL Project
90 * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
92 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
96 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103 * OF THE POSSIBILITY OF SUCH DAMAGE.
104 * ====================================================================
106 * This product includes cryptographic software written by Eric Young
107 * (eay@cryptsoft.com). This product includes software written by Tim
108 * Hudson (tjh@cryptsoft.com).
111 /* ====================================================================
112 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
113 * ECC cipher suite support in OpenSSL originally developed by
114 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
116 /* ====================================================================
117 * Copyright 2005 Nokia. All rights reserved.
119 * The portions of the attached software ("Contribution") is developed by
120 * Nokia Corporation and is licensed pursuant to the OpenSSL open source
123 * The Contribution, originally written by Mika Kousa and Pasi Eronen of
124 * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
125 * support (see RFC 4279) to OpenSSL.
127 * No patent licenses or other rights except those expressly stated in
128 * the OpenSSL open source license shall be deemed granted or received
129 * expressly, by implication, estoppel, or otherwise.
131 * No assurances are provided by Nokia that the Contribution does not
132 * infringe the patent or other intellectual property rights of any third
133 * party or that the license provides you with all the necessary rights
134 * to make use of the Contribution.
136 * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
137 * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
138 * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
139 * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
143 /* Or gethostname won't be declared properly on Linux and GNU platforms. */
144 #define _BSD_SOURCE 1
145 #define _DEFAULT_SOURCE 1
158 #ifdef OPENSSL_SYS_VMS
160 * Or isascii won't be declared properly on VMS (at least with DECompHP C).
162 # define _XOPEN_SOURCE 500
167 #include <openssl/bio.h>
168 #include <openssl/crypto.h>
169 #include <openssl/evp.h>
170 #include <openssl/x509.h>
171 #include <openssl/x509v3.h>
172 #include <openssl/ssl.h>
173 #ifndef OPENSSL_NO_ENGINE
174 # include <openssl/engine.h>
176 #include <openssl/err.h>
177 #include <openssl/rand.h>
178 #ifndef OPENSSL_NO_RSA
179 # include <openssl/rsa.h>
181 #ifndef OPENSSL_NO_DSA
182 # include <openssl/dsa.h>
184 #ifndef OPENSSL_NO_DH
185 # include <openssl/dh.h>
187 #ifndef OPENSSL_NO_SRP
188 # include <openssl/srp.h>
190 #include <openssl/bn.h>
192 #include "../ssl/ssl_locl.h"
195 * Or gethostname won't be declared properly
196 * on Compaq platforms (at least with DEC C).
197 * Do not try to put it earlier, or IPv6 includes
200 #define _XOPEN_SOURCE_EXTENDED 1
202 #ifdef OPENSSL_SYS_WINDOWS
203 # include <winsock.h>
205 # include OPENSSL_UNISTD
209 * There is really no standard for this, so let's assign something
214 static int verify_callback(int ok, X509_STORE_CTX *ctx);
215 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg);
216 #define APP_CALLBACK_STRING "Test Callback Argument"
217 struct app_verify_arg {
220 int allow_proxy_certs;
225 #ifndef OPENSSL_NO_DH
226 static DH *get_dh512(void);
227 static DH *get_dh1024(void);
228 static DH *get_dh1024dsa(void);
231 static char *psk_key = NULL; /* by default PSK is not used */
232 #ifndef OPENSSL_NO_PSK
233 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
235 unsigned int max_identity_len,
237 unsigned int max_psk_len);
238 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
240 unsigned int max_psk_len);
243 #ifndef OPENSSL_NO_SRP
245 /* This is a context that we pass to all callbacks */
246 typedef struct srp_client_arg_st {
251 # define PWD_STRLEN 1024
253 static char *ssl_give_srp_client_pwd_cb(SSL *s, void *arg)
255 SRP_CLIENT_ARG *srp_client_arg = (SRP_CLIENT_ARG *)arg;
256 return OPENSSL_strdup((char *)srp_client_arg->srppassin);
260 /* This is a context that we pass to SRP server callbacks */
261 typedef struct srp_server_arg_st {
266 static int ssl_srp_server_param_cb(SSL *s, int *ad, void *arg)
268 SRP_SERVER_ARG *p = (SRP_SERVER_ARG *)arg;
270 if (strcmp(p->expected_user, SSL_get_srp_username(s)) != 0) {
271 fprintf(stderr, "User %s doesn't exist\n", SSL_get_srp_username(s));
272 return SSL3_AL_FATAL;
274 if (SSL_set_srp_server_param_pw(s, p->expected_user, p->pass, "1024") < 0) {
275 *ad = SSL_AD_INTERNAL_ERROR;
276 return SSL3_AL_FATAL;
278 return SSL_ERROR_NONE;
282 static BIO *bio_err = NULL;
283 static BIO *bio_stdout = NULL;
285 #ifndef OPENSSL_NO_NEXTPROTONEG
286 /* Note that this code assumes that this is only a one element list: */
287 static const char NEXT_PROTO_STRING[] = "\x09testproto";
288 static int npn_client = 0;
289 static int npn_server = 0;
290 static int npn_server_reject = 0;
292 static int cb_client_npn(SSL *s, unsigned char **out, unsigned char *outlen,
293 const unsigned char *in, unsigned int inlen,
297 * This callback only returns the protocol string, rather than a length
298 * prefixed set. We assume that NEXT_PROTO_STRING is a one element list
299 * and remove the first byte to chop off the length prefix.
301 *out = (unsigned char *)NEXT_PROTO_STRING + 1;
302 *outlen = sizeof(NEXT_PROTO_STRING) - 2;
303 return SSL_TLSEXT_ERR_OK;
306 static int cb_server_npn(SSL *s, const unsigned char **data,
307 unsigned int *len, void *arg)
309 *data = (const unsigned char *)NEXT_PROTO_STRING;
310 *len = sizeof(NEXT_PROTO_STRING) - 1;
311 return SSL_TLSEXT_ERR_OK;
314 static int cb_server_rejects_npn(SSL *s, const unsigned char **data,
315 unsigned int *len, void *arg)
317 return SSL_TLSEXT_ERR_NOACK;
320 static int verify_npn(SSL *client, SSL *server)
322 const unsigned char *client_s;
324 const unsigned char *server_s;
327 SSL_get0_next_proto_negotiated(client, &client_s, &client_len);
328 SSL_get0_next_proto_negotiated(server, &server_s, &server_len);
331 BIO_printf(bio_stdout, "Client NPN: ");
332 BIO_write(bio_stdout, client_s, client_len);
333 BIO_printf(bio_stdout, "\n");
337 BIO_printf(bio_stdout, "Server NPN: ");
338 BIO_write(bio_stdout, server_s, server_len);
339 BIO_printf(bio_stdout, "\n");
343 * If an NPN string was returned, it must be the protocol that we
344 * expected to negotiate.
346 if (client_len && (client_len != sizeof(NEXT_PROTO_STRING) - 2 ||
347 memcmp(client_s, NEXT_PROTO_STRING + 1, client_len)))
349 if (server_len && (server_len != sizeof(NEXT_PROTO_STRING) - 2 ||
350 memcmp(server_s, NEXT_PROTO_STRING + 1, server_len)))
353 if (!npn_client && client_len)
355 if (!npn_server && server_len)
357 if (npn_server_reject && server_len)
359 if (npn_client && npn_server && (!client_len || !server_len))
366 static const char *alpn_client;
367 static const char *alpn_server;
368 static const char *alpn_expected;
369 static unsigned char *alpn_selected;
370 static const char *server_min_proto;
371 static const char *server_max_proto;
372 static const char *client_min_proto;
373 static const char *client_max_proto;
374 static const char *should_negotiate;
377 * next_protos_parse parses a comma separated list of strings into a string
378 * in a format suitable for passing to SSL_CTX_set_next_protos_advertised.
379 * outlen: (output) set to the length of the resulting buffer on success.
380 * err: (maybe NULL) on failure, an error message line is written to this BIO.
381 * in: a NUL terminated string like "abc,def,ghi"
383 * returns: a malloced buffer or NULL on failure.
385 static unsigned char *next_protos_parse(unsigned short *outlen,
396 out = OPENSSL_malloc(strlen(in) + 1);
400 for (i = 0; i <= len; ++i) {
401 if (i == len || in[i] == ',') {
402 if (i - start > 255) {
406 out[start] = i - start;
416 static int cb_server_alpn(SSL *s, const unsigned char **out,
417 unsigned char *outlen, const unsigned char *in,
418 unsigned int inlen, void *arg)
420 unsigned char *protos;
421 unsigned short protos_len;
423 protos = next_protos_parse(&protos_len, alpn_server);
424 if (protos == NULL) {
425 fprintf(stderr, "failed to parser ALPN server protocol string: %s\n",
430 if (SSL_select_next_proto
431 ((unsigned char **)out, outlen, protos, protos_len, in,
432 inlen) != OPENSSL_NPN_NEGOTIATED) {
433 OPENSSL_free(protos);
434 return SSL_TLSEXT_ERR_NOACK;
438 * Make a copy of the selected protocol which will be freed in
441 alpn_selected = OPENSSL_malloc(*outlen);
442 memcpy(alpn_selected, *out, *outlen);
443 *out = alpn_selected;
445 OPENSSL_free(protos);
446 return SSL_TLSEXT_ERR_OK;
449 static int verify_alpn(SSL *client, SSL *server)
451 const unsigned char *client_proto, *server_proto;
452 unsigned int client_proto_len = 0, server_proto_len = 0;
453 SSL_get0_alpn_selected(client, &client_proto, &client_proto_len);
454 SSL_get0_alpn_selected(server, &server_proto, &server_proto_len);
456 OPENSSL_free(alpn_selected);
457 alpn_selected = NULL;
459 if (client_proto_len != server_proto_len) {
460 BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");
464 if (client_proto != NULL &&
465 memcmp(client_proto, server_proto, client_proto_len) != 0) {
466 BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");
470 if (client_proto_len > 0 && alpn_expected == NULL) {
471 BIO_printf(bio_stdout, "ALPN unexpectedly negotiated\n");
475 if (alpn_expected != NULL &&
476 (client_proto_len != strlen(alpn_expected) ||
477 memcmp(client_proto, alpn_expected, client_proto_len) != 0)) {
478 BIO_printf(bio_stdout,
479 "ALPN selected protocols not equal to expected protocol: %s\n",
487 BIO_printf(bio_stdout, "ALPN results: client: '");
488 BIO_write(bio_stdout, client_proto, client_proto_len);
489 BIO_printf(bio_stdout, "', server: '");
490 BIO_write(bio_stdout, server_proto, server_proto_len);
491 BIO_printf(bio_stdout, "'\n");
492 BIO_printf(bio_stdout, "ALPN configured: client: '%s', server: '%s'\n",
493 alpn_client, alpn_server);
497 #define SCT_EXT_TYPE 18
500 * WARNING : below extension types are *NOT* IETF assigned, and could
501 * conflict if these types are reassigned and handled specially by OpenSSL
504 #define TACK_EXT_TYPE 62208
505 #define CUSTOM_EXT_TYPE_0 1000
506 #define CUSTOM_EXT_TYPE_1 1001
507 #define CUSTOM_EXT_TYPE_2 1002
508 #define CUSTOM_EXT_TYPE_3 1003
510 static const char custom_ext_cli_string[] = "abc";
511 static const char custom_ext_srv_string[] = "defg";
513 /* These set from cmdline */
514 static char *serverinfo_file = NULL;
515 static int serverinfo_sct = 0;
516 static int serverinfo_tack = 0;
518 /* These set based on extension callbacks */
519 static int serverinfo_sct_seen = 0;
520 static int serverinfo_tack_seen = 0;
521 static int serverinfo_other_seen = 0;
523 /* This set from cmdline */
524 static int custom_ext = 0;
526 /* This set based on extension callbacks */
527 static int custom_ext_error = 0;
529 static int serverinfo_cli_parse_cb(SSL *s, unsigned int ext_type,
530 const unsigned char *in, size_t inlen,
533 if (ext_type == SCT_EXT_TYPE)
534 serverinfo_sct_seen++;
535 else if (ext_type == TACK_EXT_TYPE)
536 serverinfo_tack_seen++;
538 serverinfo_other_seen++;
542 static int verify_serverinfo()
544 if (serverinfo_sct != serverinfo_sct_seen)
546 if (serverinfo_tack != serverinfo_tack_seen)
548 if (serverinfo_other_seen)
554 * Four test cases for custom extensions:
555 * 0 - no ClientHello extension or ServerHello response
556 * 1 - ClientHello with "abc", no response
557 * 2 - ClientHello with "abc", empty response
558 * 3 - ClientHello with "abc", "defg" response
561 static int custom_ext_0_cli_add_cb(SSL *s, unsigned int ext_type,
562 const unsigned char **out,
563 size_t *outlen, int *al, void *arg)
565 if (ext_type != CUSTOM_EXT_TYPE_0)
566 custom_ext_error = 1;
567 return 0; /* Don't send an extension */
570 static int custom_ext_0_cli_parse_cb(SSL *s, unsigned int ext_type,
571 const unsigned char *in,
572 size_t inlen, int *al, void *arg)
577 static int custom_ext_1_cli_add_cb(SSL *s, unsigned int ext_type,
578 const unsigned char **out,
579 size_t *outlen, int *al, void *arg)
581 if (ext_type != CUSTOM_EXT_TYPE_1)
582 custom_ext_error = 1;
583 *out = (const unsigned char *)custom_ext_cli_string;
584 *outlen = strlen(custom_ext_cli_string);
585 return 1; /* Send "abc" */
588 static int custom_ext_1_cli_parse_cb(SSL *s, unsigned int ext_type,
589 const unsigned char *in,
590 size_t inlen, int *al, void *arg)
595 static int custom_ext_2_cli_add_cb(SSL *s, unsigned int ext_type,
596 const unsigned char **out,
597 size_t *outlen, int *al, void *arg)
599 if (ext_type != CUSTOM_EXT_TYPE_2)
600 custom_ext_error = 1;
601 *out = (const unsigned char *)custom_ext_cli_string;
602 *outlen = strlen(custom_ext_cli_string);
603 return 1; /* Send "abc" */
606 static int custom_ext_2_cli_parse_cb(SSL *s, unsigned int ext_type,
607 const unsigned char *in,
608 size_t inlen, int *al, void *arg)
610 if (ext_type != CUSTOM_EXT_TYPE_2)
611 custom_ext_error = 1;
613 custom_ext_error = 1; /* Should be empty response */
617 static int custom_ext_3_cli_add_cb(SSL *s, unsigned int ext_type,
618 const unsigned char **out,
619 size_t *outlen, int *al, void *arg)
621 if (ext_type != CUSTOM_EXT_TYPE_3)
622 custom_ext_error = 1;
623 *out = (const unsigned char *)custom_ext_cli_string;
624 *outlen = strlen(custom_ext_cli_string);
625 return 1; /* Send "abc" */
628 static int custom_ext_3_cli_parse_cb(SSL *s, unsigned int ext_type,
629 const unsigned char *in,
630 size_t inlen, int *al, void *arg)
632 if (ext_type != CUSTOM_EXT_TYPE_3)
633 custom_ext_error = 1;
634 if (inlen != strlen(custom_ext_srv_string))
635 custom_ext_error = 1;
636 if (memcmp(custom_ext_srv_string, in, inlen) != 0)
637 custom_ext_error = 1; /* Check for "defg" */
642 * custom_ext_0_cli_add_cb returns 0 - the server won't receive a callback
645 static int custom_ext_0_srv_parse_cb(SSL *s, unsigned int ext_type,
646 const unsigned char *in,
647 size_t inlen, int *al, void *arg)
649 custom_ext_error = 1;
653 /* 'add' callbacks are only called if the 'parse' callback is called */
654 static int custom_ext_0_srv_add_cb(SSL *s, unsigned int ext_type,
655 const unsigned char **out,
656 size_t *outlen, int *al, void *arg)
658 /* Error: should not have been called */
659 custom_ext_error = 1;
660 return 0; /* Don't send an extension */
663 static int custom_ext_1_srv_parse_cb(SSL *s, unsigned int ext_type,
664 const unsigned char *in,
665 size_t inlen, int *al, void *arg)
667 if (ext_type != CUSTOM_EXT_TYPE_1)
668 custom_ext_error = 1;
669 /* Check for "abc" */
670 if (inlen != strlen(custom_ext_cli_string))
671 custom_ext_error = 1;
672 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
673 custom_ext_error = 1;
677 static int custom_ext_1_srv_add_cb(SSL *s, unsigned int ext_type,
678 const unsigned char **out,
679 size_t *outlen, int *al, void *arg)
681 return 0; /* Don't send an extension */
684 static int custom_ext_2_srv_parse_cb(SSL *s, unsigned int ext_type,
685 const unsigned char *in,
686 size_t inlen, int *al, void *arg)
688 if (ext_type != CUSTOM_EXT_TYPE_2)
689 custom_ext_error = 1;
690 /* Check for "abc" */
691 if (inlen != strlen(custom_ext_cli_string))
692 custom_ext_error = 1;
693 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
694 custom_ext_error = 1;
698 static int custom_ext_2_srv_add_cb(SSL *s, unsigned int ext_type,
699 const unsigned char **out,
700 size_t *outlen, int *al, void *arg)
704 return 1; /* Send empty extension */
707 static int custom_ext_3_srv_parse_cb(SSL *s, unsigned int ext_type,
708 const unsigned char *in,
709 size_t inlen, int *al, void *arg)
711 if (ext_type != CUSTOM_EXT_TYPE_3)
712 custom_ext_error = 1;
713 /* Check for "abc" */
714 if (inlen != strlen(custom_ext_cli_string))
715 custom_ext_error = 1;
716 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
717 custom_ext_error = 1;
721 static int custom_ext_3_srv_add_cb(SSL *s, unsigned int ext_type,
722 const unsigned char **out,
723 size_t *outlen, int *al, void *arg)
725 *out = (const unsigned char *)custom_ext_srv_string;
726 *outlen = strlen(custom_ext_srv_string);
727 return 1; /* Send "defg" */
730 static char *cipher = NULL;
731 static int verbose = 0;
732 static int debug = 0;
733 static const char rnd_seed[] =
734 "string to make the random number generator think it has entropy";
736 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long bytes, clock_t *s_time,
738 int doit(SSL *s_ssl, SSL *c_ssl, long bytes);
739 static int do_test_cipherlist(void);
741 static void sv_usage(void)
743 fprintf(stderr, "usage: ssltest [args ...]\n");
744 fprintf(stderr, "\n");
746 fprintf(stderr, "-F - run test in FIPS mode\n");
748 fprintf(stderr, " -server_auth - check server certificate\n");
749 fprintf(stderr, " -client_auth - do client authentication\n");
750 fprintf(stderr, " -proxy - allow proxy certificates\n");
751 fprintf(stderr, " -proxy_auth <val> - set proxy policy rights\n");
753 " -proxy_cond <val> - expression to test proxy policy rights\n");
754 fprintf(stderr, " -v - more output\n");
755 fprintf(stderr, " -d - debug output\n");
756 fprintf(stderr, " -reuse - use session-id reuse\n");
757 fprintf(stderr, " -num <val> - number of connections to perform\n");
759 " -bytes <val> - number of bytes to swap between client/server\n");
760 #ifndef OPENSSL_NO_DH
762 " -dhe512 - use 512 bit key for DHE (to test failure)\n");
764 " -dhe1024 - use 1024 bit key (safe prime) for DHE (default, no-op)\n");
766 " -dhe1024dsa - use 1024 bit key (with 160-bit subprime) for DHE\n");
767 fprintf(stderr, " -no_dhe - disable DHE\n");
769 #ifndef OPENSSL_NO_EC
770 fprintf(stderr, " -no_ecdhe - disable ECDHE\n");
772 #ifndef OPENSSL_NO_PSK
773 fprintf(stderr, " -psk arg - PSK in hex (without 0x)\n");
775 #ifndef OPENSSL_NO_SRP
776 fprintf(stderr, " -srpuser user - SRP username to use\n");
777 fprintf(stderr, " -srppass arg - password for 'user'\n");
779 #ifndef OPENSSL_NO_SSL3
780 fprintf(stderr, " -ssl3 - use SSLv3\n");
782 #ifndef OPENSSL_NO_TLS1
783 fprintf(stderr, " -tls1 - use TLSv1\n");
785 #ifndef OPENSSL_NO_DTLS
786 fprintf(stderr, " -dtls - use DTLS\n");
787 #ifndef OPENSSL_NO_DTLS1
788 fprintf(stderr, " -dtls1 - use DTLSv1\n");
790 #ifndef OPENSSL_NO_DTLS1_2
791 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");
833 fprintf(stderr, " -server_min_proto <string> - Minimum version the server should support\n");
834 fprintf(stderr, " -server_max_proto <string> - Maximum version the server should support\n");
835 fprintf(stderr, " -client_min_proto <string> - Minimum version the client should support\n");
836 fprintf(stderr, " -client_max_proto <string> - Maximum version the client should support\n");
837 fprintf(stderr, " -should_negotiate <string> - The version that should be negotiated, fail-client or fail-server\n");
840 static void print_key_details(BIO *out, EVP_PKEY *key)
842 int keyid = EVP_PKEY_id(key);
843 #ifndef OPENSSL_NO_EC
844 if (keyid == EVP_PKEY_EC) {
845 EC_KEY *ec = EVP_PKEY_get1_EC_KEY(key);
848 nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
850 cname = EC_curve_nid2nist(nid);
852 cname = OBJ_nid2sn(nid);
853 BIO_printf(out, "%d bits EC (%s)", EVP_PKEY_bits(key), cname);
869 algname = OBJ_nid2sn(keyid);
872 BIO_printf(out, "%d bits %s", EVP_PKEY_bits(key), algname);
876 static void print_details(SSL *c_ssl, const char *prefix)
878 const SSL_CIPHER *ciph;
883 ciph = SSL_get_current_cipher(c_ssl);
884 BIO_printf(bio_stdout, "%s%s, cipher %s %s",
886 SSL_get_version(c_ssl),
887 SSL_CIPHER_get_version(ciph), SSL_CIPHER_get_name(ciph));
888 cert = SSL_get_peer_certificate(c_ssl);
890 pkey = X509_get_pubkey(cert);
892 BIO_puts(bio_stdout, ", ");
893 print_key_details(bio_stdout, pkey);
898 if (SSL_get_server_tmp_key(c_ssl, &pkey)) {
899 BIO_puts(bio_stdout, ", temp key: ");
900 print_key_details(bio_stdout, pkey);
903 if (SSL_get_peer_signature_nid(c_ssl, &mdnid))
904 BIO_printf(bio_stdout, ", digest=%s", OBJ_nid2sn(mdnid));
905 BIO_printf(bio_stdout, "\n");
908 static void lock_dbg_cb(int mode, int type, const char *file, int line)
910 static int modes[CRYPTO_NUM_LOCKS]; /* = {0, 0, ... } */
911 const char *errstr = NULL;
914 rw = mode & (CRYPTO_READ | CRYPTO_WRITE);
915 if (!((rw == CRYPTO_READ) || (rw == CRYPTO_WRITE))) {
916 errstr = "invalid mode";
920 if (type < 0 || type >= CRYPTO_NUM_LOCKS) {
921 errstr = "type out of bounds";
925 if (mode & CRYPTO_LOCK) {
927 errstr = "already locked";
929 * must not happen in a single-threaded program (would deadlock)
935 } else if (mode & CRYPTO_UNLOCK) {
937 errstr = "not locked";
941 if (modes[type] != rw) {
942 errstr = (rw == CRYPTO_READ) ?
943 "CRYPTO_r_unlock on write lock" :
944 "CRYPTO_w_unlock on read lock";
949 errstr = "invalid mode";
955 /* we cannot use bio_err here */
957 "openssl (lock_dbg_cb): %s (mode=%d, type=%d) at %s:%d\n",
958 errstr, mode, type, file, line);
963 * protocol_from_string - converts a protocol version string to a number
965 * Returns -1 on failure or the version on success
967 static int protocol_from_string(const char *value)
969 struct protocol_versions {
973 static const struct protocol_versions versions[] = {
974 {"ssl3", SSL3_VERSION},
975 {"tls1", TLS1_VERSION},
976 {"tls1.1", TLS1_1_VERSION},
977 {"tls1.2", TLS1_2_VERSION},
978 {"dtls1", DTLS1_VERSION},
979 {"dtls1.2", DTLS1_2_VERSION}};
981 size_t n = OSSL_NELEM(versions);
983 for (i = 0; i < n; i++)
984 if (strcmp(versions[i].name, value) == 0)
985 return versions[i].version;
990 * set_protocol_version - Sets protocol version minimum or maximum
992 * Returns 0 on failure and 1 on success
994 static int set_protocol_version(const char *version, SSL *ssl, int setting)
996 if (version != NULL) {
997 int ver = protocol_from_string(version);
999 BIO_printf(bio_err, "Error parsing: %s\n", version);
1002 return SSL_ctrl(ssl, setting, ver, NULL);
1007 int main(int argc, char *argv[])
1009 char *CApath = NULL, *CAfile = NULL;
1013 int dtls1 = 0, dtls12 = 0, dtls = 0, tls1 = 0, ssl3 = 0, ret = 1;
1014 int client_auth = 0;
1015 int server_auth = 0, i;
1016 struct app_verify_arg app_verify_arg =
1017 { APP_CALLBACK_STRING, 0, 0, NULL, NULL };
1019 #ifndef OPENSSL_NO_EC
1020 char *named_curve = NULL;
1022 SSL_CTX *s_ctx = NULL;
1023 SSL_CTX *c_ctx = NULL;
1024 const SSL_METHOD *meth = NULL;
1026 int number = 1, reuse = 0;
1028 #ifndef OPENSSL_NO_DH
1030 int dhe512 = 0, dhe1024dsa = 0;
1032 #ifndef OPENSSL_NO_EC
1033 EC_KEY *ecdh = NULL;
1035 #ifndef OPENSSL_NO_SRP
1037 SRP_CLIENT_ARG srp_client_arg = { NULL, NULL };
1039 SRP_SERVER_ARG srp_server_arg = { NULL, NULL };
1045 clock_t s_time = 0, c_time = 0;
1046 #ifndef OPENSSL_NO_COMP
1048 COMP_METHOD *cm = NULL;
1049 STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
1051 int test_cipherlist = 0;
1057 SSL_CONF_CTX *s_cctx = NULL, *c_cctx = NULL;
1058 STACK_OF(OPENSSL_STRING) *conf_args = NULL;
1059 char *arg = NULL, *argn = NULL;
1065 bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
1067 CRYPTO_set_locking_callback(lock_dbg_cb);
1069 p = getenv("OPENSSL_DEBUG_MEMORY");
1070 if (p != NULL && strcmp(p, "on") == 0)
1071 CRYPTO_set_mem_debug(1);
1072 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
1074 RAND_seed(rnd_seed, sizeof rnd_seed);
1076 bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);
1078 s_cctx = SSL_CONF_CTX_new();
1079 c_cctx = SSL_CONF_CTX_new();
1081 if (!s_cctx || !c_cctx) {
1082 ERR_print_errors(bio_err);
1086 SSL_CONF_CTX_set_flags(s_cctx,
1087 SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_SERVER |
1088 SSL_CONF_FLAG_CERTIFICATE |
1089 SSL_CONF_FLAG_REQUIRE_PRIVATE);
1090 if (!SSL_CONF_CTX_set1_prefix(s_cctx, "-s_")) {
1091 ERR_print_errors(bio_err);
1095 SSL_CONF_CTX_set_flags(c_cctx,
1096 SSL_CONF_FLAG_CMDLINE | SSL_CONF_FLAG_CLIENT |
1097 SSL_CONF_FLAG_CERTIFICATE |
1098 SSL_CONF_FLAG_REQUIRE_PRIVATE);
1099 if (!SSL_CONF_CTX_set1_prefix(c_cctx, "-c_")) {
1100 ERR_print_errors(bio_err);
1108 if (strcmp(*argv, "-F") == 0) {
1113 "not compiled with FIPS support, so exiting without running.\n");
1116 } else if (strcmp(*argv, "-server_auth") == 0)
1118 else if (strcmp(*argv, "-client_auth") == 0)
1120 else if (strcmp(*argv, "-proxy_auth") == 0) {
1123 app_verify_arg.proxy_auth = *(++argv);
1124 } else if (strcmp(*argv, "-proxy_cond") == 0) {
1127 app_verify_arg.proxy_cond = *(++argv);
1128 } else if (strcmp(*argv, "-v") == 0)
1130 else if (strcmp(*argv, "-d") == 0)
1132 else if (strcmp(*argv, "-reuse") == 0)
1134 else if (strcmp(*argv, "-dhe512") == 0) {
1135 #ifndef OPENSSL_NO_DH
1139 "ignoring -dhe512, since I'm compiled without DH\n");
1141 } else if (strcmp(*argv, "-dhe1024dsa") == 0) {
1142 #ifndef OPENSSL_NO_DH
1146 "ignoring -dhe1024dsa, since I'm compiled without DH\n");
1148 } else if (strcmp(*argv, "-no_dhe") == 0)
1150 else if (strcmp(*argv, "-no_ecdhe") == 0)
1152 else if (strcmp(*argv, "-psk") == 0) {
1155 psk_key = *(++argv);
1156 #ifndef OPENSSL_NO_PSK
1157 if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key)) {
1158 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
1165 #ifndef OPENSSL_NO_SRP
1166 else if (strcmp(*argv, "-srpuser") == 0) {
1169 srp_server_arg.expected_user = srp_client_arg.srplogin =
1172 } else if (strcmp(*argv, "-srppass") == 0) {
1175 srp_server_arg.pass = srp_client_arg.srppassin = *(++argv);
1179 else if (strcmp(*argv, "-tls1") == 0) {
1181 } else if (strcmp(*argv, "-ssl3") == 0) {
1183 } else if (strcmp(*argv, "-dtls1") == 0) {
1185 } else if (strcmp(*argv, "-dtls12") == 0) {
1187 } else if (strcmp(*argv, "-dtls") == 0) {
1189 } else if (strncmp(*argv, "-num", 4) == 0) {
1192 number = atoi(*(++argv));
1195 } else if (strcmp(*argv, "-bytes") == 0) {
1198 bytes = atol(*(++argv));
1201 i = strlen(argv[0]);
1202 if (argv[0][i - 1] == 'k')
1204 if (argv[0][i - 1] == 'm')
1205 bytes *= 1024L * 1024L;
1206 } else if (strcmp(*argv, "-cipher") == 0) {
1210 } else if (strcmp(*argv, "-CApath") == 0) {
1214 } else if (strcmp(*argv, "-CAfile") == 0) {
1218 } else if (strcmp(*argv, "-bio_pair") == 0) {
1220 } else if (strcmp(*argv, "-f") == 0) {
1222 } else if (strcmp(*argv, "-time") == 0) {
1225 #ifndef OPENSSL_NO_COMP
1226 else if (strcmp(*argv, "-zlib") == 0) {
1230 else if (strcmp(*argv, "-named_curve") == 0) {
1233 #ifndef OPENSSL_NO_EC
1234 named_curve = *(++argv);
1237 "ignoring -named_curve, since I'm compiled without ECDH\n");
1240 } else if (strcmp(*argv, "-app_verify") == 0) {
1241 app_verify_arg.app_verify = 1;
1242 } else if (strcmp(*argv, "-proxy") == 0) {
1243 app_verify_arg.allow_proxy_certs = 1;
1244 } else if (strcmp(*argv, "-test_cipherlist") == 0) {
1245 test_cipherlist = 1;
1247 #ifndef OPENSSL_NO_NEXTPROTONEG
1248 else if (strcmp(*argv, "-npn_client") == 0) {
1250 } else if (strcmp(*argv, "-npn_server") == 0) {
1252 } else if (strcmp(*argv, "-npn_server_reject") == 0) {
1253 npn_server_reject = 1;
1256 else if (strcmp(*argv, "-serverinfo_sct") == 0) {
1258 } else if (strcmp(*argv, "-serverinfo_tack") == 0) {
1259 serverinfo_tack = 1;
1260 } else if (strcmp(*argv, "-serverinfo_file") == 0) {
1263 serverinfo_file = *(++argv);
1264 } else if (strcmp(*argv, "-custom_ext") == 0) {
1266 } else if (strcmp(*argv, "-alpn_client") == 0) {
1269 alpn_client = *(++argv);
1270 } else if (strcmp(*argv, "-alpn_server") == 0) {
1273 alpn_server = *(++argv);
1274 } else if (strcmp(*argv, "-alpn_expected") == 0) {
1277 alpn_expected = *(++argv);
1278 } else if (strcmp(*argv, "-server_min_proto") == 0) {
1281 server_min_proto = *(++argv);
1282 } else if (strcmp(*argv, "-server_max_proto") == 0) {
1285 server_max_proto = *(++argv);
1286 } else if (strcmp(*argv, "-client_min_proto") == 0) {
1289 client_min_proto = *(++argv);
1290 } else if (strcmp(*argv, "-client_max_proto") == 0) {
1293 client_max_proto = *(++argv);
1294 } else if (strcmp(*argv, "-should_negotiate") == 0) {
1297 should_negotiate = *(++argv);
1302 /* Try to process command using SSL_CONF */
1303 rv = SSL_CONF_cmd_argv(c_cctx, &argc, &argv);
1304 /* If not processed try server */
1306 rv = SSL_CONF_cmd_argv(s_cctx, &argc, &argv);
1307 /* Recognised: store it for later use */
1312 conf_args = sk_OPENSSL_STRING_new_null();
1316 if (!sk_OPENSSL_STRING_push(conf_args, arg))
1318 if (!sk_OPENSSL_STRING_push(conf_args, argn))
1323 BIO_printf(bio_err, "Missing argument for %s\n", arg);
1325 BIO_printf(bio_err, "Error with command %s\n", arg);
1327 BIO_printf(bio_err, "unknown option %s\n", arg);
1341 * test_cipherlist prevails over protocol switch: we test the cipherlist
1342 * for all enabled protocols.
1344 if (test_cipherlist == 1) {
1346 * ensure that the cipher list are correctly sorted and exit
1348 fprintf(stdout, "Testing cipherlist order only. Ignoring all "
1349 "other options.\n");
1350 if (do_test_cipherlist() == 0)
1356 if (ssl3 + tls1 + dtls + dtls1 + dtls12 > 1) {
1357 fprintf(stderr, "At most one of -ssl3, -tls1, -dtls, -dtls1 or -dtls12 should "
1362 #ifdef OPENSSL_NO_SSL3
1367 #ifdef OPENSSL_NO_TLS1
1372 #if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1)
1377 #if defined(OPENSSL_NO_DTLS) || defined(OPENSSL_NO_DTLS1_2)
1385 * Testing was requested for a compiled-out protocol (e.g. SSLv3).
1386 * Ideally, we would error out, but the generic test wrapper can't know
1387 * when to expect failure. So we do nothing and return success.
1390 fprintf(stderr, "Testing was requested for a disabled protocol. "
1391 "Skipping tests.\n");
1396 if (!ssl3 && !tls1 && !dtls && !dtls1 && !dtls12 && number > 1 && !reuse && !force) {
1397 fprintf(stderr, "This case cannot work. Use -f to perform "
1398 "the test anyway (and\n-d to see what happens), "
1399 "or add one of -ssl3, -tls1, -dtls, -dtls1, -dtls12, -reuse\n"
1400 "to avoid protocol mismatch.\n");
1405 if (!FIPS_mode_set(1)) {
1406 ERR_load_crypto_strings();
1407 ERR_print_errors(bio_err);
1410 fprintf(stderr, "*** IN FIPS MODE ***\n");
1416 fprintf(stderr, "Using BIO pair (-bio_pair)\n");
1419 if (number < 50 && !force)
1421 "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
1424 /* if (cipher == NULL) cipher=getenv("SSL_CIPHER"); */
1427 SSL_load_error_strings();
1429 #ifndef OPENSSL_NO_COMP
1430 if (comp == COMP_ZLIB)
1433 if (COMP_get_type(cm) != NID_undef) {
1434 if (SSL_COMP_add_compression_method(comp, cm) != 0) {
1435 fprintf(stderr, "Failed to add compression method\n");
1436 ERR_print_errors_fp(stderr);
1440 "Warning: %s compression not supported\n",
1441 comp == COMP_ZLIB ? "zlib" : "unknown");
1442 ERR_print_errors_fp(stderr);
1445 ssl_comp_methods = SSL_COMP_get_compression_methods();
1446 n = sk_SSL_COMP_num(ssl_comp_methods);
1449 printf("Available compression methods:");
1450 for (j = 0; j < n; j++) {
1451 SSL_COMP *c = sk_SSL_COMP_value(ssl_comp_methods, j);
1452 printf(" %s:%d", c->name, c->id);
1459 * At this point, ssl3/tls1 is only set if the protocol is available.
1460 * (Otherwise we exit early.) However the compiler doesn't know this, so
1463 #ifndef OPENSSL_NO_DTLS
1464 #ifndef OPENSSL_NO_DTLS1
1466 meth = DTLSv1_method();
1469 #ifndef OPENSSL_NO_DTLS1_2
1471 meth = DTLSv1_2_method();
1475 meth = DTLS_method();
1478 #ifndef OPENSSL_NO_SSL3
1480 meth = SSLv3_method();
1483 #ifndef OPENSSL_NO_TLS1
1485 meth = TLSv1_method();
1488 meth = TLS_method();
1490 c_ctx = SSL_CTX_new(meth);
1491 s_ctx = SSL_CTX_new(meth);
1492 if ((c_ctx == NULL) || (s_ctx == NULL)) {
1493 ERR_print_errors(bio_err);
1497 * Since we will use low security ciphersuites and keys for testing set
1498 * security level to zero by default. Tests can override this by adding
1499 * "@SECLEVEL=n" to the cipher string.
1501 SSL_CTX_set_security_level(c_ctx, 0);
1502 SSL_CTX_set_security_level(s_ctx, 0);
1504 if (cipher != NULL) {
1505 if (!SSL_CTX_set_cipher_list(c_ctx, cipher)
1506 || !SSL_CTX_set_cipher_list(s_ctx, cipher)) {
1507 ERR_print_errors(bio_err);
1512 /* Process SSL_CONF arguments */
1513 SSL_CONF_CTX_set_ssl_ctx(c_cctx, c_ctx);
1514 SSL_CONF_CTX_set_ssl_ctx(s_cctx, s_ctx);
1516 for (i = 0; i < sk_OPENSSL_STRING_num(conf_args); i += 2) {
1518 arg = sk_OPENSSL_STRING_value(conf_args, i);
1519 argn = sk_OPENSSL_STRING_value(conf_args, i + 1);
1520 rv = SSL_CONF_cmd(c_cctx, arg, argn);
1521 /* If not recognised use server context */
1523 rv = SSL_CONF_cmd(s_cctx, arg, argn);
1525 BIO_printf(bio_err, "Error processing %s %s\n",
1526 arg, argn ? argn : "");
1527 ERR_print_errors(bio_err);
1532 if (!SSL_CONF_CTX_finish(s_cctx) || !SSL_CONF_CTX_finish(c_cctx)) {
1533 BIO_puts(bio_err, "Error finishing context\n");
1534 ERR_print_errors(bio_err);
1537 #ifndef OPENSSL_NO_DH
1541 * use SSL_OP_SINGLE_DH_USE to avoid small subgroup attacks
1543 SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_DH_USE);
1544 dh = get_dh1024dsa();
1549 SSL_CTX_set_tmp_dh(s_ctx, dh);
1556 #ifndef OPENSSL_NO_EC
1560 if (named_curve != NULL) {
1561 nid = OBJ_sn2nid(named_curve);
1563 BIO_printf(bio_err, "unknown curve name (%s)\n", named_curve);
1567 nid = NID_X9_62_prime256v1;
1570 ecdh = EC_KEY_new_by_curve_name(nid);
1572 BIO_printf(bio_err, "unable to create curve\n");
1576 SSL_CTX_set_tmp_ecdh(s_ctx, ecdh);
1577 SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_ECDH_USE);
1584 if ((!SSL_CTX_load_verify_locations(s_ctx, CAfile, CApath)) ||
1585 (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1586 (!SSL_CTX_load_verify_locations(c_ctx, CAfile, CApath)) ||
1587 (!SSL_CTX_set_default_verify_paths(c_ctx))) {
1588 /* fprintf(stderr,"SSL_load_verify_locations\n"); */
1589 ERR_print_errors(bio_err);
1594 printf("client authentication\n");
1595 SSL_CTX_set_verify(s_ctx,
1596 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1598 SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback,
1602 printf("server authentication\n");
1603 SSL_CTX_set_verify(c_ctx, SSL_VERIFY_PEER, verify_callback);
1604 SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback,
1609 int session_id_context = 0;
1610 if (!SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context,
1611 sizeof session_id_context)) {
1612 ERR_print_errors(bio_err);
1617 /* Use PSK only if PSK key is given */
1618 if (psk_key != NULL) {
1620 * no_psk is used to avoid putting psk command to openssl tool
1624 * if PSK is not compiled in and psk key is given, do nothing and
1630 #ifndef OPENSSL_NO_PSK
1631 SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1632 SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1634 BIO_printf(bio_err, "setting PSK identity hint to s_ctx\n");
1635 if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint")) {
1636 BIO_printf(bio_err, "error setting PSK identity hint to s_ctx\n");
1637 ERR_print_errors(bio_err);
1642 #ifndef OPENSSL_NO_SRP
1643 if (srp_client_arg.srplogin) {
1644 if (!SSL_CTX_set_srp_username(c_ctx, srp_client_arg.srplogin)) {
1645 BIO_printf(bio_err, "Unable to set SRP username\n");
1648 SSL_CTX_set_srp_cb_arg(c_ctx, &srp_client_arg);
1649 SSL_CTX_set_srp_client_pwd_callback(c_ctx,
1650 ssl_give_srp_client_pwd_cb);
1652 * SSL_CTX_set_srp_strength(c_ctx, srp_client_arg.strength);
1656 if (srp_server_arg.expected_user != NULL) {
1657 SSL_CTX_set_verify(s_ctx, SSL_VERIFY_NONE, verify_callback);
1658 SSL_CTX_set_srp_cb_arg(s_ctx, &srp_server_arg);
1659 SSL_CTX_set_srp_username_callback(s_ctx, ssl_srp_server_param_cb);
1663 #ifndef OPENSSL_NO_NEXTPROTONEG
1665 SSL_CTX_set_next_proto_select_cb(c_ctx, cb_client_npn, NULL);
1668 if (npn_server_reject) {
1670 "Can't have both -npn_server and -npn_server_reject\n");
1673 SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_npn, NULL);
1675 if (npn_server_reject) {
1676 SSL_CTX_set_next_protos_advertised_cb(s_ctx, cb_server_rejects_npn,
1681 if (serverinfo_sct) {
1682 if (!SSL_CTX_add_client_custom_ext(c_ctx, SCT_EXT_TYPE,
1684 serverinfo_cli_parse_cb, NULL)) {
1685 BIO_printf(bio_err, "Error adding SCT extension\n");
1689 if (serverinfo_tack) {
1690 if (!SSL_CTX_add_client_custom_ext(c_ctx, TACK_EXT_TYPE,
1692 serverinfo_cli_parse_cb, NULL)) {
1693 BIO_printf(bio_err, "Error adding TACK extension\n");
1697 if (serverinfo_file)
1698 if (!SSL_CTX_use_serverinfo_file(s_ctx, serverinfo_file)) {
1699 BIO_printf(bio_err, "missing serverinfo file\n");
1704 if (!SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_0,
1705 custom_ext_0_cli_add_cb,
1707 custom_ext_0_cli_parse_cb, NULL)
1708 || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_1,
1709 custom_ext_1_cli_add_cb,
1711 custom_ext_1_cli_parse_cb, NULL)
1712 || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_2,
1713 custom_ext_2_cli_add_cb,
1715 custom_ext_2_cli_parse_cb, NULL)
1716 || !SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_3,
1717 custom_ext_3_cli_add_cb,
1719 custom_ext_3_cli_parse_cb, NULL)
1720 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_0,
1721 custom_ext_0_srv_add_cb,
1723 custom_ext_0_srv_parse_cb, NULL)
1724 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_1,
1725 custom_ext_1_srv_add_cb,
1727 custom_ext_1_srv_parse_cb, NULL)
1728 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_2,
1729 custom_ext_2_srv_add_cb,
1731 custom_ext_2_srv_parse_cb, NULL)
1732 || !SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_3,
1733 custom_ext_3_srv_add_cb,
1735 custom_ext_3_srv_parse_cb, NULL)) {
1736 BIO_printf(bio_err, "Error setting custom extensions\n");
1742 SSL_CTX_set_alpn_select_cb(s_ctx, cb_server_alpn, NULL);
1745 unsigned short alpn_len;
1746 unsigned char *alpn = next_protos_parse(&alpn_len, alpn_client);
1749 BIO_printf(bio_err, "Error parsing -alpn_client argument\n");
1752 /* Returns 0 on success!! */
1753 if (SSL_CTX_set_alpn_protos(c_ctx, alpn, alpn_len)) {
1754 BIO_printf(bio_err, "Error setting ALPN\n");
1761 c_ssl = SSL_new(c_ctx);
1762 s_ssl = SSL_new(s_ctx);
1764 if (!set_protocol_version(server_min_proto, s_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1766 if (!set_protocol_version(server_max_proto, s_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1768 if (!set_protocol_version(client_min_proto, c_ssl, SSL_CTRL_SET_MIN_PROTO_VERSION))
1770 if (!set_protocol_version(client_max_proto, c_ssl, SSL_CTRL_SET_MAX_PROTO_VERSION))
1773 BIO_printf(bio_stdout, "Doing handshakes=%d bytes=%ld\n", number, bytes);
1774 for (i = 0; i < number; i++) {
1776 if (!SSL_set_session(c_ssl, NULL)) {
1777 BIO_printf(bio_err, "Failed to set session\n");
1782 ret = doit_biopair(s_ssl, c_ssl, bytes, &s_time, &c_time);
1784 ret = doit(s_ssl, c_ssl, bytes);
1788 if (should_negotiate && ret == 0 &&
1789 strcmp(should_negotiate, "fail-server") != 0 &&
1790 strcmp(should_negotiate, "fail-client") != 0) {
1791 int version = protocol_from_string(should_negotiate);
1793 BIO_printf(bio_err, "Error parsing: %s\n", should_negotiate);
1797 if (SSL_version(c_ssl) != version) {
1798 BIO_printf(bio_err, "Unxpected version negotiated. "
1799 "Expected: %s, got %s\n", should_negotiate, SSL_get_version(c_ssl));
1806 print_details(c_ssl, "");
1809 #ifdef CLOCKS_PER_SEC
1811 * "To determine the time in seconds, the value returned by the clock
1812 * function should be divided by the value of the macro
1813 * CLOCKS_PER_SEC." -- ISO/IEC 9899
1815 BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1816 "Approximate total client time: %6.2f s\n",
1817 (double)s_time / CLOCKS_PER_SEC,
1818 (double)c_time / CLOCKS_PER_SEC);
1820 BIO_printf(bio_stdout,
1821 "Approximate total server time: %6.2f units\n"
1822 "Approximate total client time: %6.2f units\n",
1823 (double)s_time, (double)c_time);
1832 SSL_CTX_free(s_ctx);
1833 SSL_CTX_free(c_ctx);
1834 SSL_CONF_CTX_free(s_cctx);
1835 SSL_CONF_CTX_free(c_cctx);
1836 sk_OPENSSL_STRING_free(conf_args);
1838 BIO_free(bio_stdout);
1840 #ifndef OPENSSL_NO_ENGINE
1843 CONF_modules_unload(1);
1844 CRYPTO_cleanup_all_ex_data();
1846 ERR_remove_thread_state(NULL);
1848 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
1849 CRYPTO_mem_leaks(bio_err);
1855 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
1856 clock_t *s_time, clock_t *c_time)
1858 long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1859 BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1860 BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
1862 int err_in_client = 0;
1863 int err_in_server = 0;
1865 size_t bufsiz = 256; /* small buffer for testing */
1867 if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
1869 if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
1872 s_ssl_bio = BIO_new(BIO_f_ssl());
1876 c_ssl_bio = BIO_new(BIO_f_ssl());
1880 SSL_set_connect_state(c_ssl);
1881 SSL_set_bio(c_ssl, client, client);
1882 (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1884 SSL_set_accept_state(s_ssl);
1885 SSL_set_bio(s_ssl, server, server);
1886 (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1890 * c_ssl_bio: SSL filter BIO
1892 * client: pseudo-I/O for SSL library
1894 * client_io: client's SSL communication; usually to be
1895 * relayed over some I/O facility, but in this
1896 * test program, we're the server, too:
1898 * server_io: server's SSL communication
1900 * server: pseudo-I/O for SSL library
1902 * s_ssl_bio: SSL filter BIO
1904 * The client and the server each employ a "BIO pair":
1905 * client + client_io, server + server_io.
1906 * BIO pairs are symmetric. A BIO pair behaves similar
1907 * to a non-blocking socketpair (but both endpoints must
1908 * be handled by the same thread).
1909 * [Here we could connect client and server to the ends
1910 * of a single BIO pair, but then this code would be less
1911 * suitable as an example for BIO pairs in general.]
1913 * Useful functions for querying the state of BIO pair endpoints:
1915 * BIO_ctrl_pending(bio) number of bytes we can read now
1916 * BIO_ctrl_get_read_request(bio) number of bytes needed to fulfil
1917 * other side's read attempt
1918 * BIO_ctrl_get_write_guarantee(bio) number of bytes we can write now
1920 * ..._read_request is never more than ..._write_guarantee;
1921 * it depends on the application which one you should use.
1925 * We have non-blocking behaviour throughout this test program, but
1926 * can be sure that there is *some* progress in each iteration; so we
1927 * don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE --
1928 * we just try everything in each iteration
1934 char cbuf[1024 * 8];
1936 clock_t c_clock = clock();
1938 memset(cbuf, 0, sizeof(cbuf));
1941 if (SSL_in_init(c_ssl))
1942 printf("client waiting in SSL_connect - %s\n",
1943 SSL_state_string_long(c_ssl));
1946 /* Write to server. */
1948 if (cw_num > (long)sizeof cbuf)
1952 r = BIO_write(c_ssl_bio, cbuf, i);
1954 if (!BIO_should_retry(c_ssl_bio)) {
1955 fprintf(stderr, "ERROR in CLIENT\n");
1960 * BIO_should_retry(...) can just be ignored here. The
1961 * library expects us to call BIO_write with the same
1962 * arguments again, and that's what we will do in the
1965 } else if (r == 0) {
1966 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1970 printf("client wrote %d\n", r);
1976 /* Read from server. */
1978 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1980 if (!BIO_should_retry(c_ssl_bio)) {
1981 fprintf(stderr, "ERROR in CLIENT\n");
1986 * Again, "BIO_should_retry" can be ignored.
1988 } else if (r == 0) {
1989 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
1993 printf("client read %d\n", r);
1999 * c_time and s_time increments will typically be very small
2000 * (depending on machine speed and clock tick intervals), but
2001 * sampling over a large number of connections should result in
2002 * fairly accurate figures. We cannot guarantee a lot, however
2003 * -- if each connection lasts for exactly one clock tick, it
2004 * will be counted only for the client or only for the server or
2007 *c_time += (clock() - c_clock);
2013 char sbuf[1024 * 8];
2015 clock_t s_clock = clock();
2017 memset(sbuf, 0, sizeof(sbuf));
2020 if (SSL_in_init(s_ssl))
2021 printf("server waiting in SSL_accept - %s\n",
2022 SSL_state_string_long(s_ssl));
2025 /* Write to client. */
2027 if (sw_num > (long)sizeof sbuf)
2031 r = BIO_write(s_ssl_bio, sbuf, i);
2033 if (!BIO_should_retry(s_ssl_bio)) {
2034 fprintf(stderr, "ERROR in SERVER\n");
2038 /* Ignore "BIO_should_retry". */
2039 } else if (r == 0) {
2040 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2044 printf("server wrote %d\n", r);
2050 /* Read from client. */
2052 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
2054 if (!BIO_should_retry(s_ssl_bio)) {
2055 fprintf(stderr, "ERROR in SERVER\n");
2060 } else if (r == 0) {
2061 fprintf(stderr, "SSL SERVER STARTUP FAILED\n");
2065 printf("server read %d\n", r);
2070 *s_time += (clock() - s_clock);
2074 /* "I/O" BETWEEN CLIENT AND SERVER. */
2077 BIO *io1 = server_io, *io2 = client_io;
2079 * we use the non-copying interface for io1 and the standard
2080 * BIO_write/BIO_read interface for io2
2083 static int prev_progress = 1;
2091 r1 = BIO_ctrl_pending(io1);
2092 r2 = BIO_ctrl_get_write_guarantee(io2);
2100 if (INT_MAX < num) /* yeah, right */
2103 r = BIO_nread(io1, &dataptr, (int)num);
2105 assert(r <= (int)num);
2107 * possibly r < num (non-contiguous data)
2110 r = BIO_write(io2, dataptr, (int)num);
2111 if (r != (int)num) { /* can't happen */
2112 fprintf(stderr, "ERROR: BIO_write could not write "
2113 "BIO_ctrl_get_write_guarantee() bytes");
2119 printf((io1 == client_io) ?
2120 "C->S relaying: %d bytes\n" :
2121 "S->C relaying: %d bytes\n", (int)num);
2131 r1 = BIO_ctrl_pending(io2);
2132 r2 = BIO_ctrl_get_read_request(io1);
2134 * here we could use ..._get_write_guarantee instead of
2135 * ..._get_read_request, but by using the latter we test
2136 * restartability of the SSL implementation more thoroughly
2148 --num; /* test restartability even more thoroughly */
2150 r = BIO_nwrite0(io1, &dataptr);
2154 r = BIO_read(io2, dataptr, (int)num);
2155 if (r != (int)num) { /* can't happen */
2156 fprintf(stderr, "ERROR: BIO_read could not read "
2157 "BIO_ctrl_pending() bytes");
2161 r = BIO_nwrite(io1, &dataptr, (int)num);
2162 if (r != (int)num) { /* can't happen */
2163 fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
2164 "BIO_nwrite0() bytes");
2169 printf((io2 == client_io) ?
2170 "C->S relaying: %d bytes\n" :
2171 "S->C relaying: %d bytes\n", (int)num);
2173 } /* no loop, BIO_ctrl_get_read_request now
2174 * returns 0 anyway */
2176 if (!progress && !prev_progress)
2177 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0) {
2178 fprintf(stderr, "ERROR: got stuck\n");
2179 fprintf(stderr, " ERROR.\n");
2182 prev_progress = progress;
2185 while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2188 print_details(c_ssl, "DONE via BIO pair: ");
2189 #ifndef OPENSSL_NO_NEXTPROTONEG
2190 if (verify_npn(c_ssl, s_ssl) < 0) {
2195 if (verify_serverinfo() < 0) {
2196 fprintf(stderr, "Server info verify error\n");
2200 if (verify_alpn(c_ssl, s_ssl) < 0) {
2205 if (custom_ext_error) {
2206 fprintf(stderr, "Custom extension error\n");
2215 ERR_print_errors(bio_err);
2218 BIO_free(server_io);
2220 BIO_free(client_io);
2221 BIO_free(s_ssl_bio);
2222 BIO_free(c_ssl_bio);
2224 if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2225 ret = (err_in_client != 0) ? 0 : 1;
2226 else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2227 ret = (err_in_server != 0) ? 0 : 1;
2237 int doit(SSL *s_ssl, SSL *c_ssl, long count)
2239 char *cbuf = NULL, *sbuf = NULL;
2241 long cw_num = count, cr_num = count;
2242 long sw_num = count, sr_num = count;
2248 int c_r, c_w, s_r, s_w;
2251 int c_write, s_write;
2252 int do_server = 0, do_client = 0;
2253 int max_frag = 5 * 1024;
2254 int err_in_client = 0;
2255 int err_in_server = 0;
2257 bufsiz = count > 40 * 1024 ? 40 * 1024 : count;
2259 if ((cbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2261 if ((sbuf = OPENSSL_zalloc(bufsiz)) == NULL)
2264 c_to_s = BIO_new(BIO_s_mem());
2265 s_to_c = BIO_new(BIO_s_mem());
2266 if ((s_to_c == NULL) || (c_to_s == NULL)) {
2267 ERR_print_errors(bio_err);
2271 c_bio = BIO_new(BIO_f_ssl());
2272 s_bio = BIO_new(BIO_f_ssl());
2273 if ((c_bio == NULL) || (s_bio == NULL)) {
2274 ERR_print_errors(bio_err);
2278 SSL_set_connect_state(c_ssl);
2279 SSL_set_bio(c_ssl, s_to_c, c_to_s);
2280 SSL_set_max_send_fragment(c_ssl, max_frag);
2281 BIO_set_ssl(c_bio, c_ssl, BIO_NOCLOSE);
2283 SSL_set_accept_state(s_ssl);
2284 SSL_set_bio(s_ssl, c_to_s, s_to_c);
2285 SSL_set_max_send_fragment(s_ssl, max_frag);
2286 BIO_set_ssl(s_bio, s_ssl, BIO_NOCLOSE);
2292 c_write = 1, s_write = 0;
2294 /* We can always do writes */
2299 i = (int)BIO_pending(s_bio);
2300 if ((i && s_r) || s_w)
2303 i = (int)BIO_pending(c_bio);
2304 if ((i && c_r) || c_w)
2307 if (do_server && debug) {
2308 if (SSL_in_init(s_ssl))
2309 printf("server waiting in SSL_accept - %s\n",
2310 SSL_state_string_long(s_ssl));
2313 printf("server:SSL_write()\n");
2315 printf("server:SSL_read()\n"); */
2318 if (do_client && debug) {
2319 if (SSL_in_init(c_ssl))
2320 printf("client waiting in SSL_connect - %s\n",
2321 SSL_state_string_long(c_ssl));
2324 printf("client:SSL_write()\n");
2326 printf("client:SSL_read()\n"); */
2329 if (!do_client && !do_server) {
2330 fprintf(stdout, "ERROR IN STARTUP\n");
2331 ERR_print_errors(bio_err);
2334 if (do_client && !(done & C_DONE)) {
2336 j = (cw_num > bufsiz) ? (int)bufsiz : (int)cw_num;
2337 i = BIO_write(c_bio, cbuf, j);
2341 if (BIO_should_retry(c_bio)) {
2342 if (BIO_should_read(c_bio))
2344 if (BIO_should_write(c_bio))
2347 fprintf(stderr, "ERROR in CLIENT\n");
2349 ERR_print_errors(bio_err);
2352 } else if (i == 0) {
2353 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2357 printf("client wrote %d\n", i);
2362 if (max_frag > 1029)
2363 SSL_set_max_send_fragment(c_ssl, max_frag -= 5);
2366 i = BIO_read(c_bio, cbuf, bufsiz);
2370 if (BIO_should_retry(c_bio)) {
2371 if (BIO_should_read(c_bio))
2373 if (BIO_should_write(c_bio))
2376 fprintf(stderr, "ERROR in CLIENT\n");
2378 ERR_print_errors(bio_err);
2381 } else if (i == 0) {
2382 fprintf(stderr, "SSL CLIENT STARTUP FAILED\n");
2386 printf("client read %d\n", i);
2395 done = S_DONE | C_DONE;
2401 if (do_server && !(done & S_DONE)) {
2403 i = BIO_read(s_bio, sbuf, bufsiz);
2407 if (BIO_should_retry(s_bio)) {
2408 if (BIO_should_read(s_bio))
2410 if (BIO_should_write(s_bio))
2413 fprintf(stderr, "ERROR in SERVER\n");
2415 ERR_print_errors(bio_err);
2418 } else if (i == 0) {
2419 ERR_print_errors(bio_err);
2421 "SSL SERVER STARTUP FAILED in SSL_read\n");
2425 printf("server read %d\n", i);
2438 j = (sw_num > bufsiz) ? (int)bufsiz : (int)sw_num;
2439 i = BIO_write(s_bio, sbuf, j);
2443 if (BIO_should_retry(s_bio)) {
2444 if (BIO_should_read(s_bio))
2446 if (BIO_should_write(s_bio))
2449 fprintf(stderr, "ERROR in SERVER\n");
2451 ERR_print_errors(bio_err);
2454 } else if (i == 0) {
2455 ERR_print_errors(bio_err);
2457 "SSL SERVER STARTUP FAILED in SSL_write\n");
2461 printf("server wrote %d\n", i);
2467 if (max_frag > 1029)
2468 SSL_set_max_send_fragment(s_ssl, max_frag -= 5);
2473 if ((done & S_DONE) && (done & C_DONE))
2478 print_details(c_ssl, "DONE: ");
2479 #ifndef OPENSSL_NO_NEXTPROTONEG
2480 if (verify_npn(c_ssl, s_ssl) < 0) {
2485 if (verify_serverinfo() < 0) {
2486 fprintf(stderr, "Server info verify error\n");
2490 if (custom_ext_error) {
2491 fprintf(stderr, "Custom extension error\n");
2498 * We have to set the BIO's to NULL otherwise they will be
2499 * OPENSSL_free()ed twice. Once when th s_ssl is SSL_free()ed and again
2500 * when c_ssl is SSL_free()ed. This is a hack required because s_ssl and
2501 * c_ssl are sharing the same BIO structure and SSL_set_bio() and
2502 * SSL_free() automatically BIO_free non NULL entries. You should not
2503 * normally do this or be required to do this
2505 if (s_ssl != NULL) {
2509 if (c_ssl != NULL) {
2516 BIO_free_all(c_bio);
2517 BIO_free_all(s_bio);
2521 if (should_negotiate != NULL && strcmp(should_negotiate, "fail-client") == 0)
2522 ret = (err_in_client != 0) ? 0 : 1;
2523 else if (should_negotiate != NULL && strcmp(should_negotiate, "fail-server") == 0)
2524 ret = (err_in_server != 0) ? 0 : 1;
2529 static int get_proxy_auth_ex_data_idx(void)
2531 static volatile int idx = -1;
2533 CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
2535 idx = X509_STORE_CTX_get_ex_new_index(0,
2536 "SSLtest for verify callback",
2539 CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
2544 static int verify_callback(int ok, X509_STORE_CTX *ctx)
2548 s = X509_NAME_oneline(X509_get_subject_name(ctx->current_cert), buf,
2552 printf("depth=%d %s\n", ctx->error_depth, buf);
2554 fprintf(stderr, "depth=%d error=%d %s\n",
2555 ctx->error_depth, ctx->error, buf);
2560 switch (ctx->error) {
2562 fprintf(stderr, "Error string: %s\n",
2563 X509_verify_cert_error_string(ctx->error));
2565 case X509_V_ERR_CERT_NOT_YET_VALID:
2566 case X509_V_ERR_CERT_HAS_EXPIRED:
2567 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2573 X509 *xs = ctx->current_cert;
2574 if (X509_get_extension_flags(xs) & EXFLAG_PROXY) {
2575 unsigned int *letters = X509_STORE_CTX_get_ex_data(ctx,
2576 get_proxy_auth_ex_data_idx
2582 PROXY_CERT_INFO_EXTENSION *pci =
2583 X509_get_ext_d2i(xs, NID_proxyCertInfo,
2586 switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage)) {
2587 case NID_Independent:
2589 * Completely meaningless in this program, as there's no
2590 * way to grant explicit rights to a specific PrC.
2591 * Basically, using id-ppl-Independent is the perfect way
2592 * to grant no rights at all.
2594 fprintf(stderr, " Independent proxy certificate");
2595 for (i = 0; i < 26; i++)
2598 case NID_id_ppl_inheritAll:
2600 * This is basically a NOP, we simply let the current
2601 * rights stand as they are.
2603 fprintf(stderr, " Proxy certificate inherits all");
2607 pci->proxyPolicy->policy->data;
2608 i = pci->proxyPolicy->policy->length;
2611 * The algorithm works as follows: it is assumed that
2612 * previous iterations or the initial granted rights has
2613 * already set some elements of `letters'. What we need
2614 * to do is to clear those that weren't granted by the
2615 * current PrC as well. The easiest way to do this is to
2616 * add 1 to all the elements whose letters are given with
2617 * the current policy. That way, all elements that are
2618 * set by the current policy and were already set by
2619 * earlier policies and through the original grant of
2620 * rights will get the value 2 or higher. The last thing
2621 * to do is to sweep through `letters' and keep the
2622 * elements having the value 2 as set, and clear all the
2626 printf(" Certificate proxy rights = %*.*s", i,
2630 if (isascii(c) && isalpha(c)) {
2636 for (i = 0; i < 26; i++)
2644 printf(", resulting proxy rights = ");
2645 for (i = 0; i < 26; i++)
2647 printf("%c", i + 'A');
2654 PROXY_CERT_INFO_EXTENSION_free(pci);
2662 static void process_proxy_debug(int indent, const char *format, ...)
2665 static const char indentation[] =
2666 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
2667 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
2668 char my_format[256];
2671 BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
2672 indent, indent, indentation, format);
2674 va_start(args, format);
2675 vfprintf(stderr, my_format, args);
2685 static int process_proxy_cond_adders(unsigned int letters[26],
2686 const char *cond, const char **cond_end,
2687 int *pos, int indent);
2688 static int process_proxy_cond_val(unsigned int letters[26], const char *cond,
2689 const char **cond_end, int *pos, int indent)
2695 while (isspace((int)*cond)) {
2702 process_proxy_debug(indent,
2703 "Start process_proxy_cond_val at position %d: %s\n",
2710 while (isspace((int)*cond)) {
2720 ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
2725 while (isspace((int)*cond)) {
2732 "Weird condition character in position %d: "
2739 } else if (isascii(c) && isalpha(c)) {
2742 ok = letters[c - 'A'];
2747 "Weird condition character in position %d: " "%c\n", *pos, c);
2753 if (ok >= 0 && negate)
2757 process_proxy_debug(indent,
2758 "End process_proxy_cond_val at position %d: %s, returning %d\n",
2764 static int process_proxy_cond_multipliers(unsigned int letters[26],
2766 const char **cond_end, int *pos,
2773 process_proxy_debug(indent,
2774 "Start process_proxy_cond_multipliers at position %d: %s\n",
2777 ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
2783 while (isspace((int)*cond)) {
2797 ok = process_proxy_cond_val(letters,
2798 cond, cond_end, pos, indent + 1);
2811 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2823 process_proxy_debug(indent,
2824 "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
2831 static int process_proxy_cond_adders(unsigned int letters[26],
2832 const char *cond, const char **cond_end,
2833 int *pos, int indent)
2839 process_proxy_debug(indent,
2840 "Start process_proxy_cond_adders at position %d: %s\n",
2843 ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
2850 while (isspace((int)*cond)) {
2863 ok = process_proxy_cond_multipliers(letters,
2864 cond, cond_end, pos,
2875 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2887 process_proxy_debug(indent,
2888 "End process_proxy_cond_adders at position %d: %s, returning %d\n",
2895 static int process_proxy_cond(unsigned int letters[26],
2896 const char *cond, const char **cond_end)
2899 return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
2902 static int app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2905 struct app_verify_arg *cb_arg = arg;
2906 unsigned int letters[26]; /* only used with proxy_auth */
2908 if (cb_arg->app_verify) {
2909 char *s = NULL, buf[256];
2911 printf("In app_verify_callback, allowing cert. ");
2912 printf("Arg is: %s\n", cb_arg->string);
2913 printf("Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2914 (void *)ctx, (void *)ctx->cert);
2916 s = X509_NAME_oneline(X509_get_subject_name(ctx->cert), buf, 256);
2918 printf("cert depth=%d %s\n", ctx->error_depth, buf);
2922 if (cb_arg->proxy_auth) {
2923 int found_any = 0, i;
2926 for (i = 0; i < 26; i++)
2928 for (sp = cb_arg->proxy_auth; *sp; sp++) {
2930 if (isascii(c) && isalpha(c)) {
2933 letters[c - 'A'] = 1;
2937 printf(" Initial proxy rights = ");
2938 for (i = 0; i < 26; i++)
2940 printf("%c", i + 'A');
2947 X509_STORE_CTX_set_ex_data(ctx,
2948 get_proxy_auth_ex_data_idx(), letters);
2950 if (cb_arg->allow_proxy_certs) {
2951 X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
2953 ok = X509_verify_cert(ctx);
2955 if (cb_arg->proxy_auth) {
2957 const char *cond_end = NULL;
2959 ok = process_proxy_cond(letters, cb_arg->proxy_cond, &cond_end);
2965 "Stopped processing condition before it's end.\n");
2970 "Proxy rights check with condition '%s' invalid\n",
2971 cb_arg->proxy_cond);
2973 printf("Proxy rights check with condition '%s' ok\n",
2974 cb_arg->proxy_cond);
2980 #ifndef OPENSSL_NO_DH
2982 * These DH parameters have been generated as follows:
2983 * $ openssl dhparam -C -noout 512
2984 * $ openssl dhparam -C -noout 1024
2985 * $ openssl dhparam -C -noout -dsaparam 1024
2986 * (The third function has been renamed to avoid name conflicts.)
2988 static DH *get_dh512()
2990 static unsigned char dh512_p[] = {
2991 0xCB, 0xC8, 0xE1, 0x86, 0xD0, 0x1F, 0x94, 0x17, 0xA6, 0x99, 0xF0,
2993 0x1F, 0x0D, 0xAC, 0xB6, 0x25, 0x3E, 0x06, 0x39, 0xCA, 0x72, 0x04,
2995 0x6E, 0xDA, 0xC0, 0x61, 0xE6, 0x7A, 0x77, 0x25, 0xE8, 0x3B, 0xB9,
2997 0x9A, 0xB6, 0xB5, 0xFE, 0x99, 0x0B, 0xA1, 0x93, 0x4E, 0x35, 0x33,
2999 0xE1, 0xF1, 0x13, 0x4F, 0x59, 0x1A, 0xD2, 0x57, 0xC0, 0x26, 0x21,
3001 0x02, 0xC5, 0xAE, 0x23,
3003 static unsigned char dh512_g[] = {
3008 if ((dh = DH_new()) == NULL)
3010 dh->p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
3011 dh->g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
3012 if ((dh->p == NULL) || (dh->g == NULL)) {
3019 static DH *get_dh1024()
3021 static unsigned char dh1024_p[] = {
3022 0xF8, 0x81, 0x89, 0x7D, 0x14, 0x24, 0xC5, 0xD1, 0xE6, 0xF7, 0xBF,
3024 0xE4, 0x90, 0xF4, 0xFC, 0x73, 0xFB, 0x34, 0xB5, 0xFA, 0x4C, 0x56,
3026 0xEA, 0xA7, 0xE9, 0xC0, 0xC0, 0xCE, 0x89, 0xE1, 0xFA, 0x63, 0x3F,
3028 0x6B, 0x32, 0x66, 0xF1, 0xD1, 0x7B, 0xB0, 0x00, 0x8F, 0xCA, 0x87,
3030 0xAE, 0x98, 0x89, 0x26, 0x17, 0xC2, 0x05, 0xD2, 0xEC, 0x08, 0xD0,
3032 0xFF, 0x17, 0x52, 0x8C, 0xC5, 0x07, 0x93, 0x03, 0xB1, 0xF6, 0x2F,
3034 0x1C, 0x52, 0x47, 0x27, 0x1B, 0xDB, 0xD1, 0x8D, 0x9D, 0x69, 0x1D,
3036 0x4B, 0x32, 0x81, 0xAA, 0x7F, 0x00, 0xC8, 0xDC, 0xE6, 0xD9, 0xCC,
3038 0x11, 0x2D, 0x37, 0x34, 0x6C, 0xEA, 0x02, 0x97, 0x4B, 0x0E, 0xBB,
3040 0x71, 0x33, 0x09, 0x15, 0xFD, 0xDD, 0x23, 0x87, 0x07, 0x5E, 0x89,
3042 0x6B, 0x7C, 0x5F, 0xEC, 0xA6, 0x24, 0xDC, 0x53,
3044 static unsigned char dh1024_g[] = {
3049 if ((dh = DH_new()) == NULL)
3051 dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
3052 dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
3053 if ((dh->p == NULL) || (dh->g == NULL)) {
3060 static DH *get_dh1024dsa()
3062 static unsigned char dh1024_p[] = {
3063 0xC8, 0x00, 0xF7, 0x08, 0x07, 0x89, 0x4D, 0x90, 0x53, 0xF3, 0xD5,
3065 0x21, 0x1B, 0xF7, 0x31, 0xA6, 0xA2, 0xDA, 0x23, 0x9A, 0xC7, 0x87,
3067 0x3B, 0x47, 0xB6, 0x8C, 0x04, 0x6F, 0xFF, 0xC6, 0x9B, 0xB8, 0x65,
3069 0xC2, 0x5F, 0x31, 0x83, 0x4A, 0xA7, 0x5F, 0x2F, 0x88, 0x38, 0xB6,
3071 0xCF, 0xD9, 0x87, 0x6D, 0x6F, 0x9F, 0xDA, 0xAC, 0xA6, 0x48, 0xAF,
3073 0x33, 0x84, 0x37, 0x5B, 0x82, 0x4A, 0x31, 0x5D, 0xE7, 0xBD, 0x52,
3075 0xA1, 0x77, 0xBF, 0x10, 0x9E, 0x37, 0xEA, 0x64, 0xFA, 0xCA, 0x28,
3077 0x9D, 0x3B, 0xD2, 0x6E, 0x09, 0x5C, 0x68, 0xC7, 0x45, 0x90, 0xFD,
3079 0x70, 0xC9, 0x3A, 0xBB, 0xDF, 0xD4, 0x21, 0x0F, 0xC4, 0x6A, 0x3C,
3081 0x61, 0xCF, 0x3F, 0xD6, 0x13, 0xF1, 0x5F, 0xBC, 0xCF, 0xBC, 0x26,
3083 0xBC, 0x0B, 0xBD, 0xAB, 0x5D, 0xC9, 0x54, 0x39,
3085 static unsigned char dh1024_g[] = {
3086 0x3B, 0x40, 0x86, 0xE7, 0xF3, 0x6C, 0xDE, 0x67, 0x1C, 0xCC, 0x80,
3088 0x5A, 0xDF, 0xFE, 0xBD, 0x20, 0x27, 0x74, 0x6C, 0x24, 0xC9, 0x03,
3090 0xE1, 0x8D, 0xC3, 0x7D, 0x98, 0x27, 0x40, 0x08, 0xB8, 0x8C, 0x6A,
3092 0xBB, 0x1A, 0x3A, 0xD6, 0x86, 0x83, 0x5E, 0x72, 0x41, 0xCE, 0x85,
3094 0xD2, 0xB3, 0xFC, 0x13, 0xCE, 0x37, 0x81, 0x9E, 0x4C, 0x1C, 0x7B,
3096 0xD3, 0xE6, 0xA6, 0x00, 0xF5, 0x5A, 0x95, 0x43, 0x5E, 0x81, 0xCF,
3098 0xA2, 0x23, 0xFC, 0x36, 0xA7, 0x5D, 0x7A, 0x4C, 0x06, 0x91, 0x6E,
3100 0x57, 0xEE, 0x36, 0xCB, 0x06, 0xEA, 0xF5, 0x3D, 0x95, 0x49, 0xCB,
3102 0xDD, 0x81, 0xDF, 0x80, 0x09, 0x4A, 0x97, 0x4D, 0xA8, 0x22, 0x72,
3104 0x7F, 0xC4, 0x70, 0x56, 0x70, 0xE8, 0x20, 0x10, 0x18, 0x8F, 0x2E,
3106 0x07, 0xE7, 0x68, 0x1A, 0x82, 0x5D, 0x32, 0xA2,
3110 if ((dh = DH_new()) == NULL)
3112 dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
3113 dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
3114 if ((dh->p == NULL) || (dh->g == NULL)) {
3123 #ifndef OPENSSL_NO_PSK
3124 /* convert the PSK key (psk_key) in ascii to binary (psk) */
3125 static int psk_key2bn(const char *pskkey, unsigned char *psk,
3126 unsigned int max_psk_len)
3131 ret = BN_hex2bn(&bn, pskkey);
3133 BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
3138 if (BN_num_bytes(bn) > (int)max_psk_len) {
3140 "psk buffer of callback is too small (%d) for key (%d)\n",
3141 max_psk_len, BN_num_bytes(bn));
3145 ret = BN_bn2bin(bn, psk);
3150 static unsigned int psk_client_callback(SSL *ssl, const char *hint,
3152 unsigned int max_identity_len,
3154 unsigned int max_psk_len)
3157 unsigned int psk_len = 0;
3159 ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3163 fprintf(stderr, "client: created identity '%s' len=%d\n", identity,
3165 ret = psk_key2bn(psk_key, psk, max_psk_len);
3173 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3175 unsigned int max_psk_len)
3177 unsigned int psk_len = 0;
3179 if (strcmp(identity, "Client_identity") != 0) {
3180 BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3183 psk_len = psk_key2bn(psk_key, psk, max_psk_len);
3188 static int do_test_cipherlist(void)
3190 #if !defined(OPENSSL_NO_SSL3) || !defined(OPENSSL_NO_TLS1)
3192 const SSL_METHOD *meth;
3193 const SSL_CIPHER *ci, *tci = NULL;
3196 #ifndef OPENSSL_NO_SSL3
3197 meth = SSLv3_method();
3199 while ((ci = meth->get_cipher(i++)) != NULL) {
3201 if (ci->id >= tci->id) {
3202 fprintf(stderr, "testing SSLv3 cipher list order: ");
3203 fprintf(stderr, "failed %x vs. %x\n", ci->id, tci->id);
3209 #ifndef OPENSSL_NO_TLS1
3210 meth = TLSv1_method();
3212 while ((ci = meth->get_cipher(i++)) != NULL) {
3214 if (ci->id >= tci->id) {
3215 fprintf(stderr, "testing TLSv1 cipher list order: ");
3216 fprintf(stderr, "failed %x vs. %x\n", ci->id, tci->id);