2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
5 * This package is an SSL implementation written
6 * by Eric Young (eay@cryptsoft.com).
7 * The implementation was written so as to conform with Netscapes SSL.
9 * This library is free for commercial and non-commercial use as long as
10 * the following conditions are aheared to. The following conditions
11 * apply to all code found in this distribution, be it the RC4, RSA,
12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
13 * included with this distribution is covered by the same copyright terms
14 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
16 * Copyright remains Eric Young's, and as such any Copyright notices in
17 * the code are not to be removed.
18 * If this package is used in a product, Eric Young should be given attribution
19 * as the author of the parts of the library used.
20 * This can be in the form of a textual message at program startup or
21 * in documentation (online or textual) provided with the package.
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
26 * 1. Redistributions of source code must retain the copyright
27 * notice, this list of conditions and the following disclaimer.
28 * 2. Redistributions in binary form must reproduce the above copyright
29 * notice, this list of conditions and the following disclaimer in the
30 * documentation and/or other materials provided with the distribution.
31 * 3. All advertising materials mentioning features or use of this software
32 * must display the following acknowledgement:
33 * "This product includes cryptographic software written by
34 * Eric Young (eay@cryptsoft.com)"
35 * The word 'cryptographic' can be left out if the rouines from the library
36 * being used are not cryptographic related :-).
37 * 4. If you include any Windows specific code (or a derivative thereof) from
38 * the apps directory (application code) you must include an acknowledgement:
39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53 * The licence and distribution terms for any publically available version or
54 * derivative of this code cannot be changed. i.e. this code cannot simply be
55 * copied and put under another distribution licence
56 * [including the GNU Public Licence.]
58 /* ====================================================================
59 * Copyright (c) 1998-2000 The OpenSSL Project. All rights reserved.
61 * Redistribution and use in source and binary forms, with or without
62 * modification, are permitted provided that the following conditions
65 * 1. Redistributions of source code must retain the above copyright
66 * notice, this list of conditions and the following disclaimer.
68 * 2. Redistributions in binary form must reproduce the above copyright
69 * notice, this list of conditions and the following disclaimer in
70 * the documentation and/or other materials provided with the
73 * 3. All advertising materials mentioning features or use of this
74 * software must display the following acknowledgment:
75 * "This product includes software developed by the OpenSSL Project
76 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
78 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79 * endorse or promote products derived from this software without
80 * prior written permission. For written permission, please contact
81 * openssl-core@openssl.org.
83 * 5. Products derived from this software may not be called "OpenSSL"
84 * nor may "OpenSSL" appear in their names without prior written
85 * permission of the OpenSSL Project.
87 * 6. Redistributions of any form whatsoever must retain the following
89 * "This product includes software developed by the OpenSSL Project
90 * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
92 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
96 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103 * OF THE POSSIBILITY OF SUCH DAMAGE.
104 * ====================================================================
106 * This product includes cryptographic software written by Eric Young
107 * (eay@cryptsoft.com). This product includes software written by Tim
108 * Hudson (tjh@cryptsoft.com).
111 /* ====================================================================
112 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
113 * ECC cipher suite support in OpenSSL originally developed by
114 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
116 /* ====================================================================
117 * Copyright 2005 Nokia. All rights reserved.
119 * The portions of the attached software ("Contribution") is developed by
120 * Nokia Corporation and is licensed pursuant to the OpenSSL open source
123 * The Contribution, originally written by Mika Kousa and Pasi Eronen of
124 * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
125 * support (see RFC 4279) to OpenSSL.
127 * No patent licenses or other rights except those expressly stated in
128 * the OpenSSL open source license shall be deemed granted or received
129 * expressly, by implication, estoppel, or otherwise.
131 * No assurances are provided by Nokia that the Contribution does not
132 * infringe the patent or other intellectual property rights of any third
133 * party or that the license provides you with all the necessary rights
134 * to make use of the Contribution.
136 * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
137 * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
138 * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
139 * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
143 #define _BSD_SOURCE 1 /* Or gethostname won't be declared properly
144 on Linux and GNU platforms. */
157 #ifdef OPENSSL_SYS_VMS
158 #define _XOPEN_SOURCE 500 /* Or isascii won't be declared properly on
159 VMS (at least with DECompHP C). */
164 #include <openssl/bio.h>
165 #include <openssl/crypto.h>
166 #include <openssl/evp.h>
167 #include <openssl/x509.h>
168 #include <openssl/x509v3.h>
169 #include <openssl/ssl.h>
170 #ifndef OPENSSL_NO_ENGINE
171 #include <openssl/engine.h>
173 #include <openssl/err.h>
174 #include <openssl/rand.h>
175 #ifndef OPENSSL_NO_RSA
176 #include <openssl/rsa.h>
178 #ifndef OPENSSL_NO_DSA
179 #include <openssl/dsa.h>
181 #ifndef OPENSSL_NO_DH
182 #include <openssl/dh.h>
184 #ifndef OPENSSL_NO_SRP
185 #include <openssl/srp.h>
187 #include <openssl/bn.h>
189 #define _XOPEN_SOURCE_EXTENDED 1 /* Or gethostname won't be declared properly
190 on Compaq platforms (at least with DEC C).
191 Do not try to put it earlier, or IPv6 includes
195 #ifdef OPENSSL_SYS_WINDOWS
198 #include OPENSSL_UNISTD
201 #ifdef OPENSSL_SYS_VMS
202 # define TEST_SERVER_CERT "SYS$DISK:[-.APPS]SERVER.PEM"
203 # define TEST_CLIENT_CERT "SYS$DISK:[-.APPS]CLIENT.PEM"
204 #elif defined(OPENSSL_SYS_WINCE)
205 # define TEST_SERVER_CERT "\\OpenSSL\\server.pem"
206 # define TEST_CLIENT_CERT "\\OpenSSL\\client.pem"
207 #elif defined(OPENSSL_SYS_NETWARE)
208 # define TEST_SERVER_CERT "\\openssl\\apps\\server.pem"
209 # define TEST_CLIENT_CERT "\\openssl\\apps\\client.pem"
211 # define TEST_SERVER_CERT "../apps/server.pem"
212 # define TEST_CLIENT_CERT "../apps/client.pem"
215 /* There is really no standard for this, so let's assign some tentative
216 numbers. In any case, these numbers are only for this test */
220 static int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx);
221 #ifndef OPENSSL_NO_RSA
222 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export,int keylength);
223 static void free_tmp_rsa(void);
225 static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg);
226 #define APP_CALLBACK_STRING "Test Callback Argument"
227 struct app_verify_arg
231 int allow_proxy_certs;
236 #ifndef OPENSSL_NO_DH
237 static DH *get_dh512(void);
238 static DH *get_dh1024(void);
239 static DH *get_dh1024dsa(void);
243 static char *psk_key=NULL; /* by default PSK is not used */
244 #ifndef OPENSSL_NO_PSK
245 static unsigned int psk_client_callback(SSL *ssl, const char *hint, char *identity,
246 unsigned int max_identity_len, unsigned char *psk,
247 unsigned int max_psk_len);
248 static unsigned int psk_server_callback(SSL *ssl, const char *identity, unsigned char *psk,
249 unsigned int max_psk_len);
252 #ifndef OPENSSL_NO_SRP
254 /* This is a context that we pass to all callbacks */
255 typedef struct srp_client_arg_st
261 #define PWD_STRLEN 1024
263 static char * MS_CALLBACK ssl_give_srp_client_pwd_cb(SSL *s, void *arg)
265 SRP_CLIENT_ARG *srp_client_arg = (SRP_CLIENT_ARG *)arg;
266 return BUF_strdup((char *)srp_client_arg->srppassin);
270 /* This is a context that we pass to SRP server callbacks */
271 typedef struct srp_server_arg_st
277 static int MS_CALLBACK ssl_srp_server_param_cb(SSL *s, int *ad, void *arg)
279 SRP_SERVER_ARG * p = (SRP_SERVER_ARG *) arg;
281 if (strcmp(p->expected_user, SSL_get_srp_username(s)) != 0)
283 fprintf(stderr, "User %s doesn't exist\n", SSL_get_srp_username(s));
284 return SSL3_AL_FATAL;
286 if (SSL_set_srp_server_param_pw(s,p->expected_user,p->pass,"1024")<0)
288 *ad = SSL_AD_INTERNAL_ERROR;
289 return SSL3_AL_FATAL;
291 return SSL_ERROR_NONE;
295 static BIO *bio_err=NULL;
296 static BIO *bio_stdout=NULL;
298 static const char *alpn_client;
299 static const char *alpn_server;
300 static const char *alpn_expected;
301 static unsigned char *alpn_selected;
304 * next_protos_parse parses a comma separated list of strings into a string
305 * in a format suitable for passing to SSL_CTX_set_next_protos_advertised.
306 * outlen: (output) set to the length of the resulting buffer on success.
307 * err: (maybe NULL) on failure, an error message line is written to this BIO.
308 * in: a NUL terminated string like "abc,def,ghi"
310 * returns: a malloced buffer or NULL on failure.
312 static unsigned char *next_protos_parse(unsigned short *outlen, const char *in)
322 out = OPENSSL_malloc(strlen(in) + 1);
326 for (i = 0; i <= len; ++i)
328 if (i == len || in[i] == ',')
335 out[start] = i - start;
346 static int cb_server_alpn(SSL *s, const unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg)
348 unsigned char *protos;
349 unsigned short protos_len;
351 protos = next_protos_parse(&protos_len, alpn_server);
354 fprintf(stderr, "failed to parser ALPN server protocol string: %s\n", alpn_server);
358 if (SSL_select_next_proto((unsigned char**) out, outlen, protos, protos_len, in, inlen) !=
359 OPENSSL_NPN_NEGOTIATED)
361 OPENSSL_free(protos);
362 return SSL_TLSEXT_ERR_NOACK;
365 /* Make a copy of the selected protocol which will be freed in verify_alpn. */
366 alpn_selected = OPENSSL_malloc(*outlen);
367 memcpy(alpn_selected, *out, *outlen);
368 *out = alpn_selected;
370 OPENSSL_free(protos);
371 return SSL_TLSEXT_ERR_OK;
374 static int verify_alpn(SSL *client, SSL *server)
376 const unsigned char *client_proto, *server_proto;
377 unsigned int client_proto_len = 0, server_proto_len = 0;
378 SSL_get0_alpn_selected(client, &client_proto, &client_proto_len);
379 SSL_get0_alpn_selected(server, &server_proto, &server_proto_len);
381 if (alpn_selected != NULL)
383 OPENSSL_free(alpn_selected);
384 alpn_selected = NULL;
387 if (client_proto_len != server_proto_len ||
388 memcmp(client_proto, server_proto, client_proto_len) != 0)
390 BIO_printf(bio_stdout, "ALPN selected protocols differ!\n");
394 if (client_proto_len > 0 && alpn_expected == NULL)
396 BIO_printf(bio_stdout, "ALPN unexpectedly negotiated\n");
400 if (alpn_expected != NULL &&
401 (client_proto_len != strlen(alpn_expected) ||
402 memcmp(client_proto, alpn_expected, client_proto_len) != 0))
404 BIO_printf(bio_stdout, "ALPN selected protocols not equal to expected protocol: %s\n", alpn_expected);
411 BIO_printf(bio_stdout, "ALPN results: client: '");
412 BIO_write(bio_stdout, client_proto, client_proto_len);
413 BIO_printf(bio_stdout, "', server: '");
414 BIO_write(bio_stdout, server_proto, server_proto_len);
415 BIO_printf(bio_stdout, "'\n");
416 BIO_printf(bio_stdout, "ALPN configured: client: '%s', server: '%s'\n", alpn_client, alpn_server);
420 #define SCT_EXT_TYPE 18
422 /* WARNING : below extension types are *NOT* IETF assigned, and
423 could conflict if these types are reassigned and handled
424 specially by OpenSSL in the future */
425 #define TACK_EXT_TYPE 62208
426 #define CUSTOM_EXT_TYPE_0 1000
427 #define CUSTOM_EXT_TYPE_1 1001
428 #define CUSTOM_EXT_TYPE_2 1002
429 #define CUSTOM_EXT_TYPE_3 1003
431 const char custom_ext_cli_string[] = "abc";
432 const char custom_ext_srv_string[] = "defg";
434 /* These set from cmdline */
435 char* serverinfo_file = NULL;
436 int serverinfo_sct = 0;
437 int serverinfo_tack = 0;
439 /* These set based on extension callbacks */
440 int serverinfo_sct_seen = 0;
441 int serverinfo_tack_seen = 0;
442 int serverinfo_other_seen = 0;
444 /* This set from cmdline */
447 /* This set based on extension callbacks */
448 int custom_ext_error = 0;
450 static int serverinfo_cli_parse_cb(SSL *s, unsigned int ext_type,
451 const unsigned char *in, size_t inlen,
454 if (ext_type == SCT_EXT_TYPE)
455 serverinfo_sct_seen++;
456 else if (ext_type == TACK_EXT_TYPE)
457 serverinfo_tack_seen++;
459 serverinfo_other_seen++;
463 static int verify_serverinfo()
465 if (serverinfo_sct != serverinfo_sct_seen)
467 if (serverinfo_tack != serverinfo_tack_seen)
469 if (serverinfo_other_seen)
475 * Four test cases for custom extensions:
476 * 0 - no ClientHello extension or ServerHello response
477 * 1 - ClientHello with "abc", no response
478 * 2 - ClientHello with "abc", empty response
479 * 3 - ClientHello with "abc", "defg" response
482 static int custom_ext_0_cli_add_cb(SSL *s, unsigned int ext_type,
483 const unsigned char **out,
484 size_t *outlen, int *al, void *arg)
486 if (ext_type != CUSTOM_EXT_TYPE_0)
487 custom_ext_error = 1;
488 return 0; /* Don't send an extension */
491 static int custom_ext_0_cli_parse_cb(SSL *s, unsigned int ext_type,
492 const unsigned char *in,
493 size_t inlen, int *al,
499 static int custom_ext_1_cli_add_cb(SSL *s, unsigned int ext_type,
500 const unsigned char **out,
501 size_t *outlen, int *al, void *arg)
503 if (ext_type != CUSTOM_EXT_TYPE_1)
504 custom_ext_error = 1;
505 *out = (const unsigned char*)custom_ext_cli_string;
506 *outlen = strlen(custom_ext_cli_string);
507 return 1; /* Send "abc" */
510 static int custom_ext_1_cli_parse_cb(SSL *s, unsigned int ext_type,
511 const unsigned char *in,
512 size_t inlen, int *al,
518 static int custom_ext_2_cli_add_cb(SSL *s, unsigned int ext_type,
519 const unsigned char **out,
520 size_t *outlen, int *al, void *arg)
522 if (ext_type != CUSTOM_EXT_TYPE_2)
523 custom_ext_error = 1;
524 *out = (const unsigned char*)custom_ext_cli_string;
525 *outlen = strlen(custom_ext_cli_string);
526 return 1; /* Send "abc" */
529 static int custom_ext_2_cli_parse_cb(SSL *s, unsigned int ext_type,
530 const unsigned char *in,
531 size_t inlen, int *al,
534 if (ext_type != CUSTOM_EXT_TYPE_2)
535 custom_ext_error = 1;
537 custom_ext_error = 1; /* Should be empty response */
541 static int custom_ext_3_cli_add_cb(SSL *s, unsigned int ext_type,
542 const unsigned char **out,
543 size_t *outlen, int *al, void *arg)
545 if (ext_type != CUSTOM_EXT_TYPE_3)
546 custom_ext_error = 1;
547 *out = (const unsigned char*)custom_ext_cli_string;
548 *outlen = strlen(custom_ext_cli_string);
549 return 1; /* Send "abc" */
552 static int custom_ext_3_cli_parse_cb(SSL *s, unsigned int ext_type,
553 const unsigned char *in,
554 size_t inlen, int *al,
557 if (ext_type != CUSTOM_EXT_TYPE_3)
558 custom_ext_error = 1;
559 if (inlen != strlen(custom_ext_srv_string))
560 custom_ext_error = 1;
561 if (memcmp(custom_ext_srv_string, in, inlen) != 0)
562 custom_ext_error = 1; /* Check for "defg" */
566 /* custom_ext_0_cli_add_cb returns 0 - the server won't receive a callback for this extension */
567 static int custom_ext_0_srv_parse_cb(SSL *s, unsigned int ext_type,
568 const unsigned char *in,
569 size_t inlen, int *al,
572 custom_ext_error = 1;
576 /* 'add' callbacks are only called if the 'parse' callback is called */
577 static int custom_ext_0_srv_add_cb(SSL *s, unsigned int ext_type,
578 const unsigned char **out,
579 size_t *outlen, int *al, void *arg)
581 /* Error: should not have been called */
582 custom_ext_error = 1;
583 return 0; /* Don't send an extension */
586 static int custom_ext_1_srv_parse_cb(SSL *s, unsigned int ext_type,
587 const unsigned char *in,
588 size_t inlen, int *al,
591 if (ext_type != CUSTOM_EXT_TYPE_1)
592 custom_ext_error = 1;
593 /* Check for "abc" */
594 if (inlen != strlen(custom_ext_cli_string))
595 custom_ext_error = 1;
596 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
597 custom_ext_error = 1;
601 static int custom_ext_1_srv_add_cb(SSL *s, unsigned int ext_type,
602 const unsigned char **out,
603 size_t *outlen, int *al, void *arg)
605 return 0; /* Don't send an extension */
608 static int custom_ext_2_srv_parse_cb(SSL *s, unsigned int ext_type,
609 const unsigned char *in,
610 size_t inlen, int *al,
613 if (ext_type != CUSTOM_EXT_TYPE_2)
614 custom_ext_error = 1;
615 /* Check for "abc" */
616 if (inlen != strlen(custom_ext_cli_string))
617 custom_ext_error = 1;
618 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
619 custom_ext_error = 1;
623 static int custom_ext_2_srv_add_cb(SSL *s, unsigned int ext_type,
624 const unsigned char **out,
625 size_t *outlen, int *al, void *arg)
629 return 1; /* Send empty extension */
632 static int custom_ext_3_srv_parse_cb(SSL *s, unsigned int ext_type,
633 const unsigned char *in,
634 size_t inlen, int *al,
637 if (ext_type != CUSTOM_EXT_TYPE_3)
638 custom_ext_error = 1;
639 /* Check for "abc" */
640 if (inlen != strlen(custom_ext_cli_string))
641 custom_ext_error = 1;
642 if (memcmp(in, custom_ext_cli_string, inlen) != 0)
643 custom_ext_error = 1;
647 static int custom_ext_3_srv_add_cb(SSL *s, unsigned int ext_type,
648 const unsigned char **out,
649 size_t *outlen, int *al, void *arg)
651 *out = (const unsigned char*)custom_ext_srv_string;
652 *outlen = strlen(custom_ext_srv_string);
653 return 1; /* Send "defg" */
656 static char *cipher=NULL;
657 static int verbose=0;
666 static const char rnd_seed[] = "string to make the random number generator think it has entropy";
668 int doit_biopair(SSL *s_ssl,SSL *c_ssl,long bytes,clock_t *s_time,clock_t *c_time);
669 int doit(SSL *s_ssl,SSL *c_ssl,long bytes);
670 static int do_test_cipherlist(void);
671 static void sv_usage(void)
673 fprintf(stderr,"usage: ssltest [args ...]\n");
674 fprintf(stderr,"\n");
676 fprintf(stderr,"-F - run test in FIPS mode\n");
678 fprintf(stderr," -server_auth - check server certificate\n");
679 fprintf(stderr," -client_auth - do client authentication\n");
680 fprintf(stderr," -proxy - allow proxy certificates\n");
681 fprintf(stderr," -proxy_auth <val> - set proxy policy rights\n");
682 fprintf(stderr," -proxy_cond <val> - expression to test proxy policy rights\n");
683 fprintf(stderr," -v - more output\n");
684 fprintf(stderr," -d - debug output\n");
685 fprintf(stderr," -reuse - use session-id reuse\n");
686 fprintf(stderr," -num <val> - number of connections to perform\n");
687 fprintf(stderr," -bytes <val> - number of bytes to swap between client/server\n");
688 #ifndef OPENSSL_NO_DH
689 fprintf(stderr," -dhe1024 - use 1024 bit key (safe prime) for DHE\n");
690 fprintf(stderr," -dhe1024dsa - use 1024 bit key (with 160-bit subprime) for DHE\n");
691 fprintf(stderr," -no_dhe - disable DHE\n");
693 #ifndef OPENSSL_NO_ECDH
694 fprintf(stderr," -no_ecdhe - disable ECDHE\n");
696 #ifndef OPENSSL_NO_PSK
697 fprintf(stderr," -psk arg - PSK in hex (without 0x)\n");
699 #ifndef OPENSSL_NO_SRP
700 fprintf(stderr," -srpuser user - SRP username to use\n");
701 fprintf(stderr," -srppass arg - password for 'user'\n");
703 #ifndef OPENSSL_NO_SSL2
704 fprintf(stderr," -ssl2 - use SSLv2\n");
706 #ifndef OPENSSL_NO_SSL3_METHOD
707 fprintf(stderr," -ssl3 - use SSLv3\n");
709 #ifndef OPENSSL_NO_TLS1
710 fprintf(stderr," -tls1 - use TLSv1\n");
712 fprintf(stderr," -CApath arg - PEM format directory of CA's\n");
713 fprintf(stderr," -CAfile arg - PEM format file of CA's\n");
714 fprintf(stderr," -cert arg - Server certificate file\n");
715 fprintf(stderr," -key arg - Server key file (default: same as -cert)\n");
716 fprintf(stderr," -c_cert arg - Client certificate file\n");
717 fprintf(stderr," -c_key arg - Client key file (default: same as -c_cert)\n");
718 fprintf(stderr," -cipher arg - The cipher list\n");
719 fprintf(stderr," -bio_pair - Use BIO pairs\n");
720 fprintf(stderr," -f - Test even cases that can't work\n");
721 fprintf(stderr," -time - measure processor time used by client and server\n");
722 fprintf(stderr," -zlib - use zlib compression\n");
723 fprintf(stderr," -rle - use rle compression\n");
724 #ifndef OPENSSL_NO_ECDH
725 fprintf(stderr," -named_curve arg - Elliptic curve name to use for ephemeral ECDH keys.\n" \
726 " Use \"openssl ecparam -list_curves\" for all names\n" \
727 " (default is sect163r2).\n");
729 fprintf(stderr," -test_cipherlist - Verifies the order of the ssl cipher lists.\n"
730 " When this option is requested, the cipherlist\n"
731 " tests are run instead of handshake tests.\n");
732 fprintf(stderr," -serverinfo_file file - have server use this file\n");
733 fprintf(stderr," -serverinfo_sct - have client offer and expect SCT\n");
734 fprintf(stderr," -serverinfo_tack - have client offer and expect TACK\n");
735 fprintf(stderr," -custom_ext - try various custom extension callbacks\n");
736 fprintf(stderr," -alpn_client <string> - have client side offer ALPN\n");
737 fprintf(stderr," -alpn_server <string> - have server side offer ALPN\n");
738 fprintf(stderr," -alpn_expected <string> - the ALPN protocol that should be negotiated\n");
741 static void print_details(SSL *c_ssl, const char *prefix)
743 const SSL_CIPHER *ciph;
746 ciph=SSL_get_current_cipher(c_ssl);
747 BIO_printf(bio_stdout,"%s%s, cipher %s %s",
749 SSL_get_version(c_ssl),
750 SSL_CIPHER_get_version(ciph),
751 SSL_CIPHER_get_name(ciph));
752 cert=SSL_get_peer_certificate(c_ssl);
755 EVP_PKEY *pkey = X509_get_pubkey(cert);
760 #ifndef OPENSSL_NO_RSA
761 else if (pkey->type == EVP_PKEY_RSA && pkey->pkey.rsa != NULL
762 && pkey->pkey.rsa->n != NULL)
764 BIO_printf(bio_stdout, ", %d bit RSA",
765 BN_num_bits(pkey->pkey.rsa->n));
768 #ifndef OPENSSL_NO_DSA
769 else if (pkey->type == EVP_PKEY_DSA && pkey->pkey.dsa != NULL
770 && pkey->pkey.dsa->p != NULL)
772 BIO_printf(bio_stdout, ", %d bit DSA",
773 BN_num_bits(pkey->pkey.dsa->p));
780 /* The SSL API does not allow us to look at temporary RSA/DH keys,
781 * otherwise we should print their lengths too */
782 BIO_printf(bio_stdout,"\n");
785 static void lock_dbg_cb(int mode, int type, const char *file, int line)
787 static int modes[CRYPTO_NUM_LOCKS]; /* = {0, 0, ... } */
788 const char *errstr = NULL;
791 rw = mode & (CRYPTO_READ|CRYPTO_WRITE);
792 if (!((rw == CRYPTO_READ) || (rw == CRYPTO_WRITE)))
794 errstr = "invalid mode";
798 if (type < 0 || type >= CRYPTO_NUM_LOCKS)
800 errstr = "type out of bounds";
804 if (mode & CRYPTO_LOCK)
808 errstr = "already locked";
809 /* must not happen in a single-threaded program
810 * (would deadlock) */
816 else if (mode & CRYPTO_UNLOCK)
820 errstr = "not locked";
824 if (modes[type] != rw)
826 errstr = (rw == CRYPTO_READ) ?
827 "CRYPTO_r_unlock on write lock" :
828 "CRYPTO_w_unlock on read lock";
835 errstr = "invalid mode";
842 /* we cannot use bio_err here */
843 fprintf(stderr, "openssl (lock_dbg_cb): %s (mode=%d, type=%d) at %s:%d\n",
844 errstr, mode, type, file, line);
848 #ifdef TLSEXT_TYPE_opaque_prf_input
849 struct cb_info_st { void *input; size_t len; int ret; };
850 struct cb_info_st co1 = { "C", 1, 1 }; /* try to negotiate oqaque PRF input */
851 struct cb_info_st co2 = { "C", 1, 2 }; /* insist on oqaque PRF input */
852 struct cb_info_st so1 = { "S", 1, 1 }; /* try to negotiate oqaque PRF input */
853 struct cb_info_st so2 = { "S", 1, 2 }; /* insist on oqaque PRF input */
855 int opaque_prf_input_cb(SSL *ssl, void *peerinput, size_t len, void *arg_)
857 struct cb_info_st *arg = arg_;
862 if (!SSL_set_tlsext_opaque_prf_input(ssl, arg->input, arg->len))
868 int main(int argc, char *argv[])
870 char *CApath=NULL,*CAfile=NULL;
874 int tls1=0,ssl2=0,ssl3=0,ret=1;
877 struct app_verify_arg app_verify_arg =
878 { APP_CALLBACK_STRING, 0, 0, NULL, NULL };
879 char *server_cert=TEST_SERVER_CERT;
880 char *server_key=NULL;
881 char *client_cert=TEST_CLIENT_CERT;
882 char *client_key=NULL;
883 #ifndef OPENSSL_NO_ECDH
884 char *named_curve = NULL;
888 const SSL_METHOD *meth=NULL;
890 int number=1,reuse=0;
892 #ifndef OPENSSL_NO_DH
894 int dhe1024 = 0, dhe1024dsa = 0;
896 #ifndef OPENSSL_NO_ECDH
899 #ifndef OPENSSL_NO_SRP
901 SRP_CLIENT_ARG srp_client_arg = {NULL,NULL};
903 SRP_SERVER_ARG srp_server_arg = {NULL,NULL};
909 clock_t s_time = 0, c_time = 0;
910 #ifndef OPENSSL_NO_COMP
912 COMP_METHOD *cm = NULL;
913 STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
915 int test_cipherlist = 0;
925 bio_err=BIO_new_fp(stderr,BIO_NOCLOSE|BIO_FP_TEXT);
927 CRYPTO_set_locking_callback(lock_dbg_cb);
929 /* enable memory leak checking unless explicitly disabled */
930 if (!((getenv("OPENSSL_DEBUG_MEMORY") != NULL) && (0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off"))))
932 CRYPTO_malloc_debug_init();
933 CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
937 /* OPENSSL_DEBUG_MEMORY=off */
938 CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);
940 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
942 RAND_seed(rnd_seed, sizeof rnd_seed);
944 bio_stdout=BIO_new_fp(stdout,BIO_NOCLOSE|BIO_FP_TEXT);
951 if(!strcmp(*argv,"-F"))
956 fprintf(stderr,"not compiled with FIPS support, so exiting without running.\n");
960 else if (strcmp(*argv,"-server_auth") == 0)
962 else if (strcmp(*argv,"-client_auth") == 0)
964 else if (strcmp(*argv,"-proxy_auth") == 0)
966 if (--argc < 1) goto bad;
967 app_verify_arg.proxy_auth= *(++argv);
969 else if (strcmp(*argv,"-proxy_cond") == 0)
971 if (--argc < 1) goto bad;
972 app_verify_arg.proxy_cond= *(++argv);
974 else if (strcmp(*argv,"-v") == 0)
976 else if (strcmp(*argv,"-d") == 0)
978 else if (strcmp(*argv,"-reuse") == 0)
980 else if (strcmp(*argv,"-dhe1024") == 0)
982 #ifndef OPENSSL_NO_DH
985 fprintf(stderr,"ignoring -dhe1024, since I'm compiled without DH\n");
988 else if (strcmp(*argv,"-dhe1024dsa") == 0)
990 #ifndef OPENSSL_NO_DH
993 fprintf(stderr,"ignoring -dhe1024, since I'm compiled without DH\n");
996 else if (strcmp(*argv,"-no_dhe") == 0)
998 else if (strcmp(*argv,"-no_ecdhe") == 0)
1000 else if (strcmp(*argv,"-psk") == 0)
1002 if (--argc < 1) goto bad;
1004 #ifndef OPENSSL_NO_PSK
1005 if (strspn(psk_key, "abcdefABCDEF1234567890") != strlen(psk_key))
1007 BIO_printf(bio_err,"Not a hex number '%s'\n",*argv);
1014 #ifndef OPENSSL_NO_SRP
1015 else if (strcmp(*argv,"-srpuser") == 0)
1017 if (--argc < 1) goto bad;
1018 srp_server_arg.expected_user = srp_client_arg.srplogin= *(++argv);
1021 else if (strcmp(*argv,"-srppass") == 0)
1023 if (--argc < 1) goto bad;
1024 srp_server_arg.pass = srp_client_arg.srppassin= *(++argv);
1028 else if (strcmp(*argv,"-ssl2") == 0)
1030 #ifdef OPENSSL_NO_SSL2
1035 else if (strcmp(*argv,"-tls1") == 0)
1037 #ifdef OPENSSL_NO_TLS1
1042 else if (strcmp(*argv,"-ssl3") == 0)
1044 #ifdef OPENSSL_NO_SSL3_METHOD
1049 else if (strncmp(*argv,"-num",4) == 0)
1051 if (--argc < 1) goto bad;
1052 number= atoi(*(++argv));
1053 if (number == 0) number=1;
1055 else if (strcmp(*argv,"-bytes") == 0)
1057 if (--argc < 1) goto bad;
1058 bytes= atol(*(++argv));
1059 if (bytes == 0L) bytes=1L;
1061 if (argv[0][i-1] == 'k') bytes*=1024L;
1062 if (argv[0][i-1] == 'm') bytes*=1024L*1024L;
1064 else if (strcmp(*argv,"-cert") == 0)
1066 if (--argc < 1) goto bad;
1067 server_cert= *(++argv);
1069 else if (strcmp(*argv,"-s_cert") == 0)
1071 if (--argc < 1) goto bad;
1072 server_cert= *(++argv);
1074 else if (strcmp(*argv,"-key") == 0)
1076 if (--argc < 1) goto bad;
1077 server_key= *(++argv);
1079 else if (strcmp(*argv,"-s_key") == 0)
1081 if (--argc < 1) goto bad;
1082 server_key= *(++argv);
1084 else if (strcmp(*argv,"-c_cert") == 0)
1086 if (--argc < 1) goto bad;
1087 client_cert= *(++argv);
1089 else if (strcmp(*argv,"-c_key") == 0)
1091 if (--argc < 1) goto bad;
1092 client_key= *(++argv);
1094 else if (strcmp(*argv,"-cipher") == 0)
1096 if (--argc < 1) goto bad;
1099 else if (strcmp(*argv,"-CApath") == 0)
1101 if (--argc < 1) goto bad;
1104 else if (strcmp(*argv,"-CAfile") == 0)
1106 if (--argc < 1) goto bad;
1109 else if (strcmp(*argv,"-bio_pair") == 0)
1113 else if (strcmp(*argv,"-f") == 0)
1117 else if (strcmp(*argv,"-time") == 0)
1121 #ifndef OPENSSL_NO_COMP
1122 else if (strcmp(*argv,"-zlib") == 0)
1126 else if (strcmp(*argv,"-rle") == 0)
1131 else if (strcmp(*argv,"-named_curve") == 0)
1133 if (--argc < 1) goto bad;
1134 #ifndef OPENSSL_NO_ECDH
1135 named_curve = *(++argv);
1137 fprintf(stderr,"ignoring -named_curve, since I'm compiled without ECDH\n");
1141 else if (strcmp(*argv,"-app_verify") == 0)
1143 app_verify_arg.app_verify = 1;
1145 else if (strcmp(*argv,"-proxy") == 0)
1147 app_verify_arg.allow_proxy_certs = 1;
1149 else if (strcmp(*argv,"-test_cipherlist") == 0)
1151 test_cipherlist = 1;
1153 else if (strcmp(*argv,"-serverinfo_sct") == 0)
1157 else if (strcmp(*argv,"-serverinfo_tack") == 0)
1159 serverinfo_tack = 1;
1161 else if (strcmp(*argv,"-serverinfo_file") == 0)
1163 if (--argc < 1) goto bad;
1164 serverinfo_file = *(++argv);
1166 else if (strcmp(*argv,"-custom_ext") == 0)
1170 else if (strcmp(*argv,"-alpn_client") == 0)
1172 if (--argc < 1) goto bad;
1173 alpn_client = *(++argv);
1175 else if (strcmp(*argv,"-alpn_server") == 0)
1177 if (--argc < 1) goto bad;
1178 alpn_server = *(++argv);
1180 else if (strcmp(*argv,"-alpn_expected") == 0)
1182 if (--argc < 1) goto bad;
1183 alpn_expected = *(++argv);
1187 fprintf(stderr,"unknown option %s\n",*argv);
1202 * test_cipherlist prevails over protocol switch: we test the cipherlist
1203 * for all enabled protocols.
1205 if (test_cipherlist == 1)
1207 /* ensure that the cipher list are correctly sorted and exit */
1208 fprintf(stdout, "Testing cipherlist order only. Ignoring all "
1209 "other options.\n");
1210 if (do_test_cipherlist() == 0)
1216 if (ssl2 + ssl3 + tls1 > 1)
1218 fprintf(stderr, "At most one of -ssl2, -ssl3, or -tls1 should "
1224 * Testing was requested for a compiled-out protocol (e.g. SSLv2).
1225 * Ideally, we would error out, but the generic test wrapper can't know
1226 * when to expect failure. So we do nothing and return success.
1230 fprintf(stderr, "Testing was requested for a disabled protocol. "
1231 "Skipping tests.\n");
1236 if (!ssl2 && !ssl3 && !tls1 && number > 1 && !reuse && !force)
1238 fprintf(stderr, "This case cannot work. Use -f to perform "
1239 "the test anyway (and\n-d to see what happens), "
1240 "or add one of -ssl2, -ssl3, -tls1, -reuse\n"
1241 "to avoid protocol mismatch.\n");
1248 if(!FIPS_mode_set(1))
1250 ERR_load_crypto_strings();
1251 ERR_print_errors(BIO_new_fp(stderr,BIO_NOCLOSE));
1255 fprintf(stderr,"*** IN FIPS MODE ***\n");
1263 fprintf(stderr, "Using BIO pair (-bio_pair)\n");
1266 if (number < 50 && !force)
1267 fprintf(stderr, "Warning: For accurate timings, use more connections (e.g. -num 1000)\n");
1270 /* if (cipher == NULL) cipher=getenv("SSL_CIPHER"); */
1273 SSL_load_error_strings();
1275 #ifndef OPENSSL_NO_COMP
1276 if (comp == COMP_ZLIB) cm = COMP_zlib();
1277 if (comp == COMP_RLE) cm = COMP_rle();
1280 if (cm->type != NID_undef)
1282 if (SSL_COMP_add_compression_method(comp, cm) != 0)
1285 "Failed to add compression method\n");
1286 ERR_print_errors_fp(stderr);
1292 "Warning: %s compression not supported\n",
1293 (comp == COMP_RLE ? "rle" :
1294 (comp == COMP_ZLIB ? "zlib" :
1296 ERR_print_errors_fp(stderr);
1299 ssl_comp_methods = SSL_COMP_get_compression_methods();
1300 fprintf(stderr, "Available compression methods:\n");
1302 int j, n = sk_SSL_COMP_num(ssl_comp_methods);
1304 fprintf(stderr, " NONE\n");
1306 for (j = 0; j < n; j++)
1308 SSL_COMP *c = sk_SSL_COMP_value(ssl_comp_methods, j);
1309 fprintf(stderr, " %d: %s\n", c->id, c->name);
1314 /* At this point, ssl2/ssl3/tls1 is only set if the protocol is available.
1315 * (Otherwise we exit early.)
1316 * However the compiler doesn't know this, so we ifdef. */
1317 #ifndef OPENSSL_NO_SSL2
1319 meth=SSLv2_method();
1322 #ifndef OPENSSL_NO_SSL3
1324 meth=SSLv3_method();
1327 #ifndef OPENSSL_NO_TLS1
1329 meth=TLSv1_method();
1332 meth=SSLv23_method();
1334 c_ctx=SSL_CTX_new(meth);
1335 s_ctx=SSL_CTX_new(meth);
1336 if ((c_ctx == NULL) || (s_ctx == NULL))
1338 ERR_print_errors(bio_err);
1344 SSL_CTX_set_cipher_list(c_ctx,cipher);
1345 SSL_CTX_set_cipher_list(s_ctx,cipher);
1348 #ifndef OPENSSL_NO_DH
1353 /* use SSL_OP_SINGLE_DH_USE to avoid small subgroup attacks */
1354 SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_DH_USE);
1361 SSL_CTX_set_tmp_dh(s_ctx,dh);
1368 #ifndef OPENSSL_NO_ECDH
1373 if (named_curve != NULL)
1375 nid = OBJ_sn2nid(named_curve);
1378 BIO_printf(bio_err, "unknown curve name (%s)\n", named_curve);
1383 #ifdef OPENSSL_NO_EC2M
1384 nid = NID_X9_62_prime256v1;
1386 nid = NID_sect163r2;
1389 ecdh = EC_KEY_new_by_curve_name(nid);
1392 BIO_printf(bio_err, "unable to create curve\n");
1396 SSL_CTX_set_tmp_ecdh(s_ctx, ecdh);
1397 SSL_CTX_set_options(s_ctx, SSL_OP_SINGLE_ECDH_USE);
1404 #ifndef OPENSSL_NO_RSA
1405 SSL_CTX_set_tmp_rsa_callback(s_ctx,tmp_rsa_cb);
1408 #ifdef TLSEXT_TYPE_opaque_prf_input
1409 SSL_CTX_set_tlsext_opaque_prf_input_callback(c_ctx, opaque_prf_input_cb);
1410 SSL_CTX_set_tlsext_opaque_prf_input_callback(s_ctx, opaque_prf_input_cb);
1411 SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(c_ctx, &co1); /* or &co2 or NULL */
1412 SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(s_ctx, &so1); /* or &so2 or NULL */
1415 if (!SSL_CTX_use_certificate_file(s_ctx,server_cert,SSL_FILETYPE_PEM))
1417 ERR_print_errors(bio_err);
1419 else if (!SSL_CTX_use_PrivateKey_file(s_ctx,
1420 (server_key?server_key:server_cert), SSL_FILETYPE_PEM))
1422 ERR_print_errors(bio_err);
1428 SSL_CTX_use_certificate_file(c_ctx,client_cert,
1430 SSL_CTX_use_PrivateKey_file(c_ctx,
1431 (client_key?client_key:client_cert),
1435 if ( (!SSL_CTX_load_verify_locations(s_ctx,CAfile,CApath)) ||
1436 (!SSL_CTX_set_default_verify_paths(s_ctx)) ||
1437 (!SSL_CTX_load_verify_locations(c_ctx,CAfile,CApath)) ||
1438 (!SSL_CTX_set_default_verify_paths(c_ctx)))
1440 /* fprintf(stderr,"SSL_load_verify_locations\n"); */
1441 ERR_print_errors(bio_err);
1447 BIO_printf(bio_err,"client authentication\n");
1448 SSL_CTX_set_verify(s_ctx,
1449 SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
1451 SSL_CTX_set_cert_verify_callback(s_ctx, app_verify_callback, &app_verify_arg);
1455 BIO_printf(bio_err,"server authentication\n");
1456 SSL_CTX_set_verify(c_ctx,SSL_VERIFY_PEER,
1458 SSL_CTX_set_cert_verify_callback(c_ctx, app_verify_callback, &app_verify_arg);
1462 int session_id_context = 0;
1463 SSL_CTX_set_session_id_context(s_ctx, (void *)&session_id_context, sizeof session_id_context);
1466 /* Use PSK only if PSK key is given */
1467 if (psk_key != NULL)
1469 /* no_psk is used to avoid putting psk command to openssl tool */
1472 /* if PSK is not compiled in and psk key is
1473 * given, do nothing and exit successfully */
1477 #ifndef OPENSSL_NO_PSK
1478 SSL_CTX_set_psk_client_callback(c_ctx, psk_client_callback);
1479 SSL_CTX_set_psk_server_callback(s_ctx, psk_server_callback);
1481 BIO_printf(bio_err,"setting PSK identity hint to s_ctx\n");
1482 if (!SSL_CTX_use_psk_identity_hint(s_ctx, "ctx server identity_hint"))
1484 BIO_printf(bio_err,"error setting PSK identity hint to s_ctx\n");
1485 ERR_print_errors(bio_err);
1490 #ifndef OPENSSL_NO_SRP
1491 if (srp_client_arg.srplogin)
1493 if (!SSL_CTX_set_srp_username(c_ctx, srp_client_arg.srplogin))
1495 BIO_printf(bio_err,"Unable to set SRP username\n");
1498 SSL_CTX_set_srp_cb_arg(c_ctx,&srp_client_arg);
1499 SSL_CTX_set_srp_client_pwd_callback(c_ctx, ssl_give_srp_client_pwd_cb);
1500 /*SSL_CTX_set_srp_strength(c_ctx, srp_client_arg.strength);*/
1503 if (srp_server_arg.expected_user != NULL)
1505 SSL_CTX_set_verify(s_ctx,SSL_VERIFY_NONE,verify_callback);
1506 SSL_CTX_set_srp_cb_arg(s_ctx, &srp_server_arg);
1507 SSL_CTX_set_srp_username_callback(s_ctx, ssl_srp_server_param_cb);
1512 SSL_CTX_add_client_custom_ext(c_ctx, SCT_EXT_TYPE,
1514 serverinfo_cli_parse_cb, NULL);
1515 if (serverinfo_tack)
1516 SSL_CTX_add_client_custom_ext(c_ctx, TACK_EXT_TYPE,
1518 serverinfo_cli_parse_cb, NULL);
1520 if (serverinfo_file)
1521 if (!SSL_CTX_use_serverinfo_file(s_ctx, serverinfo_file))
1523 BIO_printf(bio_err, "missing serverinfo file\n");
1529 SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_0,
1530 custom_ext_0_cli_add_cb,
1532 custom_ext_0_cli_parse_cb, NULL);
1533 SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_1,
1534 custom_ext_1_cli_add_cb,
1536 custom_ext_1_cli_parse_cb, NULL);
1537 SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_2,
1538 custom_ext_2_cli_add_cb,
1540 custom_ext_2_cli_parse_cb, NULL);
1541 SSL_CTX_add_client_custom_ext(c_ctx, CUSTOM_EXT_TYPE_3,
1542 custom_ext_3_cli_add_cb,
1544 custom_ext_3_cli_parse_cb, NULL);
1547 SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_0,
1548 custom_ext_0_srv_add_cb,
1550 custom_ext_0_srv_parse_cb, NULL);
1551 SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_1,
1552 custom_ext_1_srv_add_cb,
1554 custom_ext_1_srv_parse_cb, NULL);
1555 SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_2,
1556 custom_ext_2_srv_add_cb,
1558 custom_ext_2_srv_parse_cb, NULL);
1559 SSL_CTX_add_server_custom_ext(s_ctx, CUSTOM_EXT_TYPE_3,
1560 custom_ext_3_srv_add_cb,
1562 custom_ext_3_srv_parse_cb, NULL);
1566 SSL_CTX_set_alpn_select_cb(s_ctx, cb_server_alpn, NULL);
1570 unsigned short alpn_len;
1571 unsigned char *alpn = next_protos_parse(&alpn_len, alpn_client);
1575 BIO_printf(bio_err, "Error parsing -alpn_client argument\n");
1578 SSL_CTX_set_alpn_protos(c_ctx, alpn, alpn_len);
1582 c_ssl=SSL_new(c_ctx);
1583 s_ssl=SSL_new(s_ctx);
1585 #ifndef OPENSSL_NO_KRB5
1586 if (c_ssl && c_ssl->kssl_ctx)
1588 char localhost[MAXHOSTNAMELEN+2];
1590 if (gethostname(localhost, sizeof localhost-1) == 0)
1592 localhost[sizeof localhost-1]='\0';
1593 if(strlen(localhost) == sizeof localhost-1)
1595 BIO_printf(bio_err,"localhost name too long\n");
1598 kssl_ctx_setstring(c_ssl->kssl_ctx, KSSL_SERVER,
1602 #endif /* OPENSSL_NO_KRB5 */
1604 for (i=0; i<number; i++)
1606 if (!reuse) SSL_set_session(c_ssl,NULL);
1608 ret=doit_biopair(s_ssl,c_ssl,bytes,&s_time,&c_time);
1610 ret=doit(s_ssl,c_ssl,bytes);
1615 print_details(c_ssl, "");
1617 if ((number > 1) || (bytes > 1L))
1618 BIO_printf(bio_stdout, "%d handshakes of %ld bytes done\n",number,bytes);
1621 #ifdef CLOCKS_PER_SEC
1622 /* "To determine the time in seconds, the value returned
1623 * by the clock function should be divided by the value
1624 * of the macro CLOCKS_PER_SEC."
1625 * -- ISO/IEC 9899 */
1626 BIO_printf(bio_stdout, "Approximate total server time: %6.2f s\n"
1627 "Approximate total client time: %6.2f s\n",
1628 (double)s_time/CLOCKS_PER_SEC,
1629 (double)c_time/CLOCKS_PER_SEC);
1631 /* "`CLOCKS_PER_SEC' undeclared (first use this function)"
1632 * -- cc on NeXTstep/OpenStep */
1633 BIO_printf(bio_stdout,
1634 "Approximate total server time: %6.2f units\n"
1635 "Approximate total client time: %6.2f units\n",
1645 if (s_ctx != NULL) SSL_CTX_free(s_ctx);
1646 if (c_ctx != NULL) SSL_CTX_free(c_ctx);
1648 if (bio_stdout != NULL) BIO_free(bio_stdout);
1650 #ifndef OPENSSL_NO_RSA
1653 #ifndef OPENSSL_NO_ENGINE
1656 CRYPTO_cleanup_all_ex_data();
1658 ERR_remove_thread_state(NULL);
1660 CRYPTO_mem_leaks(bio_err);
1661 if (bio_err != NULL) BIO_free(bio_err);
1666 int doit_biopair(SSL *s_ssl, SSL *c_ssl, long count,
1667 clock_t *s_time, clock_t *c_time)
1669 long cw_num = count, cr_num = count, sw_num = count, sr_num = count;
1670 BIO *s_ssl_bio = NULL, *c_ssl_bio = NULL;
1671 BIO *server = NULL, *server_io = NULL, *client = NULL, *client_io = NULL;
1674 size_t bufsiz = 256; /* small buffer for testing */
1676 if (!BIO_new_bio_pair(&server, bufsiz, &server_io, bufsiz))
1678 if (!BIO_new_bio_pair(&client, bufsiz, &client_io, bufsiz))
1681 s_ssl_bio = BIO_new(BIO_f_ssl());
1685 c_ssl_bio = BIO_new(BIO_f_ssl());
1689 SSL_set_connect_state(c_ssl);
1690 SSL_set_bio(c_ssl, client, client);
1691 (void)BIO_set_ssl(c_ssl_bio, c_ssl, BIO_NOCLOSE);
1693 SSL_set_accept_state(s_ssl);
1694 SSL_set_bio(s_ssl, server, server);
1695 (void)BIO_set_ssl(s_ssl_bio, s_ssl, BIO_NOCLOSE);
1700 * c_ssl_bio: SSL filter BIO
1702 * client: pseudo-I/O for SSL library
1704 * client_io: client's SSL communication; usually to be
1705 * relayed over some I/O facility, but in this
1706 * test program, we're the server, too:
1708 * server_io: server's SSL communication
1710 * server: pseudo-I/O for SSL library
1712 * s_ssl_bio: SSL filter BIO
1714 * The client and the server each employ a "BIO pair":
1715 * client + client_io, server + server_io.
1716 * BIO pairs are symmetric. A BIO pair behaves similar
1717 * to a non-blocking socketpair (but both endpoints must
1718 * be handled by the same thread).
1719 * [Here we could connect client and server to the ends
1720 * of a single BIO pair, but then this code would be less
1721 * suitable as an example for BIO pairs in general.]
1723 * Useful functions for querying the state of BIO pair endpoints:
1725 * BIO_ctrl_pending(bio) number of bytes we can read now
1726 * BIO_ctrl_get_read_request(bio) number of bytes needed to fulfil
1727 * other side's read attempt
1728 * BIO_ctrl_get_write_guarantee(bio) number of bytes we can write now
1730 * ..._read_request is never more than ..._write_guarantee;
1731 * it depends on the application which one you should use.
1734 /* We have non-blocking behaviour throughout this test program, but
1735 * can be sure that there is *some* progress in each iteration; so
1736 * we don't have to worry about ..._SHOULD_READ or ..._SHOULD_WRITE
1737 * -- we just try everything in each iteration
1743 MS_STATIC char cbuf[1024*8];
1745 clock_t c_clock = clock();
1747 memset(cbuf, 0, sizeof(cbuf));
1750 if (SSL_in_init(c_ssl))
1751 printf("client waiting in SSL_connect - %s\n",
1752 SSL_state_string_long(c_ssl));
1756 /* Write to server. */
1758 if (cw_num > (long)sizeof cbuf)
1762 r = BIO_write(c_ssl_bio, cbuf, i);
1765 if (!BIO_should_retry(c_ssl_bio))
1767 fprintf(stderr,"ERROR in CLIENT\n");
1770 /* BIO_should_retry(...) can just be ignored here.
1771 * The library expects us to call BIO_write with
1772 * the same arguments again, and that's what we will
1773 * do in the next iteration. */
1777 fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1783 printf("client wrote %d\n", r);
1790 /* Read from server. */
1792 r = BIO_read(c_ssl_bio, cbuf, sizeof(cbuf));
1795 if (!BIO_should_retry(c_ssl_bio))
1797 fprintf(stderr,"ERROR in CLIENT\n");
1800 /* Again, "BIO_should_retry" can be ignored. */
1804 fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
1810 printf("client read %d\n", r);
1815 /* c_time and s_time increments will typically be very small
1816 * (depending on machine speed and clock tick intervals),
1817 * but sampling over a large number of connections should
1818 * result in fairly accurate figures. We cannot guarantee
1819 * a lot, however -- if each connection lasts for exactly
1820 * one clock tick, it will be counted only for the client
1821 * or only for the server or even not at all.
1823 *c_time += (clock() - c_clock);
1829 MS_STATIC char sbuf[1024*8];
1831 clock_t s_clock = clock();
1833 memset(sbuf, 0, sizeof(sbuf));
1836 if (SSL_in_init(s_ssl))
1837 printf("server waiting in SSL_accept - %s\n",
1838 SSL_state_string_long(s_ssl));
1842 /* Write to client. */
1844 if (sw_num > (long)sizeof sbuf)
1848 r = BIO_write(s_ssl_bio, sbuf, i);
1851 if (!BIO_should_retry(s_ssl_bio))
1853 fprintf(stderr,"ERROR in SERVER\n");
1856 /* Ignore "BIO_should_retry". */
1860 fprintf(stderr,"SSL SERVER STARTUP FAILED\n");
1866 printf("server wrote %d\n", r);
1873 /* Read from client. */
1875 r = BIO_read(s_ssl_bio, sbuf, sizeof(sbuf));
1878 if (!BIO_should_retry(s_ssl_bio))
1880 fprintf(stderr,"ERROR in SERVER\n");
1887 fprintf(stderr,"SSL SERVER STARTUP FAILED\n");
1893 printf("server read %d\n", r);
1898 *s_time += (clock() - s_clock);
1902 /* "I/O" BETWEEN CLIENT AND SERVER. */
1905 BIO *io1 = server_io, *io2 = client_io;
1906 /* we use the non-copying interface for io1
1907 * and the standard BIO_write/BIO_read interface for io2
1910 static int prev_progress = 1;
1919 r1 = BIO_ctrl_pending(io1);
1920 r2 = BIO_ctrl_get_write_guarantee(io2);
1929 if (INT_MAX < num) /* yeah, right */
1932 r = BIO_nread(io1, &dataptr, (int)num);
1934 assert(r <= (int)num);
1935 /* possibly r < num (non-contiguous data) */
1937 r = BIO_write(io2, dataptr, (int)num);
1938 if (r != (int)num) /* can't happen */
1940 fprintf(stderr, "ERROR: BIO_write could not write "
1941 "BIO_ctrl_get_write_guarantee() bytes");
1947 printf((io1 == client_io) ?
1948 "C->S relaying: %d bytes\n" :
1949 "S->C relaying: %d bytes\n",
1960 r1 = BIO_ctrl_pending(io2);
1961 r2 = BIO_ctrl_get_read_request(io1);
1962 /* here we could use ..._get_write_guarantee instead of
1963 * ..._get_read_request, but by using the latter
1964 * we test restartability of the SSL implementation
1965 * more thoroughly */
1977 --num; /* test restartability even more thoroughly */
1979 r = BIO_nwrite0(io1, &dataptr);
1983 r = BIO_read(io2, dataptr, (int)num);
1984 if (r != (int)num) /* can't happen */
1986 fprintf(stderr, "ERROR: BIO_read could not read "
1987 "BIO_ctrl_pending() bytes");
1991 r = BIO_nwrite(io1, &dataptr, (int)num);
1992 if (r != (int)num) /* can't happen */
1994 fprintf(stderr, "ERROR: BIO_nwrite() did not accept "
1995 "BIO_nwrite0() bytes");
2000 printf((io2 == client_io) ?
2001 "C->S relaying: %d bytes\n" :
2002 "S->C relaying: %d bytes\n",
2005 } /* no loop, BIO_ctrl_get_read_request now returns 0 anyway */
2007 if (!progress && !prev_progress)
2008 if (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0)
2010 fprintf(stderr, "ERROR: got stuck\n");
2011 if (strcmp("SSLv2", SSL_get_version(c_ssl)) == 0)
2013 fprintf(stderr, "This can happen for SSL2 because "
2014 "CLIENT-FINISHED and SERVER-VERIFY are written \n"
2015 "concurrently ...");
2016 if (strncmp("2SCF", SSL_state_string(c_ssl), 4) == 0
2017 && strncmp("2SSV", SSL_state_string(s_ssl), 4) == 0)
2019 fprintf(stderr, " ok.\n");
2023 fprintf(stderr, " ERROR.\n");
2026 prev_progress = progress;
2029 while (cw_num > 0 || cr_num > 0 || sw_num > 0 || sr_num > 0);
2032 print_details(c_ssl, "DONE via BIO pair: ");
2034 if (verify_serverinfo() < 0)
2039 if (verify_alpn(c_ssl, s_ssl) < 0)
2045 if (custom_ext_error)
2055 ERR_print_errors(bio_err);
2060 BIO_free(server_io);
2064 BIO_free(client_io);
2066 BIO_free(s_ssl_bio);
2068 BIO_free(c_ssl_bio);
2079 int doit(SSL *s_ssl, SSL *c_ssl, long count)
2081 char *cbuf=NULL,*sbuf=NULL;
2083 long cw_num=count,cr_num=count;
2084 long sw_num=count,sr_num=count;
2090 int c_r,c_w,s_r,s_w;
2093 int c_write,s_write;
2094 int do_server=0,do_client=0;
2095 int max_frag = 5*1024;
2097 bufsiz = count>40*1024 ? 40*1024 : count;
2099 if ((cbuf = OPENSSL_malloc(bufsiz))==NULL) goto err;
2100 if ((sbuf = OPENSSL_malloc(bufsiz))==NULL) goto err;
2102 memset(cbuf,0,bufsiz);
2103 memset(sbuf,0,bufsiz);
2105 c_to_s=BIO_new(BIO_s_mem());
2106 s_to_c=BIO_new(BIO_s_mem());
2107 if ((s_to_c == NULL) || (c_to_s == NULL))
2109 ERR_print_errors(bio_err);
2113 c_bio=BIO_new(BIO_f_ssl());
2114 s_bio=BIO_new(BIO_f_ssl());
2115 if ((c_bio == NULL) || (s_bio == NULL))
2117 ERR_print_errors(bio_err);
2121 SSL_set_connect_state(c_ssl);
2122 SSL_set_bio(c_ssl,s_to_c,c_to_s);
2123 SSL_set_max_send_fragment(c_ssl,max_frag);
2124 BIO_set_ssl(c_bio,c_ssl,BIO_NOCLOSE);
2126 SSL_set_accept_state(s_ssl);
2127 SSL_set_bio(s_ssl,c_to_s,s_to_c);
2128 SSL_set_max_send_fragment(s_ssl,max_frag);
2129 BIO_set_ssl(s_bio,s_ssl,BIO_NOCLOSE);
2133 c_write=1,s_write=0;
2135 /* We can always do writes */
2141 i=(int)BIO_pending(s_bio);
2142 if ((i && s_r) || s_w) do_server=1;
2144 i=(int)BIO_pending(c_bio);
2145 if ((i && c_r) || c_w) do_client=1;
2147 if (do_server && debug)
2149 if (SSL_in_init(s_ssl))
2150 printf("server waiting in SSL_accept - %s\n",
2151 SSL_state_string_long(s_ssl));
2154 printf("server:SSL_write()\n");
2156 printf("server:SSL_read()\n"); */
2159 if (do_client && debug)
2161 if (SSL_in_init(c_ssl))
2162 printf("client waiting in SSL_connect - %s\n",
2163 SSL_state_string_long(c_ssl));
2166 printf("client:SSL_write()\n");
2168 printf("client:SSL_read()\n"); */
2171 if (!do_client && !do_server)
2173 fprintf(stdout,"ERROR IN STARTUP\n");
2174 ERR_print_errors(bio_err);
2177 if (do_client && !(done & C_DONE))
2181 j = (cw_num > bufsiz) ?
2182 (int)bufsiz : (int)cw_num;
2183 i=BIO_write(c_bio,cbuf,j);
2188 if (BIO_should_retry(c_bio))
2190 if (BIO_should_read(c_bio))
2192 if (BIO_should_write(c_bio))
2197 fprintf(stderr,"ERROR in CLIENT\n");
2198 ERR_print_errors(bio_err);
2204 fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
2210 printf("client wrote %d\n",i);
2216 SSL_set_max_send_fragment(c_ssl,max_frag-=5);
2221 i=BIO_read(c_bio,cbuf,bufsiz);
2226 if (BIO_should_retry(c_bio))
2228 if (BIO_should_read(c_bio))
2230 if (BIO_should_write(c_bio))
2235 fprintf(stderr,"ERROR in CLIENT\n");
2236 ERR_print_errors(bio_err);
2242 fprintf(stderr,"SSL CLIENT STARTUP FAILED\n");
2248 printf("client read %d\n",i);
2265 if (do_server && !(done & S_DONE))
2269 i=BIO_read(s_bio,sbuf,bufsiz);
2274 if (BIO_should_retry(s_bio))
2276 if (BIO_should_read(s_bio))
2278 if (BIO_should_write(s_bio))
2283 fprintf(stderr,"ERROR in SERVER\n");
2284 ERR_print_errors(bio_err);
2290 ERR_print_errors(bio_err);
2291 fprintf(stderr,"SSL SERVER STARTUP FAILED in SSL_read\n");
2297 printf("server read %d\n",i);
2314 j = (sw_num > bufsiz) ?
2315 (int)bufsiz : (int)sw_num;
2316 i=BIO_write(s_bio,sbuf,j);
2321 if (BIO_should_retry(s_bio))
2323 if (BIO_should_read(s_bio))
2325 if (BIO_should_write(s_bio))
2330 fprintf(stderr,"ERROR in SERVER\n");
2331 ERR_print_errors(bio_err);
2337 ERR_print_errors(bio_err);
2338 fprintf(stderr,"SSL SERVER STARTUP FAILED in SSL_write\n");
2344 printf("server wrote %d\n",i);
2351 SSL_set_max_send_fragment(s_ssl,max_frag-=5);
2356 if ((done & S_DONE) && (done & C_DONE)) break;
2360 print_details(c_ssl, "DONE: ");
2361 if (verify_serverinfo() < 0)
2366 if (custom_ext_error)
2373 /* We have to set the BIO's to NULL otherwise they will be
2374 * OPENSSL_free()ed twice. Once when th s_ssl is SSL_free()ed and
2375 * again when c_ssl is SSL_free()ed.
2376 * This is a hack required because s_ssl and c_ssl are sharing the same
2377 * BIO structure and SSL_set_bio() and SSL_free() automatically
2378 * BIO_free non NULL entries.
2379 * You should not normally do this or be required to do this */
2391 if (c_to_s != NULL) BIO_free(c_to_s);
2392 if (s_to_c != NULL) BIO_free(s_to_c);
2393 if (c_bio != NULL) BIO_free_all(c_bio);
2394 if (s_bio != NULL) BIO_free_all(s_bio);
2396 if (cbuf) OPENSSL_free(cbuf);
2397 if (sbuf) OPENSSL_free(sbuf);
2402 static int get_proxy_auth_ex_data_idx(void)
2404 static volatile int idx = -1;
2407 CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
2410 idx = X509_STORE_CTX_get_ex_new_index(0,
2411 "SSLtest for verify callback", NULL,NULL,NULL);
2413 CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
2418 static int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx)
2422 s=X509_NAME_oneline(X509_get_subject_name(ctx->current_cert),buf,
2427 fprintf(stderr,"depth=%d %s\n",
2428 ctx->error_depth,buf);
2431 fprintf(stderr,"depth=%d error=%d %s\n",
2432 ctx->error_depth,ctx->error,buf);
2438 fprintf(stderr,"Error string: %s\n",
2439 X509_verify_cert_error_string(ctx->error));
2442 case X509_V_ERR_CERT_NOT_YET_VALID:
2443 case X509_V_ERR_CERT_HAS_EXPIRED:
2444 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
2445 fprintf(stderr," ... ignored.\n");
2452 X509 *xs = ctx->current_cert;
2454 X509 *xi = ctx->current_issuer;
2457 if (xs->ex_flags & EXFLAG_PROXY)
2459 unsigned int *letters =
2460 X509_STORE_CTX_get_ex_data(ctx,
2461 get_proxy_auth_ex_data_idx());
2467 PROXY_CERT_INFO_EXTENSION *pci =
2468 X509_get_ext_d2i(xs, NID_proxyCertInfo,
2471 switch (OBJ_obj2nid(pci->proxyPolicy->policyLanguage))
2473 case NID_Independent:
2474 /* Completely meaningless in this
2475 program, as there's no way to
2476 grant explicit rights to a
2477 specific PrC. Basically, using
2478 id-ppl-Independent is the perfect
2479 way to grant no rights at all. */
2480 fprintf(stderr, " Independent proxy certificate");
2481 for (i = 0; i < 26; i++)
2484 case NID_id_ppl_inheritAll:
2485 /* This is basically a NOP, we
2486 simply let the current rights
2487 stand as they are. */
2488 fprintf(stderr, " Proxy certificate inherits all");
2492 pci->proxyPolicy->policy->data;
2493 i = pci->proxyPolicy->policy->length;
2495 /* The algorithm works as follows:
2496 it is assumed that previous
2497 iterations or the initial granted
2498 rights has already set some elements
2499 of `letters'. What we need to do is
2500 to clear those that weren't granted
2501 by the current PrC as well. The
2502 easiest way to do this is to add 1
2503 to all the elements whose letters
2504 are given with the current policy.
2505 That way, all elements that are set
2506 by the current policy and were
2507 already set by earlier policies and
2508 through the original grant of rights
2509 will get the value 2 or higher.
2510 The last thing to do is to sweep
2511 through `letters' and keep the
2512 elements having the value 2 as set,
2513 and clear all the others. */
2515 fprintf(stderr, " Certificate proxy rights = %*.*s", i, i, s);
2519 if (isascii(c) && isalpha(c))
2526 for (i = 0; i < 26; i++)
2535 ", resulting proxy rights = ");
2536 for(i = 0; i < 26; i++)
2539 fprintf(stderr, "%c", i + 'A');
2543 fprintf(stderr, "none");
2544 fprintf(stderr, "\n");
2546 PROXY_CERT_INFO_EXTENSION_free(pci);
2554 static void process_proxy_debug(int indent, const char *format, ...)
2556 static const char indentation[] =
2557 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
2558 ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"; /* That's 80 > */
2559 char my_format[256];
2562 BIO_snprintf(my_format, sizeof(my_format), "%*.*s %s",
2563 indent, indent, indentation, format);
2565 va_start(args, format);
2566 vfprintf(stderr, my_format, args);
2575 static int process_proxy_cond_adders(unsigned int letters[26],
2576 const char *cond, const char **cond_end, int *pos, int indent);
2577 static int process_proxy_cond_val(unsigned int letters[26],
2578 const char *cond, const char **cond_end, int *pos, int indent)
2584 while(isspace((int)*cond))
2591 process_proxy_debug(indent,
2592 "Start process_proxy_cond_val at position %d: %s\n",
2599 while(isspace((int)*cond))
2609 ok = process_proxy_cond_adders(letters, cond, cond_end, pos,
2614 while(isspace((int)*cond))
2622 "Weird condition character in position %d: "
2629 else if (isascii(c) && isalpha(c))
2633 ok = letters[c - 'A'];
2639 "Weird condition character in position %d: "
2646 if (ok >= 0 && negate)
2650 process_proxy_debug(indent,
2651 "End process_proxy_cond_val at position %d: %s, returning %d\n",
2656 static int process_proxy_cond_multipliers(unsigned int letters[26],
2657 const char *cond, const char **cond_end, int *pos, int indent)
2663 process_proxy_debug(indent,
2664 "Start process_proxy_cond_multipliers at position %d: %s\n",
2667 ok = process_proxy_cond_val(letters, cond, cond_end, pos, indent + 1);
2674 while(isspace((int)*cond))
2688 ok = process_proxy_cond_val(letters,
2689 cond, cond_end, pos, indent + 1);
2703 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2715 process_proxy_debug(indent,
2716 "End process_proxy_cond_multipliers at position %d: %s, returning %d\n",
2722 static int process_proxy_cond_adders(unsigned int letters[26],
2723 const char *cond, const char **cond_end, int *pos, int indent)
2729 process_proxy_debug(indent,
2730 "Start process_proxy_cond_adders at position %d: %s\n",
2733 ok = process_proxy_cond_multipliers(letters, cond, cond_end, pos,
2741 while(isspace((int)*cond))
2754 ok = process_proxy_cond_multipliers(letters,
2755 cond, cond_end, pos, indent + 1);
2766 fprintf(stderr, "SOMETHING IS SERIOUSLY WRONG!"
2778 process_proxy_debug(indent,
2779 "End process_proxy_cond_adders at position %d: %s, returning %d\n",
2786 static int process_proxy_cond(unsigned int letters[26],
2787 const char *cond, const char **cond_end)
2790 return process_proxy_cond_adders(letters, cond, cond_end, &pos, 1);
2793 static int MS_CALLBACK app_verify_callback(X509_STORE_CTX *ctx, void *arg)
2796 struct app_verify_arg *cb_arg = arg;
2797 unsigned int letters[26]; /* only used with proxy_auth */
2799 if (cb_arg->app_verify)
2801 char *s = NULL,buf[256];
2803 fprintf(stderr, "In app_verify_callback, allowing cert. ");
2804 fprintf(stderr, "Arg is: %s\n", cb_arg->string);
2805 fprintf(stderr, "Finished printing do we have a context? 0x%p a cert? 0x%p\n",
2806 (void *)ctx, (void *)ctx->cert);
2808 s=X509_NAME_oneline(X509_get_subject_name(ctx->cert),buf,256);
2811 fprintf(stderr,"cert depth=%d %s\n",ctx->error_depth,buf);
2815 if (cb_arg->proxy_auth)
2817 int found_any = 0, i;
2820 for(i = 0; i < 26; i++)
2822 for(sp = cb_arg->proxy_auth; *sp; sp++)
2825 if (isascii(c) && isalpha(c))
2829 letters[c - 'A'] = 1;
2834 " Initial proxy rights = ");
2835 for(i = 0; i < 26; i++)
2838 fprintf(stderr, "%c", i + 'A');
2842 fprintf(stderr, "none");
2843 fprintf(stderr, "\n");
2845 X509_STORE_CTX_set_ex_data(ctx,
2846 get_proxy_auth_ex_data_idx(),letters);
2848 if (cb_arg->allow_proxy_certs)
2850 X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_ALLOW_PROXY_CERTS);
2853 #ifndef OPENSSL_NO_X509_VERIFY
2854 ok = X509_verify_cert(ctx);
2857 if (cb_arg->proxy_auth)
2861 const char *cond_end = NULL;
2863 ok = process_proxy_cond(letters,
2864 cb_arg->proxy_cond, &cond_end);
2870 fprintf(stderr, "Stopped processing condition before it's end.\n");
2874 fprintf(stderr, "Proxy rights check with condition '%s' proved invalid\n",
2875 cb_arg->proxy_cond);
2877 fprintf(stderr, "Proxy rights check with condition '%s' proved valid\n",
2878 cb_arg->proxy_cond);
2884 #ifndef OPENSSL_NO_RSA
2885 static RSA *rsa_tmp=NULL;
2887 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
2890 if (rsa_tmp == NULL)
2893 rsa_tmp = RSA_new();
2894 if(!bn || !rsa_tmp || !BN_set_word(bn, RSA_F4))
2896 BIO_printf(bio_err, "Memory error...");
2899 BIO_printf(bio_err,"Generating temp (%d bit) RSA key...",keylength);
2900 (void)BIO_flush(bio_err);
2901 if(!RSA_generate_key_ex(rsa_tmp,keylength,bn,NULL))
2903 BIO_printf(bio_err, "Error generating key.");
2908 BIO_printf(bio_err,"\n");
2909 (void)BIO_flush(bio_err);
2915 static void free_tmp_rsa(void)
2917 if (rsa_tmp != NULL)
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,0xC6,
2937 0x1F,0x0D,0xAC,0xB6,0x25,0x3E,0x06,0x39,0xCA,0x72,0x04,0xB0,
2938 0x6E,0xDA,0xC0,0x61,0xE6,0x7A,0x77,0x25,0xE8,0x3B,0xB9,0x5F,
2939 0x9A,0xB6,0xB5,0xFE,0x99,0x0B,0xA1,0x93,0x4E,0x35,0x33,0xB8,
2940 0xE1,0xF1,0x13,0x4F,0x59,0x1A,0xD2,0x57,0xC0,0x26,0x21,0x33,
2941 0x02,0xC5,0xAE,0x23,
2943 static unsigned char dh512_g[]={
2948 if ((dh=DH_new()) == NULL) return(NULL);
2949 dh->p=BN_bin2bn(dh512_p,sizeof(dh512_p),NULL);
2950 dh->g=BN_bin2bn(dh512_g,sizeof(dh512_g),NULL);
2951 if ((dh->p == NULL) || (dh->g == NULL))
2952 { DH_free(dh); return(NULL); }
2956 static DH *get_dh1024()
2958 static unsigned char dh1024_p[]={
2959 0xF8,0x81,0x89,0x7D,0x14,0x24,0xC5,0xD1,0xE6,0xF7,0xBF,0x3A,
2960 0xE4,0x90,0xF4,0xFC,0x73,0xFB,0x34,0xB5,0xFA,0x4C,0x56,0xA2,
2961 0xEA,0xA7,0xE9,0xC0,0xC0,0xCE,0x89,0xE1,0xFA,0x63,0x3F,0xB0,
2962 0x6B,0x32,0x66,0xF1,0xD1,0x7B,0xB0,0x00,0x8F,0xCA,0x87,0xC2,
2963 0xAE,0x98,0x89,0x26,0x17,0xC2,0x05,0xD2,0xEC,0x08,0xD0,0x8C,
2964 0xFF,0x17,0x52,0x8C,0xC5,0x07,0x93,0x03,0xB1,0xF6,0x2F,0xB8,
2965 0x1C,0x52,0x47,0x27,0x1B,0xDB,0xD1,0x8D,0x9D,0x69,0x1D,0x52,
2966 0x4B,0x32,0x81,0xAA,0x7F,0x00,0xC8,0xDC,0xE6,0xD9,0xCC,0xC1,
2967 0x11,0x2D,0x37,0x34,0x6C,0xEA,0x02,0x97,0x4B,0x0E,0xBB,0xB1,
2968 0x71,0x33,0x09,0x15,0xFD,0xDD,0x23,0x87,0x07,0x5E,0x89,0xAB,
2969 0x6B,0x7C,0x5F,0xEC,0xA6,0x24,0xDC,0x53,
2971 static unsigned char dh1024_g[]={
2976 if ((dh=DH_new()) == NULL) return(NULL);
2977 dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
2978 dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
2979 if ((dh->p == NULL) || (dh->g == NULL))
2980 { DH_free(dh); return(NULL); }
2984 static DH *get_dh1024dsa()
2986 static unsigned char dh1024_p[]={
2987 0xC8,0x00,0xF7,0x08,0x07,0x89,0x4D,0x90,0x53,0xF3,0xD5,0x00,
2988 0x21,0x1B,0xF7,0x31,0xA6,0xA2,0xDA,0x23,0x9A,0xC7,0x87,0x19,
2989 0x3B,0x47,0xB6,0x8C,0x04,0x6F,0xFF,0xC6,0x9B,0xB8,0x65,0xD2,
2990 0xC2,0x5F,0x31,0x83,0x4A,0xA7,0x5F,0x2F,0x88,0x38,0xB6,0x55,
2991 0xCF,0xD9,0x87,0x6D,0x6F,0x9F,0xDA,0xAC,0xA6,0x48,0xAF,0xFC,
2992 0x33,0x84,0x37,0x5B,0x82,0x4A,0x31,0x5D,0xE7,0xBD,0x52,0x97,
2993 0xA1,0x77,0xBF,0x10,0x9E,0x37,0xEA,0x64,0xFA,0xCA,0x28,0x8D,
2994 0x9D,0x3B,0xD2,0x6E,0x09,0x5C,0x68,0xC7,0x45,0x90,0xFD,0xBB,
2995 0x70,0xC9,0x3A,0xBB,0xDF,0xD4,0x21,0x0F,0xC4,0x6A,0x3C,0xF6,
2996 0x61,0xCF,0x3F,0xD6,0x13,0xF1,0x5F,0xBC,0xCF,0xBC,0x26,0x9E,
2997 0xBC,0x0B,0xBD,0xAB,0x5D,0xC9,0x54,0x39,
2999 static unsigned char dh1024_g[]={
3000 0x3B,0x40,0x86,0xE7,0xF3,0x6C,0xDE,0x67,0x1C,0xCC,0x80,0x05,
3001 0x5A,0xDF,0xFE,0xBD,0x20,0x27,0x74,0x6C,0x24,0xC9,0x03,0xF3,
3002 0xE1,0x8D,0xC3,0x7D,0x98,0x27,0x40,0x08,0xB8,0x8C,0x6A,0xE9,
3003 0xBB,0x1A,0x3A,0xD6,0x86,0x83,0x5E,0x72,0x41,0xCE,0x85,0x3C,
3004 0xD2,0xB3,0xFC,0x13,0xCE,0x37,0x81,0x9E,0x4C,0x1C,0x7B,0x65,
3005 0xD3,0xE6,0xA6,0x00,0xF5,0x5A,0x95,0x43,0x5E,0x81,0xCF,0x60,
3006 0xA2,0x23,0xFC,0x36,0xA7,0x5D,0x7A,0x4C,0x06,0x91,0x6E,0xF6,
3007 0x57,0xEE,0x36,0xCB,0x06,0xEA,0xF5,0x3D,0x95,0x49,0xCB,0xA7,
3008 0xDD,0x81,0xDF,0x80,0x09,0x4A,0x97,0x4D,0xA8,0x22,0x72,0xA1,
3009 0x7F,0xC4,0x70,0x56,0x70,0xE8,0x20,0x10,0x18,0x8F,0x2E,0x60,
3010 0x07,0xE7,0x68,0x1A,0x82,0x5D,0x32,0xA2,
3014 if ((dh=DH_new()) == NULL) return(NULL);
3015 dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
3016 dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
3017 if ((dh->p == NULL) || (dh->g == NULL))
3018 { DH_free(dh); return(NULL); }
3024 #ifndef OPENSSL_NO_PSK
3025 /* convert the PSK key (psk_key) in ascii to binary (psk) */
3026 static int psk_key2bn(const char *pskkey, unsigned char *psk,
3027 unsigned int max_psk_len)
3032 ret = BN_hex2bn(&bn, pskkey);
3035 BIO_printf(bio_err,"Could not convert PSK key '%s' to BIGNUM\n", pskkey);
3040 if (BN_num_bytes(bn) > (int)max_psk_len)
3042 BIO_printf(bio_err,"psk buffer of callback is too small (%d) for key (%d)\n",
3043 max_psk_len, BN_num_bytes(bn));
3047 ret = BN_bn2bin(bn, psk);
3052 static unsigned int psk_client_callback(SSL *ssl, const char *hint, char *identity,
3053 unsigned int max_identity_len, unsigned char *psk,
3054 unsigned int max_psk_len)
3057 unsigned int psk_len = 0;
3059 ret = BIO_snprintf(identity, max_identity_len, "Client_identity");
3063 fprintf(stderr, "client: created identity '%s' len=%d\n", identity, ret);
3064 ret = psk_key2bn(psk_key, psk, max_psk_len);
3072 static unsigned int psk_server_callback(SSL *ssl, const char *identity,
3073 unsigned char *psk, unsigned int max_psk_len)
3075 unsigned int psk_len=0;
3077 if (strcmp(identity, "Client_identity") != 0)
3079 BIO_printf(bio_err, "server: PSK error: client identity not found\n");
3082 psk_len=psk_key2bn(psk_key, psk, max_psk_len);
3087 static int do_test_cipherlist(void)
3090 const SSL_METHOD *meth;
3091 const SSL_CIPHER *ci, *tci = NULL;
3093 #ifndef OPENSSL_NO_SSL2
3094 fprintf(stderr, "testing SSLv2 cipher list order: ");
3095 meth = SSLv2_method();
3096 while ((ci = meth->get_cipher(i++)) != NULL)
3099 if (ci->id >= tci->id)
3101 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3106 fprintf(stderr, "ok\n");
3108 #ifndef OPENSSL_NO_SSL3
3109 fprintf(stderr, "testing SSLv3 cipher list order: ");
3110 meth = SSLv3_method();
3112 while ((ci = meth->get_cipher(i++)) != NULL)
3115 if (ci->id >= tci->id)
3117 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3122 fprintf(stderr, "ok\n");
3124 #ifndef OPENSSL_NO_TLS1
3125 fprintf(stderr, "testing TLSv1 cipher list order: ");
3126 meth = TLSv1_method();
3128 while ((ci = meth->get_cipher(i++)) != NULL)
3131 if (ci->id >= tci->id)
3133 fprintf(stderr, "failed %lx vs. %lx\n", ci->id, tci->id);
3138 fprintf(stderr, "ok\n");