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-2006 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
144 * Until the key-gen callbacks are modified to use newer prototypes, we allow
145 * deprecated functions for openssl-internal code
147 #ifdef OPENSSL_NO_DEPRECATED
148 # undef OPENSSL_NO_DEPRECATED
157 #include <openssl/e_os2.h>
158 #ifdef OPENSSL_NO_STDIO
162 /* conflicts with winsock2 stuff on netware */
163 #if !defined(OPENSSL_SYS_NETWARE)
164 # include <sys/types.h>
168 * With IPv6, it looks like Digital has mixed up the proper order of
169 * recursive header file inclusion, resulting in the compiler complaining
170 * that u_int isn't defined, but only if _POSIX_C_SOURCE is defined, which is
171 * needed to have fileno() declared correctly... So let's define u_int
173 #if defined(OPENSSL_SYS_VMS_DECC) && !defined(__U_INT)
175 typedef unsigned int u_int;
178 #include <openssl/lhash.h>
179 #include <openssl/bn.h>
182 #include <openssl/err.h>
183 #include <openssl/pem.h>
184 #include <openssl/x509.h>
185 #include <openssl/ssl.h>
186 #include <openssl/rand.h>
187 #include <openssl/ocsp.h>
188 #ifndef OPENSSL_NO_DH
189 # include <openssl/dh.h>
191 #ifndef OPENSSL_NO_RSA
192 # include <openssl/rsa.h>
194 #ifndef OPENSSL_NO_SRP
195 # include <openssl/srp.h>
198 #include "timeouts.h"
200 #if (defined(OPENSSL_SYS_VMS) && __VMS_VER < 70000000)
201 /* FIONBIO used as a switch to enable ioctl, and that isn't in VMS < 7.0 */
205 #if defined(OPENSSL_SYS_BEOS_R5)
209 #ifndef OPENSSL_NO_RSA
210 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength);
212 static int sv_body(char *hostname, int s, int stype, unsigned char *context);
213 static int www_body(char *hostname, int s, int stype, unsigned char *context);
214 static int rev_body(char *hostname, int s, int stype, unsigned char *context);
215 static void close_accept_socket(void);
216 static void sv_usage(void);
217 static int init_ssl_connection(SSL *s);
218 static void print_stats(BIO *bp, SSL_CTX *ctx);
219 static int generate_session_id(const SSL *ssl, unsigned char *id,
220 unsigned int *id_len);
221 static void init_session_cache_ctx(SSL_CTX *sctx);
222 static void free_sessions(void);
223 #ifndef OPENSSL_NO_DH
224 static DH *load_dh_param(const char *dhfile);
225 static DH *get_dh512(void);
229 static void s_server_init(void);
232 #ifndef OPENSSL_NO_DH
233 static unsigned char dh512_p[] = {
234 0xDA, 0x58, 0x3C, 0x16, 0xD9, 0x85, 0x22, 0x89, 0xD0, 0xE4, 0xAF, 0x75,
235 0x6F, 0x4C, 0xCA, 0x92, 0xDD, 0x4B, 0xE5, 0x33, 0xB8, 0x04, 0xFB, 0x0F,
236 0xED, 0x94, 0xEF, 0x9C, 0x8A, 0x44, 0x03, 0xED, 0x57, 0x46, 0x50, 0xD3,
237 0x69, 0x99, 0xDB, 0x29, 0xD7, 0x76, 0x27, 0x6B, 0xA2, 0xD3, 0xD4, 0x12,
238 0xE2, 0x18, 0xF4, 0xDD, 0x1E, 0x08, 0x4C, 0xF6, 0xD8, 0x00, 0x3E, 0x7C,
239 0x47, 0x74, 0xE8, 0x33,
242 static unsigned char dh512_g[] = {
246 static DH *get_dh512(void)
250 if ((dh = DH_new()) == NULL)
252 dh->p = BN_bin2bn(dh512_p, sizeof(dh512_p), NULL);
253 dh->g = BN_bin2bn(dh512_g, sizeof(dh512_g), NULL);
254 if ((dh->p == NULL) || (dh->g == NULL))
260 /* static int load_CA(SSL_CTX *ctx, char *file);*/
263 #define BUFSIZZ 16*1024
264 static int bufsize = BUFSIZZ;
265 static int accept_socket = -1;
267 #define TEST_CERT "server.pem"
268 #ifndef OPENSSL_NO_TLSEXT
269 # define TEST_CERT2 "server2.pem"
272 #define PROG s_server_main
274 extern int verify_depth, verify_return_error, verify_quiet;
276 static int s_server_verify = SSL_VERIFY_NONE;
277 static int s_server_session_id_context = 1; /* anything will do */
278 static const char *s_cert_file = TEST_CERT, *s_key_file =
279 NULL, *s_chain_file = NULL;
280 #ifndef OPENSSL_NO_TLSEXT
281 static const char *s_cert_file2 = TEST_CERT2, *s_key_file2 = NULL;
283 static char *s_dcert_file = NULL, *s_dkey_file = NULL, *s_dchain_file = NULL;
285 static int s_nbio = 0;
287 static int s_nbio_test = 0;
289 static SSL_CTX *ctx = NULL;
290 #ifndef OPENSSL_NO_TLSEXT
291 static SSL_CTX *ctx2 = NULL;
295 static BIO *bio_s_out = NULL;
296 static BIO *bio_s_msg = NULL;
297 static int s_debug = 0;
298 #ifndef OPENSSL_NO_TLSEXT
299 static int s_tlsextdebug = 0;
300 static int s_tlsextstatus = 0;
301 static int cert_status_cb(SSL *s, void *arg);
303 static int no_resume_ephemeral = 0;
304 static int s_msg = 0;
305 static int s_quiet = 0;
306 static int s_ign_eof = 0;
307 static int s_brief = 0;
309 static char *keymatexportlabel = NULL;
310 static int keymatexportlen = 20;
313 #ifndef OPENSSL_NO_ENGINE
314 static char *engine_id = NULL;
316 static const char *session_id_prefix = NULL;
318 static int enable_timeouts = 0;
319 static long socket_mtu;
320 #ifndef OPENSSL_NO_DTLS1
321 static int cert_chain = 0;
324 #ifndef OPENSSL_NO_TLSEXT
325 static BIO *serverinfo_in = NULL;
326 static const char *s_serverinfo_file = NULL;
330 #ifndef OPENSSL_NO_PSK
331 static char *psk_identity = "Client_identity";
332 char *psk_key = NULL; /* by default PSK is not used */
334 static unsigned int psk_server_cb(SSL *ssl, const char *identity,
336 unsigned int max_psk_len)
338 unsigned int psk_len = 0;
343 BIO_printf(bio_s_out, "psk_server_cb\n");
345 BIO_printf(bio_err, "Error: client did not send PSK identity\n");
349 BIO_printf(bio_s_out, "identity_len=%d identity=%s\n",
350 identity ? (int)strlen(identity) : 0, identity);
352 /* here we could lookup the given identity e.g. from a database */
353 if (strcmp(identity, psk_identity) != 0) {
354 BIO_printf(bio_s_out, "PSK error: client identity not found"
355 " (got '%s' expected '%s')\n", identity, psk_identity);
359 BIO_printf(bio_s_out, "PSK client identity found\n");
361 /* convert the PSK key to binary */
362 ret = BN_hex2bn(&bn, psk_key);
364 BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
370 if (BN_num_bytes(bn) > (int)max_psk_len) {
372 "psk buffer of callback is too small (%d) for key (%d)\n",
373 max_psk_len, BN_num_bytes(bn));
378 ret = BN_bn2bin(bn, psk);
383 psk_len = (unsigned int)ret;
386 BIO_printf(bio_s_out, "fetched PSK len=%d\n", psk_len);
390 BIO_printf(bio_err, "Error in PSK server callback\n");
395 #ifndef OPENSSL_NO_SRP
396 /* This is a context that we pass to callbacks */
397 typedef struct srpsrvparm_st {
404 * This callback pretends to require some asynchronous logic in order to
405 * obtain a verifier. When the callback is called for a new connection we
406 * return with a negative value. This will provoke the accept etc to return
407 * with an LOOKUP_X509. The main logic of the reinvokes the suspended call
408 * (which would normally occur after a worker has finished) and we set the
411 static int MS_CALLBACK ssl_srp_server_param_cb(SSL *s, int *ad, void *arg)
413 srpsrvparm *p = (srpsrvparm *) arg;
414 if (p->login == NULL && p->user == NULL) {
415 p->login = SSL_get_srp_username(s);
416 BIO_printf(bio_err, "SRP username = \"%s\"\n", p->login);
420 if (p->user == NULL) {
421 BIO_printf(bio_err, "User %s doesn't exist\n", p->login);
422 return SSL3_AL_FATAL;
424 if (SSL_set_srp_server_param
425 (s, p->user->N, p->user->g, p->user->s, p->user->v,
426 p->user->info) < 0) {
427 *ad = SSL_AD_INTERNAL_ERROR;
428 return SSL3_AL_FATAL;
431 "SRP parameters set: username = \"%s\" info=\"%s\" \n",
432 p->login, p->user->info);
433 /* need to check whether there are memory leaks */
436 return SSL_ERROR_NONE;
442 static void s_server_init(void)
445 s_server_verify = SSL_VERIFY_NONE;
448 s_dchain_file = NULL;
449 s_cert_file = TEST_CERT;
452 # ifndef OPENSSL_NO_TLSEXT
453 s_cert_file2 = TEST_CERT2;
470 # ifndef OPENSSL_NO_ENGINE
476 static void sv_usage(void)
478 BIO_printf(bio_err, "usage: s_server [args ...]\n");
479 BIO_printf(bio_err, "\n");
481 " -accept arg - port to accept on (default is %d)\n", PORT);
483 " -verify_host host - check peer certificate matches \"host\"\n");
485 " -verify_email email - check peer certificate matches \"email\"\n");
487 " -verify_ip ipaddr - check peer certificate matches \"ipaddr\"\n");
488 BIO_printf(bio_err, " -context arg - set session ID context\n");
490 " -verify arg - turn on peer certificate verification\n");
492 " -Verify arg - turn on peer certificate verification, must have a cert.\n");
494 " -verify_return_error - return verification errors\n");
495 BIO_printf(bio_err, " -cert arg - certificate file to use\n");
496 BIO_printf(bio_err, " (default is %s)\n", TEST_CERT);
497 #ifndef OPENSSL_NO_TLSEXT
499 " -serverinfo arg - PEM serverinfo file for certificate\n");
501 " -auth - send and receive RFC 5878 TLS auth extensions and supplemental data\n");
503 " -auth_require_reneg - Do not send TLS auth extensions until renegotiation\n");
506 " -no_resumption_on_reneg - set SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION flag\n");
508 " -crl_check - check the peer certificate has not been revoked by its CA.\n"
509 " The CRL(s) are appended to the certificate file\n");
511 " -crl_check_all - check the peer certificate has not been revoked by its CA\n"
512 " or any other CRL in the CA chain. CRL(s) are appened to the\n"
513 " the certificate file.\n");
515 " -certform arg - certificate format (PEM or DER) PEM default\n");
517 " -key arg - Private Key file to use, in cert file if\n");
518 BIO_printf(bio_err, " not specified (default is %s)\n",
521 " -keyform arg - key format (PEM, DER or ENGINE) PEM default\n");
523 " -pass arg - private key file pass phrase source\n");
525 " -dcert arg - second certificate file to use (usually for DSA)\n");
527 " -dcertform x - second certificate format (PEM or DER) PEM default\n");
529 " -dkey arg - second private key file to use (usually for DSA)\n");
531 " -dkeyform arg - second key format (PEM, DER or ENGINE) PEM default\n");
533 " -dpass arg - second private key file pass phrase source\n");
535 " -dhparam arg - DH parameter file to use, in cert file if not specified\n");
537 " or a default set of parameters is used\n");
538 #ifndef OPENSSL_NO_ECDH
540 " -named_curve arg - Elliptic curve name to use for ephemeral ECDH keys.\n"
541 " Use \"openssl ecparam -list_curves\" for all names\n"
542 " (default is nistp256).\n");
545 BIO_printf(bio_err, " -nbio - Run with non-blocking IO\n");
548 " -nbio_test - test with the non-blocking test bio\n");
550 " -crlf - convert LF from terminal into CRLF\n");
551 BIO_printf(bio_err, " -debug - Print more output\n");
552 BIO_printf(bio_err, " -msg - Show protocol messages\n");
553 BIO_printf(bio_err, " -state - Print the SSL states\n");
554 BIO_printf(bio_err, " -CApath arg - PEM format directory of CA's\n");
555 BIO_printf(bio_err, " -CAfile arg - PEM format file of CA's\n");
557 " -nocert - Don't use any certificates (Anon-DH)\n");
559 " -cipher arg - play with 'openssl ciphers' to see what goes here\n");
560 BIO_printf(bio_err, " -serverpref - Use server's cipher preferences\n");
561 BIO_printf(bio_err, " -quiet - No server output\n");
562 BIO_printf(bio_err, " -no_tmp_rsa - Do not generate a tmp RSA key\n");
563 #ifndef OPENSSL_NO_PSK
564 BIO_printf(bio_err, " -psk_hint arg - PSK identity hint to use\n");
565 BIO_printf(bio_err, " -psk arg - PSK in hex (without 0x)\n");
566 # ifndef OPENSSL_NO_JPAKE
567 BIO_printf(bio_err, " -jpake arg - JPAKE secret to use\n");
570 #ifndef OPENSSL_NO_SRP
571 BIO_printf(bio_err, " -srpvfile file - The verifier file for SRP\n");
573 " -srpuserseed string - A seed string for a default user salt.\n");
575 BIO_printf(bio_err, " -ssl2 - Just talk SSLv2\n");
576 #ifndef OPENSSL_NO_SSL3_METHOD
577 BIO_printf(bio_err, " -ssl3 - Just talk SSLv3\n");
579 BIO_printf(bio_err, " -tls1_2 - Just talk TLSv1.2\n");
580 BIO_printf(bio_err, " -tls1_1 - Just talk TLSv1.1\n");
581 BIO_printf(bio_err, " -tls1 - Just talk TLSv1\n");
582 BIO_printf(bio_err, " -dtls1 - Just talk DTLSv1\n");
583 BIO_printf(bio_err, " -dtls1_2 - Just talk DTLSv1.2\n");
584 BIO_printf(bio_err, " -timeout - Enable timeouts\n");
585 BIO_printf(bio_err, " -mtu - Set link layer MTU\n");
586 BIO_printf(bio_err, " -chain - Read a certificate chain\n");
587 BIO_printf(bio_err, " -no_ssl2 - Just disable SSLv2\n");
588 BIO_printf(bio_err, " -no_ssl3 - Just disable SSLv3\n");
589 BIO_printf(bio_err, " -no_tls1 - Just disable TLSv1\n");
590 BIO_printf(bio_err, " -no_tls1_1 - Just disable TLSv1.1\n");
591 BIO_printf(bio_err, " -no_tls1_2 - Just disable TLSv1.2\n");
592 #ifndef OPENSSL_NO_DH
593 BIO_printf(bio_err, " -no_dhe - Disable ephemeral DH\n");
595 #ifndef OPENSSL_NO_ECDH
596 BIO_printf(bio_err, " -no_ecdhe - Disable ephemeral ECDH\n");
598 BIO_printf(bio_err, " -bugs - Turn on SSL bug compatibility\n");
600 " -hack - workaround for early Netscape code\n");
602 " -www - Respond to a 'GET /' with a status page\n");
604 " -WWW - Respond to a 'GET /<path> HTTP/1.0' with file ./<path>\n");
606 " -HTTP - Respond to a 'GET /<path> HTTP/1.0' with file ./<path>\n");
608 " with the assumption it contains a complete HTTP response.\n");
609 #ifndef OPENSSL_NO_ENGINE
611 " -engine id - Initialise and use the specified engine\n");
614 " -id_prefix arg - Generate SSL/TLS session IDs prefixed by 'arg'\n");
615 BIO_printf(bio_err, " -rand file%cfile%c...\n", LIST_SEPARATOR_CHAR,
616 LIST_SEPARATOR_CHAR);
617 #ifndef OPENSSL_NO_TLSEXT
619 " -servername host - servername for HostName TLS extension\n");
621 " -servername_fatal - on mismatch send fatal alert (default warning alert)\n");
623 " -cert2 arg - certificate file to use for servername\n");
624 BIO_printf(bio_err, " (default is %s)\n", TEST_CERT2);
626 " -key2 arg - Private Key file to use for servername, in cert file if\n");
627 BIO_printf(bio_err, " not specified (default is %s)\n",
630 " -tlsextdebug - hex dump of all TLS extensions received\n");
632 " -no_ticket - disable use of RFC4507bis session tickets\n");
634 " -legacy_renegotiation - enable use of legacy renegotiation (dangerous)\n");
635 # ifndef OPENSSL_NO_NEXTPROTONEG
637 " -nextprotoneg arg - set the advertised protocols for the NPN extension (comma-separated list)\n");
639 # ifndef OPENSSL_NO_SRTP
641 " -use_srtp profiles - Offer SRTP key management with a colon-separated profile list\n");
644 " -alpn arg - set the advertised protocols for the ALPN extension (comma-separated list)\n");
647 " -keymatexport label - Export keying material using label\n");
649 " -keymatexportlen len - Export len bytes of keying material (default 20)\n");
651 " -status - respond to certificate status requests\n");
653 " -status_verbose - enable status request verbose printout\n");
655 " -status_timeout n - status request responder timeout\n");
656 BIO_printf(bio_err, " -status_url URL - status request fallback URL\n");
659 static int local_argc = 0;
660 static char **local_argv;
662 #ifdef CHARSET_EBCDIC
663 static int ebcdic_new(BIO *bi);
664 static int ebcdic_free(BIO *a);
665 static int ebcdic_read(BIO *b, char *out, int outl);
666 static int ebcdic_write(BIO *b, const char *in, int inl);
667 static long ebcdic_ctrl(BIO *b, int cmd, long num, void *ptr);
668 static int ebcdic_gets(BIO *bp, char *buf, int size);
669 static int ebcdic_puts(BIO *bp, const char *str);
671 # define BIO_TYPE_EBCDIC_FILTER (18|0x0200)
672 static BIO_METHOD methods_ebcdic = {
673 BIO_TYPE_EBCDIC_FILTER,
674 "EBCDIC/ASCII filter",
689 BIO_METHOD *BIO_f_ebcdic_filter()
691 return (&methods_ebcdic);
694 static int ebcdic_new(BIO *bi)
696 EBCDIC_OUTBUFF *wbuf;
698 wbuf = (EBCDIC_OUTBUFF *) OPENSSL_malloc(sizeof(EBCDIC_OUTBUFF) + 1024);
699 wbuf->alloced = 1024;
700 wbuf->buff[0] = '\0';
702 bi->ptr = (char *)wbuf;
708 static int ebcdic_free(BIO *a)
713 OPENSSL_free(a->ptr);
720 static int ebcdic_read(BIO *b, char *out, int outl)
724 if (out == NULL || outl == 0)
726 if (b->next_bio == NULL)
729 ret = BIO_read(b->next_bio, out, outl);
731 ascii2ebcdic(out, out, ret);
735 static int ebcdic_write(BIO *b, const char *in, int inl)
737 EBCDIC_OUTBUFF *wbuf;
742 if ((in == NULL) || (inl <= 0))
744 if (b->next_bio == NULL)
747 wbuf = (EBCDIC_OUTBUFF *) b->ptr;
749 if (inl > (num = wbuf->alloced)) {
750 num = num + num; /* double the size */
755 (EBCDIC_OUTBUFF *) OPENSSL_malloc(sizeof(EBCDIC_OUTBUFF) + num);
758 wbuf->buff[0] = '\0';
760 b->ptr = (char *)wbuf;
763 ebcdic2ascii(wbuf->buff, in, inl);
765 ret = BIO_write(b->next_bio, wbuf->buff, inl);
770 static long ebcdic_ctrl(BIO *b, int cmd, long num, void *ptr)
774 if (b->next_bio == NULL)
781 ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
787 static int ebcdic_gets(BIO *bp, char *buf, int size)
790 if (bp->next_bio == NULL)
792 /* return(BIO_gets(bp->next_bio,buf,size));*/
793 for (i = 0; i < size - 1; ++i) {
794 ret = ebcdic_read(bp, &buf[i], 1);
797 else if (buf[i] == '\n') {
804 return (ret < 0 && i == 0) ? ret : i;
807 static int ebcdic_puts(BIO *bp, const char *str)
809 if (bp->next_bio == NULL)
811 return ebcdic_write(bp, str, strlen(str));
815 #ifndef OPENSSL_NO_TLSEXT
817 /* This is a context that we pass to callbacks */
818 typedef struct tlsextctx_st {
824 static int MS_CALLBACK ssl_servername_cb(SSL *s, int *ad, void *arg)
826 tlsextctx *p = (tlsextctx *) arg;
827 const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
828 if (servername && p->biodebug)
829 BIO_printf(p->biodebug, "Hostname in TLS extension: \"%s\"\n",
833 return SSL_TLSEXT_ERR_NOACK;
836 if (strcasecmp(servername, p->servername))
837 return p->extension_error;
839 BIO_printf(p->biodebug, "Switching server context.\n");
840 SSL_set_SSL_CTX(s, ctx2);
843 return SSL_TLSEXT_ERR_OK;
846 /* Structure passed to cert status callback */
848 typedef struct tlsextstatusctx_st {
849 /* Default responder to use */
850 char *host, *path, *port;
857 static tlsextstatusctx tlscstatp = { NULL, NULL, NULL, 0, -1, NULL, 0 };
860 * Certificate Status callback. This is called when a client includes a
861 * certificate status request extension. This is a simplified version. It
862 * examines certificates each time and makes one OCSP responder query for
863 * each request. A full version would store details such as the OCSP
864 * certificate IDs and minimise the number of OCSP responses by caching them
865 * until they were considered "expired".
868 static int cert_status_cb(SSL *s, void *arg)
870 tlsextstatusctx *srctx = arg;
871 BIO *err = srctx->err;
872 char *host, *port, *path;
874 unsigned char *rspder = NULL;
876 STACK_OF(OPENSSL_STRING) *aia = NULL;
878 X509_STORE_CTX inctx;
880 OCSP_REQUEST *req = NULL;
881 OCSP_RESPONSE *resp = NULL;
882 OCSP_CERTID *id = NULL;
883 STACK_OF(X509_EXTENSION) *exts;
884 int ret = SSL_TLSEXT_ERR_NOACK;
887 STACK_OF(OCSP_RESPID) *ids;
888 SSL_get_tlsext_status_ids(s, &ids);
889 BIO_printf(err, "cert_status: received %d ids\n",
890 sk_OCSP_RESPID_num(ids));
893 BIO_puts(err, "cert_status: callback called\n");
894 /* Build up OCSP query from server certificate */
895 x = SSL_get_certificate(s);
896 aia = X509_get1_ocsp(x);
898 if (!OCSP_parse_url(sk_OPENSSL_STRING_value(aia, 0),
899 &host, &port, &path, &use_ssl)) {
900 BIO_puts(err, "cert_status: can't parse AIA URL\n");
904 BIO_printf(err, "cert_status: AIA URL: %s\n",
905 sk_OPENSSL_STRING_value(aia, 0));
909 "cert_status: no AIA and no default responder URL\n");
915 use_ssl = srctx->use_ssl;
918 if (!X509_STORE_CTX_init(&inctx,
919 SSL_CTX_get_cert_store(SSL_get_SSL_CTX(s)),
922 if (X509_STORE_get_by_subject(&inctx, X509_LU_X509,
923 X509_get_issuer_name(x), &obj) <= 0) {
924 BIO_puts(err, "cert_status: Can't retrieve issuer certificate.\n");
925 X509_STORE_CTX_cleanup(&inctx);
928 req = OCSP_REQUEST_new();
931 id = OCSP_cert_to_id(NULL, x, obj.data.x509);
932 X509_free(obj.data.x509);
933 X509_STORE_CTX_cleanup(&inctx);
936 if (!OCSP_request_add0_id(req, id))
939 /* Add any extensions to the request */
940 SSL_get_tlsext_status_exts(s, &exts);
941 for (i = 0; i < sk_X509_EXTENSION_num(exts); i++) {
942 X509_EXTENSION *ext = sk_X509_EXTENSION_value(exts, i);
943 if (!OCSP_REQUEST_add_ext(req, ext, -1))
946 resp = process_responder(err, req, host, path, port, use_ssl, NULL,
949 BIO_puts(err, "cert_status: error querying responder\n");
952 rspderlen = i2d_OCSP_RESPONSE(resp, &rspder);
955 SSL_set_tlsext_status_ocsp_resp(s, rspder, rspderlen);
956 if (srctx->verbose) {
957 BIO_puts(err, "cert_status: ocsp response sent:\n");
958 OCSP_RESPONSE_print(err, resp, 2);
960 ret = SSL_TLSEXT_ERR_OK;
962 if (ret != SSL_TLSEXT_ERR_OK)
963 ERR_print_errors(err);
968 X509_email_free(aia);
971 OCSP_CERTID_free(id);
973 OCSP_REQUEST_free(req);
975 OCSP_RESPONSE_free(resp);
978 ret = SSL_TLSEXT_ERR_ALERT_FATAL;
982 # ifndef OPENSSL_NO_NEXTPROTONEG
983 /* This is the context that we pass to next_proto_cb */
984 typedef struct tlsextnextprotoctx_st {
987 } tlsextnextprotoctx;
989 static int next_proto_cb(SSL *s, const unsigned char **data,
990 unsigned int *len, void *arg)
992 tlsextnextprotoctx *next_proto = arg;
994 *data = next_proto->data;
995 *len = next_proto->len;
997 return SSL_TLSEXT_ERR_OK;
999 # endif /* ndef OPENSSL_NO_NEXTPROTONEG */
1001 /* This the context that we pass to alpn_cb */
1002 typedef struct tlsextalpnctx_st {
1003 unsigned char *data;
1007 static int alpn_cb(SSL *s, const unsigned char **out, unsigned char *outlen,
1008 const unsigned char *in, unsigned int inlen, void *arg)
1010 tlsextalpnctx *alpn_ctx = arg;
1013 /* We can assume that |in| is syntactically valid. */
1015 BIO_printf(bio_s_out, "ALPN protocols advertised by the client: ");
1016 for (i = 0; i < inlen;) {
1018 BIO_write(bio_s_out, ", ", 2);
1019 BIO_write(bio_s_out, &in[i + 1], in[i]);
1022 BIO_write(bio_s_out, "\n", 1);
1025 if (SSL_select_next_proto
1026 ((unsigned char **)out, outlen, alpn_ctx->data, alpn_ctx->len, in,
1027 inlen) != OPENSSL_NPN_NEGOTIATED) {
1028 return SSL_TLSEXT_ERR_NOACK;
1032 BIO_printf(bio_s_out, "ALPN protocols selected: ");
1033 BIO_write(bio_s_out, *out, *outlen);
1034 BIO_write(bio_s_out, "\n", 1);
1037 return SSL_TLSEXT_ERR_OK;
1039 #endif /* ndef OPENSSL_NO_TLSEXT */
1041 int MAIN(int, char **);
1043 #ifndef OPENSSL_NO_JPAKE
1044 static char *jpake_secret = NULL;
1045 # define no_jpake !jpake_secret
1049 #ifndef OPENSSL_NO_SRP
1050 static srpsrvparm srp_callback_parm;
1052 #ifndef OPENSSL_NO_SRTP
1053 static char *srtp_profiles = NULL;
1056 int MAIN(int argc, char *argv[])
1058 X509_VERIFY_PARAM *vpm = NULL;
1061 char *CApath = NULL, *CAfile = NULL;
1062 char *chCApath = NULL, *chCAfile = NULL;
1063 char *vfyCApath = NULL, *vfyCAfile = NULL;
1064 unsigned char *context = NULL;
1065 char *dhfile = NULL;
1068 int build_chain = 0;
1069 int no_tmp_rsa = 0, no_dhe = 0, no_ecdhe = 0, nocert = 0;
1071 const SSL_METHOD *meth = NULL;
1072 int socket_type = SOCK_STREAM;
1074 char *inrand = NULL;
1075 int s_cert_format = FORMAT_PEM, s_key_format = FORMAT_PEM;
1076 char *passarg = NULL, *pass = NULL;
1077 char *dpassarg = NULL, *dpass = NULL;
1078 int s_dcert_format = FORMAT_PEM, s_dkey_format = FORMAT_PEM;
1079 X509 *s_cert = NULL, *s_dcert = NULL;
1080 STACK_OF(X509) *s_chain = NULL, *s_dchain = NULL;
1081 EVP_PKEY *s_key = NULL, *s_dkey = NULL;
1082 int no_cache = 0, ext_cache = 0;
1083 int rev = 0, naccept = -1;
1084 #ifndef OPENSSL_NO_TLSEXT
1085 EVP_PKEY *s_key2 = NULL;
1086 X509 *s_cert2 = NULL;
1087 tlsextctx tlsextcbp = { NULL, NULL, SSL_TLSEXT_ERR_ALERT_WARNING };
1088 # ifndef OPENSSL_NO_NEXTPROTONEG
1089 const char *next_proto_neg_in = NULL;
1090 tlsextnextprotoctx next_proto = { NULL, 0 };
1092 const char *alpn_in = NULL;
1093 tlsextalpnctx alpn_ctx = { NULL, 0 };
1095 #ifndef OPENSSL_NO_PSK
1096 /* by default do not send a PSK identity hint */
1097 static char *psk_identity_hint = NULL;
1099 #ifndef OPENSSL_NO_SRP
1100 char *srpuserseed = NULL;
1101 char *srp_verifier_file = NULL;
1103 SSL_EXCERT *exc = NULL;
1104 SSL_CONF_CTX *cctx = NULL;
1105 STACK_OF(OPENSSL_STRING) *ssl_args = NULL;
1107 char *crl_file = NULL;
1108 int crl_format = FORMAT_PEM;
1109 int crl_download = 0;
1110 STACK_OF(X509_CRL) *crls = NULL;
1112 meth = SSLv23_server_method();
1122 if (bio_err == NULL)
1123 bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);
1125 if (!load_config(bio_err, NULL))
1128 cctx = SSL_CONF_CTX_new();
1131 SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_SERVER);
1132 SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CMDLINE);
1144 if ((strcmp(*argv, "-port") == 0) || (strcmp(*argv, "-accept") == 0)) {
1147 if (!extract_port(*(++argv), &port))
1149 } else if (strcmp(*argv, "-naccept") == 0) {
1152 naccept = atol(*(++argv));
1154 BIO_printf(bio_err, "bad accept value %s\n", *argv);
1157 } else if (strcmp(*argv, "-verify") == 0) {
1158 s_server_verify = SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE;
1161 verify_depth = atoi(*(++argv));
1163 BIO_printf(bio_err, "verify depth is %d\n", verify_depth);
1164 } else if (strcmp(*argv, "-Verify") == 0) {
1166 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT |
1167 SSL_VERIFY_CLIENT_ONCE;
1170 verify_depth = atoi(*(++argv));
1173 "verify depth is %d, must return a certificate\n",
1175 } else if (strcmp(*argv, "-context") == 0) {
1178 context = (unsigned char *)*(++argv);
1179 } else if (strcmp(*argv, "-cert") == 0) {
1182 s_cert_file = *(++argv);
1183 } else if (strcmp(*argv, "-CRL") == 0) {
1186 crl_file = *(++argv);
1187 } else if (strcmp(*argv, "-crl_download") == 0)
1189 #ifndef OPENSSL_NO_TLSEXT
1190 else if (strcmp(*argv, "-serverinfo") == 0) {
1193 s_serverinfo_file = *(++argv);
1196 else if (strcmp(*argv, "-certform") == 0) {
1199 s_cert_format = str2fmt(*(++argv));
1200 } else if (strcmp(*argv, "-key") == 0) {
1203 s_key_file = *(++argv);
1204 } else if (strcmp(*argv, "-keyform") == 0) {
1207 s_key_format = str2fmt(*(++argv));
1208 } else if (strcmp(*argv, "-pass") == 0) {
1211 passarg = *(++argv);
1212 } else if (strcmp(*argv, "-cert_chain") == 0) {
1215 s_chain_file = *(++argv);
1216 } else if (strcmp(*argv, "-dhparam") == 0) {
1220 } else if (strcmp(*argv, "-dcertform") == 0) {
1223 s_dcert_format = str2fmt(*(++argv));
1224 } else if (strcmp(*argv, "-dcert") == 0) {
1227 s_dcert_file = *(++argv);
1228 } else if (strcmp(*argv, "-dkeyform") == 0) {
1231 s_dkey_format = str2fmt(*(++argv));
1232 } else if (strcmp(*argv, "-dpass") == 0) {
1235 dpassarg = *(++argv);
1236 } else if (strcmp(*argv, "-dkey") == 0) {
1239 s_dkey_file = *(++argv);
1240 } else if (strcmp(*argv, "-dcert_chain") == 0) {
1243 s_dchain_file = *(++argv);
1244 } else if (strcmp(*argv, "-nocert") == 0) {
1246 } else if (strcmp(*argv, "-CApath") == 0) {
1250 } else if (strcmp(*argv, "-chainCApath") == 0) {
1253 chCApath = *(++argv);
1254 } else if (strcmp(*argv, "-verifyCApath") == 0) {
1257 vfyCApath = *(++argv);
1258 } else if (strcmp(*argv, "-no_cache") == 0)
1260 else if (strcmp(*argv, "-ext_cache") == 0)
1262 else if (strcmp(*argv, "-CRLform") == 0) {
1265 crl_format = str2fmt(*(++argv));
1266 } else if (args_verify(&argv, &argc, &badarg, bio_err, &vpm)) {
1270 } else if (args_excert(&argv, &argc, &badarg, bio_err, &exc)) {
1274 } else if (args_ssl(&argv, &argc, cctx, &badarg, bio_err, &ssl_args)) {
1278 } else if (strcmp(*argv, "-verify_return_error") == 0)
1279 verify_return_error = 1;
1280 else if (strcmp(*argv, "-verify_quiet") == 0)
1282 else if (strcmp(*argv, "-build_chain") == 0)
1284 else if (strcmp(*argv, "-CAfile") == 0) {
1288 } else if (strcmp(*argv, "-chainCAfile") == 0) {
1291 chCAfile = *(++argv);
1292 } else if (strcmp(*argv, "-verifyCAfile") == 0) {
1295 vfyCAfile = *(++argv);
1298 else if (strcmp(*argv, "-nbio") == 0) {
1302 else if (strcmp(*argv, "-nbio_test") == 0) {
1307 } else if (strcmp(*argv, "-ign_eof") == 0)
1309 else if (strcmp(*argv, "-no_ign_eof") == 0)
1311 else if (strcmp(*argv, "-debug") == 0) {
1314 #ifndef OPENSSL_NO_TLSEXT
1315 else if (strcmp(*argv, "-tlsextdebug") == 0)
1317 else if (strcmp(*argv, "-status") == 0)
1319 else if (strcmp(*argv, "-status_verbose") == 0) {
1321 tlscstatp.verbose = 1;
1322 } else if (!strcmp(*argv, "-status_timeout")) {
1326 tlscstatp.timeout = atoi(*(++argv));
1327 } else if (!strcmp(*argv, "-status_url")) {
1331 if (!OCSP_parse_url(*(++argv),
1334 &tlscstatp.path, &tlscstatp.use_ssl)) {
1335 BIO_printf(bio_err, "Error parsing URL\n");
1340 else if (strcmp(*argv, "-msg") == 0) {
1342 } else if (strcmp(*argv, "-msgfile") == 0) {
1345 bio_s_msg = BIO_new_file(*(++argv), "w");
1347 #ifndef OPENSSL_NO_SSL_TRACE
1348 else if (strcmp(*argv, "-trace") == 0) {
1352 else if (strcmp(*argv, "-hack") == 0) {
1354 } else if (strcmp(*argv, "-state") == 0) {
1356 } else if (strcmp(*argv, "-crlf") == 0) {
1358 } else if (strcmp(*argv, "-quiet") == 0) {
1360 } else if (strcmp(*argv, "-brief") == 0) {
1364 } else if (strcmp(*argv, "-no_tmp_rsa") == 0) {
1366 } else if (strcmp(*argv, "-no_dhe") == 0) {
1368 } else if (strcmp(*argv, "-no_ecdhe") == 0) {
1370 } else if (strcmp(*argv, "-no_resume_ephemeral") == 0) {
1371 no_resume_ephemeral = 1;
1373 #ifndef OPENSSL_NO_PSK
1374 else if (strcmp(*argv, "-psk_hint") == 0) {
1377 psk_identity_hint = *(++argv);
1378 } else if (strcmp(*argv, "-psk") == 0) {
1383 psk_key = *(++argv);
1384 for (i = 0; i < strlen(psk_key); i++) {
1385 if (isxdigit((unsigned char)psk_key[i]))
1387 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
1392 #ifndef OPENSSL_NO_SRP
1393 else if (strcmp(*argv, "-srpvfile") == 0) {
1396 srp_verifier_file = *(++argv);
1397 meth = TLSv1_server_method();
1398 } else if (strcmp(*argv, "-srpuserseed") == 0) {
1401 srpuserseed = *(++argv);
1402 meth = TLSv1_server_method();
1405 else if (strcmp(*argv, "-rev") == 0) {
1407 } else if (strcmp(*argv, "-www") == 0) {
1409 } else if (strcmp(*argv, "-WWW") == 0) {
1411 } else if (strcmp(*argv, "-HTTP") == 0) {
1414 #ifndef OPENSSL_NO_SSL2
1415 else if (strcmp(*argv, "-ssl2") == 0) {
1417 meth = SSLv2_server_method();
1420 #ifndef OPENSSL_NO_SSL3_METHOD
1421 else if (strcmp(*argv, "-ssl3") == 0) {
1422 meth = SSLv3_server_method();
1425 #ifndef OPENSSL_NO_TLS1
1426 else if (strcmp(*argv, "-tls1") == 0) {
1427 meth = TLSv1_server_method();
1428 } else if (strcmp(*argv, "-tls1_1") == 0) {
1429 meth = TLSv1_1_server_method();
1430 } else if (strcmp(*argv, "-tls1_2") == 0) {
1431 meth = TLSv1_2_server_method();
1434 #ifndef OPENSSL_NO_DTLS1
1435 else if (strcmp(*argv, "-dtls") == 0) {
1436 meth = DTLS_server_method();
1437 socket_type = SOCK_DGRAM;
1438 } else if (strcmp(*argv, "-dtls1") == 0) {
1439 meth = DTLSv1_server_method();
1440 socket_type = SOCK_DGRAM;
1441 } else if (strcmp(*argv, "-dtls1_2") == 0) {
1442 meth = DTLSv1_2_server_method();
1443 socket_type = SOCK_DGRAM;
1444 } else if (strcmp(*argv, "-timeout") == 0)
1445 enable_timeouts = 1;
1446 else if (strcmp(*argv, "-mtu") == 0) {
1449 socket_mtu = atol(*(++argv));
1450 } else if (strcmp(*argv, "-chain") == 0)
1453 else if (strcmp(*argv, "-id_prefix") == 0) {
1456 session_id_prefix = *(++argv);
1458 #ifndef OPENSSL_NO_ENGINE
1459 else if (strcmp(*argv, "-engine") == 0) {
1462 engine_id = *(++argv);
1465 else if (strcmp(*argv, "-rand") == 0) {
1470 #ifndef OPENSSL_NO_TLSEXT
1471 else if (strcmp(*argv, "-servername") == 0) {
1474 tlsextcbp.servername = *(++argv);
1475 } else if (strcmp(*argv, "-servername_fatal") == 0) {
1476 tlsextcbp.extension_error = SSL_TLSEXT_ERR_ALERT_FATAL;
1477 } else if (strcmp(*argv, "-cert2") == 0) {
1480 s_cert_file2 = *(++argv);
1481 } else if (strcmp(*argv, "-key2") == 0) {
1484 s_key_file2 = *(++argv);
1486 # ifndef OPENSSL_NO_NEXTPROTONEG
1487 else if (strcmp(*argv, "-nextprotoneg") == 0) {
1490 next_proto_neg_in = *(++argv);
1493 else if (strcmp(*argv, "-alpn") == 0) {
1496 alpn_in = *(++argv);
1499 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
1500 else if (strcmp(*argv, "-jpake") == 0) {
1503 jpake_secret = *(++argv);
1506 #ifndef OPENSSL_NO_SRTP
1507 else if (strcmp(*argv, "-use_srtp") == 0) {
1510 srtp_profiles = *(++argv);
1513 else if (strcmp(*argv, "-keymatexport") == 0) {
1516 keymatexportlabel = *(++argv);
1517 } else if (strcmp(*argv, "-keymatexportlen") == 0) {
1520 keymatexportlen = atoi(*(++argv));
1521 if (keymatexportlen == 0)
1524 BIO_printf(bio_err, "unknown option %s\n", *argv);
1536 #ifndef OPENSSL_NO_DTLS1
1537 if (www && socket_type == SOCK_DGRAM) {
1538 BIO_printf(bio_err, "Can't use -HTTP, -www or -WWW with DTLS\n");
1543 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
1546 BIO_printf(bio_err, "Can't use JPAKE and PSK together\n");
1549 psk_identity = "JPAKE";
1553 SSL_load_error_strings();
1554 OpenSSL_add_ssl_algorithms();
1556 #ifndef OPENSSL_NO_ENGINE
1557 e = setup_engine(bio_err, engine_id, 1);
1560 if (!app_passwd(bio_err, passarg, dpassarg, &pass, &dpass)) {
1561 BIO_printf(bio_err, "Error getting password\n");
1565 if (s_key_file == NULL)
1566 s_key_file = s_cert_file;
1567 #ifndef OPENSSL_NO_TLSEXT
1568 if (s_key_file2 == NULL)
1569 s_key_file2 = s_cert_file2;
1572 if (!load_excert(&exc, bio_err))
1576 s_key = load_key(bio_err, s_key_file, s_key_format, 0, pass, e,
1577 "server certificate private key file");
1579 ERR_print_errors(bio_err);
1583 s_cert = load_cert(bio_err, s_cert_file, s_cert_format,
1584 NULL, e, "server certificate file");
1587 ERR_print_errors(bio_err);
1591 s_chain = load_certs(bio_err, s_chain_file, FORMAT_PEM,
1592 NULL, e, "server certificate chain");
1596 #ifndef OPENSSL_NO_TLSEXT
1597 if (tlsextcbp.servername) {
1598 s_key2 = load_key(bio_err, s_key_file2, s_key_format, 0, pass, e,
1599 "second server certificate private key file");
1601 ERR_print_errors(bio_err);
1605 s_cert2 = load_cert(bio_err, s_cert_file2, s_cert_format,
1606 NULL, e, "second server certificate file");
1609 ERR_print_errors(bio_err);
1613 #endif /* OPENSSL_NO_TLSEXT */
1615 #if !defined(OPENSSL_NO_TLSEXT)
1616 # if !defined(OPENSSL_NO_NEXTPROTONEG)
1617 if (next_proto_neg_in) {
1619 next_proto.data = next_protos_parse(&len, next_proto_neg_in);
1620 if (next_proto.data == NULL)
1622 next_proto.len = len;
1624 next_proto.data = NULL;
1627 alpn_ctx.data = NULL;
1630 alpn_ctx.data = next_protos_parse(&len, alpn_in);
1631 if (alpn_ctx.data == NULL)
1639 crl = load_crl(crl_file, crl_format);
1641 BIO_puts(bio_err, "Error loading CRL\n");
1642 ERR_print_errors(bio_err);
1645 crls = sk_X509_CRL_new_null();
1646 if (!crls || !sk_X509_CRL_push(crls, crl)) {
1647 BIO_puts(bio_err, "Error adding CRL\n");
1648 ERR_print_errors(bio_err);
1656 if (s_dkey_file == NULL)
1657 s_dkey_file = s_dcert_file;
1659 s_dkey = load_key(bio_err, s_dkey_file, s_dkey_format,
1660 0, dpass, e, "second certificate private key file");
1662 ERR_print_errors(bio_err);
1666 s_dcert = load_cert(bio_err, s_dcert_file, s_dcert_format,
1667 NULL, e, "second server certificate file");
1670 ERR_print_errors(bio_err);
1673 if (s_dchain_file) {
1674 s_dchain = load_certs(bio_err, s_dchain_file, FORMAT_PEM,
1675 NULL, e, "second server certificate chain");
1682 if (!app_RAND_load_file(NULL, bio_err, 1) && inrand == NULL
1683 && !RAND_status()) {
1685 "warning, not much extra random data, consider using the -rand option\n");
1688 BIO_printf(bio_err, "%ld semi-random bytes loaded\n",
1689 app_RAND_load_files(inrand));
1691 if (bio_s_out == NULL) {
1692 if (s_quiet && !s_debug) {
1693 bio_s_out = BIO_new(BIO_s_null());
1694 if (s_msg && !bio_s_msg)
1695 bio_s_msg = BIO_new_fp(stdout, BIO_NOCLOSE);
1697 if (bio_s_out == NULL)
1698 bio_s_out = BIO_new_fp(stdout, BIO_NOCLOSE);
1701 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_ECDSA)
1707 s_dcert_file = NULL;
1709 #ifndef OPENSSL_NO_TLSEXT
1710 s_cert_file2 = NULL;
1715 ctx = SSL_CTX_new(meth);
1717 ERR_print_errors(bio_err);
1720 if (session_id_prefix) {
1721 if (strlen(session_id_prefix) >= 32)
1723 "warning: id_prefix is too long, only one new session will be possible\n");
1724 else if (strlen(session_id_prefix) >= 16)
1726 "warning: id_prefix is too long if you use SSLv2\n");
1727 if (!SSL_CTX_set_generate_session_id(ctx, generate_session_id)) {
1728 BIO_printf(bio_err, "error setting 'id_prefix'\n");
1729 ERR_print_errors(bio_err);
1732 BIO_printf(bio_err, "id_prefix '%s' set.\n", session_id_prefix);
1734 SSL_CTX_set_quiet_shutdown(ctx, 1);
1736 SSL_CTX_set_options(ctx, SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG);
1738 ssl_ctx_set_excert(ctx, exc);
1741 SSL_CTX_set_info_callback(ctx, apps_ssl_info_callback);
1743 SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
1745 init_session_cache_ctx(ctx);
1747 SSL_CTX_sess_set_cache_size(ctx, 128);
1749 #ifndef OPENSSL_NO_SRTP
1750 if (srtp_profiles != NULL)
1751 SSL_CTX_set_tlsext_use_srtp(ctx, srtp_profiles);
1756 cipher = getenv("SSL_CIPHER");
1760 if (s_cert_file == NULL) {
1762 "You must specify a certificate file for the server to use\n");
1767 if ((!SSL_CTX_load_verify_locations(ctx, CAfile, CApath)) ||
1768 (!SSL_CTX_set_default_verify_paths(ctx))) {
1769 /* BIO_printf(bio_err,"X509_load_verify_locations\n"); */
1770 ERR_print_errors(bio_err);
1774 SSL_CTX_set1_param(ctx, vpm);
1776 ssl_ctx_add_crls(ctx, crls, 0);
1778 if (!args_ssl_call(ctx, bio_err, cctx, ssl_args, no_ecdhe, no_jpake))
1781 if (!ssl_load_stores(ctx, vfyCApath, vfyCAfile, chCApath, chCAfile,
1782 crls, crl_download)) {
1783 BIO_printf(bio_err, "Error loading store locations\n");
1784 ERR_print_errors(bio_err);
1787 #ifndef OPENSSL_NO_TLSEXT
1789 ctx2 = SSL_CTX_new(meth);
1791 ERR_print_errors(bio_err);
1797 BIO_printf(bio_s_out, "Setting secondary ctx parameters\n");
1799 if (session_id_prefix) {
1800 if (strlen(session_id_prefix) >= 32)
1802 "warning: id_prefix is too long, only one new session will be possible\n");
1803 else if (strlen(session_id_prefix) >= 16)
1805 "warning: id_prefix is too long if you use SSLv2\n");
1806 if (!SSL_CTX_set_generate_session_id(ctx2, generate_session_id)) {
1807 BIO_printf(bio_err, "error setting 'id_prefix'\n");
1808 ERR_print_errors(bio_err);
1811 BIO_printf(bio_err, "id_prefix '%s' set.\n", session_id_prefix);
1813 SSL_CTX_set_quiet_shutdown(ctx2, 1);
1815 SSL_CTX_set_options(ctx2, SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG);
1817 ssl_ctx_set_excert(ctx2, exc);
1820 SSL_CTX_set_info_callback(ctx2, apps_ssl_info_callback);
1823 SSL_CTX_set_session_cache_mode(ctx2, SSL_SESS_CACHE_OFF);
1825 init_session_cache_ctx(ctx2);
1827 SSL_CTX_sess_set_cache_size(ctx2, 128);
1829 if ((!SSL_CTX_load_verify_locations(ctx2, CAfile, CApath)) ||
1830 (!SSL_CTX_set_default_verify_paths(ctx2))) {
1831 ERR_print_errors(bio_err);
1834 SSL_CTX_set1_param(ctx2, vpm);
1836 ssl_ctx_add_crls(ctx2, crls, 0);
1838 if (!args_ssl_call(ctx2, bio_err, cctx, ssl_args, no_ecdhe, no_jpake))
1842 # ifndef OPENSSL_NO_NEXTPROTONEG
1843 if (next_proto.data)
1844 SSL_CTX_set_next_protos_advertised_cb(ctx, next_proto_cb,
1848 SSL_CTX_set_alpn_select_cb(ctx, alpn_cb, &alpn_ctx);
1851 #ifndef OPENSSL_NO_DH
1856 dh = load_dh_param(dhfile);
1857 else if (s_cert_file)
1858 dh = load_dh_param(s_cert_file);
1861 BIO_printf(bio_s_out, "Setting temp DH parameters\n");
1863 BIO_printf(bio_s_out, "Using default temp DH parameters\n");
1866 (void)BIO_flush(bio_s_out);
1868 SSL_CTX_set_tmp_dh(ctx, dh);
1869 # ifndef OPENSSL_NO_TLSEXT
1872 DH *dh2 = load_dh_param(s_cert_file2);
1874 BIO_printf(bio_s_out, "Setting temp DH parameters\n");
1875 (void)BIO_flush(bio_s_out);
1881 SSL_CTX_set_tmp_dh(ctx2, dh);
1888 if (!set_cert_key_stuff(ctx, s_cert, s_key, s_chain, build_chain))
1890 #ifndef OPENSSL_NO_TLSEXT
1891 if (s_serverinfo_file != NULL
1892 && !SSL_CTX_use_serverinfo_file(ctx, s_serverinfo_file)) {
1893 ERR_print_errors(bio_err);
1897 #ifndef OPENSSL_NO_TLSEXT
1898 if (ctx2 && !set_cert_key_stuff(ctx2, s_cert2, s_key2, NULL, build_chain))
1901 if (s_dcert != NULL) {
1902 if (!set_cert_key_stuff(ctx, s_dcert, s_dkey, s_dchain, build_chain))
1905 #ifndef OPENSSL_NO_RSA
1908 SSL_CTX_set_tmp_rsa_callback(ctx, tmp_rsa_cb);
1909 # ifndef OPENSSL_NO_TLSEXT
1911 SSL_CTX_set_tmp_rsa_callback(ctx2, tmp_rsa_cb);
1915 if (!no_tmp_rsa && SSL_CTX_need_tmp_RSA(ctx)) {
1918 BIO_printf(bio_s_out, "Generating temp (512 bit) RSA key...");
1919 BIO_flush(bio_s_out);
1921 rsa = RSA_generate_key(512, RSA_F4, NULL);
1923 if (!SSL_CTX_set_tmp_rsa(ctx, rsa)) {
1924 ERR_print_errors(bio_err);
1927 # ifndef OPENSSL_NO_TLSEXT
1929 if (!SSL_CTX_set_tmp_rsa(ctx2, rsa)) {
1930 ERR_print_errors(bio_err);
1936 BIO_printf(bio_s_out, "\n");
1941 #ifndef OPENSSL_NO_PSK
1942 # ifdef OPENSSL_NO_JPAKE
1943 if (psk_key != NULL)
1945 if (psk_key != NULL || jpake_secret)
1949 BIO_printf(bio_s_out,
1950 "PSK key given or JPAKE in use, setting server callback\n");
1951 SSL_CTX_set_psk_server_callback(ctx, psk_server_cb);
1954 if (!SSL_CTX_use_psk_identity_hint(ctx, psk_identity_hint)) {
1955 BIO_printf(bio_err, "error setting PSK identity hint to context\n");
1956 ERR_print_errors(bio_err);
1961 SSL_CTX_set_verify(ctx, s_server_verify, verify_callback);
1962 SSL_CTX_set_session_id_context(ctx, (void *)&s_server_session_id_context,
1963 sizeof s_server_session_id_context);
1965 /* Set DTLS cookie generation and verification callbacks */
1966 SSL_CTX_set_cookie_generate_cb(ctx, generate_cookie_callback);
1967 SSL_CTX_set_cookie_verify_cb(ctx, verify_cookie_callback);
1969 #ifndef OPENSSL_NO_TLSEXT
1971 SSL_CTX_set_verify(ctx2, s_server_verify, verify_callback);
1972 SSL_CTX_set_session_id_context(ctx2,
1973 (void *)&s_server_session_id_context,
1974 sizeof s_server_session_id_context);
1976 tlsextcbp.biodebug = bio_s_out;
1977 SSL_CTX_set_tlsext_servername_callback(ctx2, ssl_servername_cb);
1978 SSL_CTX_set_tlsext_servername_arg(ctx2, &tlsextcbp);
1979 SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
1980 SSL_CTX_set_tlsext_servername_arg(ctx, &tlsextcbp);
1984 #ifndef OPENSSL_NO_SRP
1985 if (srp_verifier_file != NULL) {
1986 srp_callback_parm.vb = SRP_VBASE_new(srpuserseed);
1987 srp_callback_parm.user = NULL;
1988 srp_callback_parm.login = NULL;
1990 SRP_VBASE_init(srp_callback_parm.vb,
1991 srp_verifier_file)) != SRP_NO_ERROR) {
1993 "Cannot initialize SRP verifier file \"%s\":ret=%d\n",
1994 srp_verifier_file, ret);
1997 SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, verify_callback);
1998 SSL_CTX_set_srp_cb_arg(ctx, &srp_callback_parm);
1999 SSL_CTX_set_srp_username_callback(ctx, ssl_srp_server_param_cb);
2002 if (CAfile != NULL) {
2003 SSL_CTX_set_client_CA_list(ctx, SSL_load_client_CA_file(CAfile));
2004 #ifndef OPENSSL_NO_TLSEXT
2006 SSL_CTX_set_client_CA_list(ctx2, SSL_load_client_CA_file(CAfile));
2010 BIO_printf(bio_s_out, "ACCEPT\n");
2011 (void)BIO_flush(bio_s_out);
2013 do_server(port, socket_type, &accept_socket, rev_body, context,
2016 do_server(port, socket_type, &accept_socket, www_body, context,
2019 do_server(port, socket_type, &accept_socket, sv_body, context,
2021 print_stats(bio_s_out, ctx);
2029 sk_X509_CRL_pop_free(crls, X509_CRL_free);
2033 EVP_PKEY_free(s_key);
2035 EVP_PKEY_free(s_dkey);
2037 sk_X509_pop_free(s_chain, X509_free);
2039 sk_X509_pop_free(s_dchain, X509_free);
2043 OPENSSL_free(dpass);
2045 X509_VERIFY_PARAM_free(vpm);
2047 #ifndef OPENSSL_NO_TLSEXT
2049 OPENSSL_free(tlscstatp.host);
2051 OPENSSL_free(tlscstatp.port);
2053 OPENSSL_free(tlscstatp.path);
2059 EVP_PKEY_free(s_key2);
2060 if (serverinfo_in != NULL)
2061 BIO_free(serverinfo_in);
2062 # ifndef OPENSSL_NO_NEXTPROTONEG
2063 if (next_proto.data)
2064 OPENSSL_free(next_proto.data);
2067 OPENSSL_free(alpn_ctx.data);
2069 ssl_excert_free(exc);
2071 sk_OPENSSL_STRING_free(ssl_args);
2073 SSL_CONF_CTX_free(cctx);
2074 #ifndef OPENSSL_NO_JPAKE
2075 if (jpake_secret && psk_key)
2076 OPENSSL_free(psk_key);
2078 if (bio_s_out != NULL) {
2079 BIO_free(bio_s_out);
2082 if (bio_s_msg != NULL) {
2083 BIO_free(bio_s_msg);
2090 static void print_stats(BIO *bio, SSL_CTX *ssl_ctx)
2092 BIO_printf(bio, "%4ld items in the session cache\n",
2093 SSL_CTX_sess_number(ssl_ctx));
2094 BIO_printf(bio, "%4ld client connects (SSL_connect())\n",
2095 SSL_CTX_sess_connect(ssl_ctx));
2096 BIO_printf(bio, "%4ld client renegotiates (SSL_connect())\n",
2097 SSL_CTX_sess_connect_renegotiate(ssl_ctx));
2098 BIO_printf(bio, "%4ld client connects that finished\n",
2099 SSL_CTX_sess_connect_good(ssl_ctx));
2100 BIO_printf(bio, "%4ld server accepts (SSL_accept())\n",
2101 SSL_CTX_sess_accept(ssl_ctx));
2102 BIO_printf(bio, "%4ld server renegotiates (SSL_accept())\n",
2103 SSL_CTX_sess_accept_renegotiate(ssl_ctx));
2104 BIO_printf(bio, "%4ld server accepts that finished\n",
2105 SSL_CTX_sess_accept_good(ssl_ctx));
2106 BIO_printf(bio, "%4ld session cache hits\n", SSL_CTX_sess_hits(ssl_ctx));
2107 BIO_printf(bio, "%4ld session cache misses\n",
2108 SSL_CTX_sess_misses(ssl_ctx));
2109 BIO_printf(bio, "%4ld session cache timeouts\n",
2110 SSL_CTX_sess_timeouts(ssl_ctx));
2111 BIO_printf(bio, "%4ld callback cache hits\n",
2112 SSL_CTX_sess_cb_hits(ssl_ctx));
2113 BIO_printf(bio, "%4ld cache full overflows (%ld allowed)\n",
2114 SSL_CTX_sess_cache_full(ssl_ctx),
2115 SSL_CTX_sess_get_cache_size(ssl_ctx));
2118 static int sv_body(char *hostname, int s, int stype, unsigned char *context)
2127 #ifndef OPENSSL_NO_KRB5
2130 struct timeval timeout;
2131 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE) || defined(OPENSSL_SYS_BEOS_R5)
2134 struct timeval *timeoutp;
2137 if ((buf = OPENSSL_malloc(bufsize)) == NULL) {
2138 BIO_printf(bio_err, "out of memory\n");
2143 unsigned long sl = 1;
2146 BIO_printf(bio_err, "turning on non blocking io\n");
2147 if (BIO_socket_ioctl(s, FIONBIO, &sl) < 0)
2148 ERR_print_errors(bio_err);
2154 #ifndef OPENSSL_NO_TLSEXT
2155 if (s_tlsextdebug) {
2156 SSL_set_tlsext_debug_callback(con, tlsext_cb);
2157 SSL_set_tlsext_debug_arg(con, bio_s_out);
2159 if (s_tlsextstatus) {
2160 SSL_CTX_set_tlsext_status_cb(ctx, cert_status_cb);
2161 tlscstatp.err = bio_err;
2162 SSL_CTX_set_tlsext_status_arg(ctx, &tlscstatp);
2165 #ifndef OPENSSL_NO_KRB5
2166 if ((kctx = kssl_ctx_new()) != NULL) {
2167 SSL_set0_kssl_ctx(con, kctx);
2168 kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
2169 kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
2171 #endif /* OPENSSL_NO_KRB5 */
2173 SSL_set_session_id_context(con, context, strlen((char *)context));
2177 # ifdef TLSEXT_TYPE_opaque_prf_input
2178 SSL_set_tlsext_opaque_prf_input(con, "Test server", 11);
2182 if (stype == SOCK_DGRAM) {
2184 sbio = BIO_new_dgram(s, BIO_NOCLOSE);
2186 if (enable_timeouts) {
2188 timeout.tv_usec = DGRAM_RCV_TIMEOUT;
2189 BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout);
2192 timeout.tv_usec = DGRAM_SND_TIMEOUT;
2193 BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_SEND_TIMEOUT, 0, &timeout);
2197 if (socket_mtu < DTLS_get_link_min_mtu(con)) {
2198 BIO_printf(bio_err, "MTU too small. Must be at least %ld\n",
2199 DTLS_get_link_min_mtu(con));
2204 SSL_set_options(con, SSL_OP_NO_QUERY_MTU);
2205 if (!DTLS_set_link_mtu(con, socket_mtu)) {
2206 BIO_printf(bio_err, "Failed to set MTU\n");
2212 /* want to do MTU discovery */
2213 BIO_ctrl(sbio, BIO_CTRL_DGRAM_MTU_DISCOVER, 0, NULL);
2215 /* turn on cookie exchange */
2216 SSL_set_options(con, SSL_OP_COOKIE_EXCHANGE);
2218 sbio = BIO_new_socket(s, BIO_NOCLOSE);
2223 test = BIO_new(BIO_f_nbio_test());
2224 sbio = BIO_push(test, sbio);
2226 #ifndef OPENSSL_NO_JPAKE
2228 jpake_server_auth(bio_s_out, sbio, jpake_secret);
2231 SSL_set_bio(con, sbio, sbio);
2232 SSL_set_accept_state(con);
2233 /* SSL_set_fd(con,s); */
2236 SSL_set_debug(con, 1);
2237 BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
2238 BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
2241 #ifndef OPENSSL_NO_SSL_TRACE
2243 SSL_set_msg_callback(con, SSL_trace);
2246 SSL_set_msg_callback(con, msg_cb);
2247 SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
2249 #ifndef OPENSSL_NO_TLSEXT
2250 if (s_tlsextdebug) {
2251 SSL_set_tlsext_debug_callback(con, tlsext_cb);
2252 SSL_set_tlsext_debug_arg(con, bio_s_out);
2258 int read_from_terminal;
2259 int read_from_sslcon;
2261 read_from_terminal = 0;
2262 read_from_sslcon = SSL_pending(con);
2264 if (!read_from_sslcon) {
2266 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_NETWARE) && !defined(OPENSSL_SYS_BEOS_R5)
2267 openssl_fdset(fileno(stdin), &readfds);
2269 openssl_fdset(s, &readfds);
2271 * Note: under VMS with SOCKETSHR the second parameter is
2272 * currently of type (int *) whereas under other systems it is
2273 * (void *) if you don't have a cast it will choke the compiler:
2274 * if you do have a cast then you can either go for (int *) or
2277 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE)
2279 * Under DOS (non-djgpp) and Windows we can't select on stdin:
2280 * only on sockets. As a workaround we timeout the select every
2281 * second and check for any keypress. In a proper Windows
2282 * application we wouldn't do this because it is inefficient.
2286 i = select(width, (void *)&readfds, NULL, NULL, &tv);
2287 if ((i < 0) || (!i && !_kbhit()))
2290 read_from_terminal = 1;
2291 #elif defined(OPENSSL_SYS_BEOS_R5)
2292 /* Under BeOS-R5 the situation is similar to DOS */
2295 (void)fcntl(fileno(stdin), F_SETFL, O_NONBLOCK);
2296 i = select(width, (void *)&readfds, NULL, NULL, &tv);
2297 if ((i < 0) || (!i && read(fileno(stdin), buf, 0) < 0))
2299 if (read(fileno(stdin), buf, 0) >= 0)
2300 read_from_terminal = 1;
2301 (void)fcntl(fileno(stdin), F_SETFL, 0);
2303 if ((SSL_version(con) == DTLS1_VERSION) &&
2304 DTLSv1_get_timeout(con, &timeout))
2305 timeoutp = &timeout;
2309 i = select(width, (void *)&readfds, NULL, NULL, timeoutp);
2311 if ((SSL_version(con) == DTLS1_VERSION)
2312 && DTLSv1_handle_timeout(con) > 0) {
2313 BIO_printf(bio_err, "TIMEOUT occured\n");
2318 if (FD_ISSET(fileno(stdin), &readfds))
2319 read_from_terminal = 1;
2321 if (FD_ISSET(s, &readfds))
2322 read_from_sslcon = 1;
2324 if (read_from_terminal) {
2328 i = raw_read_stdin(buf, bufsize / 2);
2330 /* both loops are skipped when i <= 0 */
2331 for (j = 0; j < i; j++)
2334 for (j = i - 1; j >= 0; j--) {
2335 buf[j + lf_num] = buf[j];
2336 if (buf[j] == '\n') {
2339 buf[j + lf_num] = '\r';
2342 assert(lf_num == 0);
2344 i = raw_read_stdin(buf, bufsize);
2345 if (!s_quiet && !s_brief) {
2346 if ((i <= 0) || (buf[0] == 'Q')) {
2347 BIO_printf(bio_s_out, "DONE\n");
2349 close_accept_socket();
2353 if ((i <= 0) || (buf[0] == 'q')) {
2354 BIO_printf(bio_s_out, "DONE\n");
2355 if (SSL_version(con) != DTLS1_VERSION)
2358 * close_accept_socket(); ret= -11;
2362 #ifndef OPENSSL_NO_HEARTBEATS
2363 if ((buf[0] == 'B') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2364 BIO_printf(bio_err, "HEARTBEATING\n");
2370 if ((buf[0] == 'r') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2371 SSL_renegotiate(con);
2372 i = SSL_do_handshake(con);
2373 printf("SSL_do_handshake -> %d\n", i);
2377 * strcpy(buf,"server side RE-NEGOTIATE\n");
2380 if ((buf[0] == 'R') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2382 SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE,
2384 SSL_renegotiate(con);
2385 i = SSL_do_handshake(con);
2386 printf("SSL_do_handshake -> %d\n", i);
2390 * strcpy(buf,"server side RE-NEGOTIATE asking for client
2394 if (buf[0] == 'P') {
2395 static const char *str = "Lets print some clear text\n";
2396 BIO_write(SSL_get_wbio(con), str, strlen(str));
2398 if (buf[0] == 'S') {
2399 print_stats(bio_s_out, SSL_get_SSL_CTX(con));
2402 #ifdef CHARSET_EBCDIC
2403 ebcdic2ascii(buf, buf, i);
2407 /* should do a select for the write */
2411 if (++count == 100) {
2413 SSL_renegotiate(con);
2417 k = SSL_write(con, &(buf[l]), (unsigned int)i);
2418 #ifndef OPENSSL_NO_SRP
2419 while (SSL_get_error(con, k) == SSL_ERROR_WANT_X509_LOOKUP) {
2420 BIO_printf(bio_s_out, "LOOKUP renego during write\n");
2421 srp_callback_parm.user =
2422 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2423 srp_callback_parm.login);
2424 if (srp_callback_parm.user)
2425 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2426 srp_callback_parm.user->info);
2428 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2429 k = SSL_write(con, &(buf[l]), (unsigned int)i);
2432 switch (SSL_get_error(con, k)) {
2433 case SSL_ERROR_NONE:
2435 case SSL_ERROR_WANT_WRITE:
2436 case SSL_ERROR_WANT_READ:
2437 case SSL_ERROR_WANT_X509_LOOKUP:
2438 BIO_printf(bio_s_out, "Write BLOCK\n");
2440 case SSL_ERROR_SYSCALL:
2442 BIO_printf(bio_s_out, "ERROR\n");
2443 ERR_print_errors(bio_err);
2447 case SSL_ERROR_ZERO_RETURN:
2448 BIO_printf(bio_s_out, "DONE\n");
2458 if (read_from_sslcon) {
2459 if (!SSL_is_init_finished(con)) {
2460 i = init_ssl_connection(con);
2465 } else if (i == 0) {
2471 i = SSL_read(con, (char *)buf, bufsize);
2472 #ifndef OPENSSL_NO_SRP
2473 while (SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2474 BIO_printf(bio_s_out, "LOOKUP renego during read\n");
2475 srp_callback_parm.user =
2476 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2477 srp_callback_parm.login);
2478 if (srp_callback_parm.user)
2479 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2480 srp_callback_parm.user->info);
2482 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2483 i = SSL_read(con, (char *)buf, bufsize);
2486 switch (SSL_get_error(con, i)) {
2487 case SSL_ERROR_NONE:
2488 #ifdef CHARSET_EBCDIC
2489 ascii2ebcdic(buf, buf, i);
2491 raw_write_stdout(buf, (unsigned int)i);
2492 if (SSL_pending(con))
2495 case SSL_ERROR_WANT_WRITE:
2496 case SSL_ERROR_WANT_READ:
2497 BIO_printf(bio_s_out, "Read BLOCK\n");
2499 case SSL_ERROR_SYSCALL:
2501 BIO_printf(bio_s_out, "ERROR\n");
2502 ERR_print_errors(bio_err);
2505 case SSL_ERROR_ZERO_RETURN:
2506 BIO_printf(bio_s_out, "DONE\n");
2515 BIO_printf(bio_s_out, "shutting down SSL\n");
2517 SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
2523 BIO_printf(bio_s_out, "CONNECTION CLOSED\n");
2525 OPENSSL_cleanse(buf, bufsize);
2529 BIO_printf(bio_s_out, "ACCEPT\n");
2533 static void close_accept_socket(void)
2535 BIO_printf(bio_err, "shutdown accept socket\n");
2536 if (accept_socket >= 0) {
2537 SHUTDOWN2(accept_socket);
2541 static int init_ssl_connection(SSL *con)
2547 MS_STATIC char buf[BUFSIZ];
2548 #ifndef OPENSSL_NO_KRB5
2551 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2552 const unsigned char *next_proto_neg;
2553 unsigned next_proto_neg_len;
2555 unsigned char *exportedkeymat;
2557 i = SSL_accept(con);
2558 #ifdef CERT_CB_TEST_RETRY
2560 while (i <= 0 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP
2561 && SSL_state(con) == SSL3_ST_SR_CLNT_HELLO_C) {
2563 "LOOKUP from certificate callback during accept\n");
2564 i = SSL_accept(con);
2568 #ifndef OPENSSL_NO_SRP
2569 while (i <= 0 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2570 BIO_printf(bio_s_out, "LOOKUP during accept %s\n",
2571 srp_callback_parm.login);
2572 srp_callback_parm.user =
2573 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2574 srp_callback_parm.login);
2575 if (srp_callback_parm.user)
2576 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2577 srp_callback_parm.user->info);
2579 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2580 i = SSL_accept(con);
2585 if (BIO_sock_should_retry(i)) {
2586 BIO_printf(bio_s_out, "DELAY\n");
2590 BIO_printf(bio_err, "ERROR\n");
2591 verify_error = SSL_get_verify_result(con);
2592 if (verify_error != X509_V_OK) {
2593 BIO_printf(bio_err, "verify error:%s\n",
2594 X509_verify_cert_error_string(verify_error));
2596 /* Always print any error messages */
2597 ERR_print_errors(bio_err);
2602 print_ssl_summary(bio_err, con);
2604 PEM_write_bio_SSL_SESSION(bio_s_out, SSL_get_session(con));
2606 peer = SSL_get_peer_certificate(con);
2608 BIO_printf(bio_s_out, "Client certificate\n");
2609 PEM_write_bio_X509(bio_s_out, peer);
2610 X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof buf);
2611 BIO_printf(bio_s_out, "subject=%s\n", buf);
2612 X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof buf);
2613 BIO_printf(bio_s_out, "issuer=%s\n", buf);
2617 if (SSL_get_shared_ciphers(con, buf, sizeof buf) != NULL)
2618 BIO_printf(bio_s_out, "Shared ciphers:%s\n", buf);
2619 str = SSL_CIPHER_get_name(SSL_get_current_cipher(con));
2620 ssl_print_sigalgs(bio_s_out, con);
2621 #ifndef OPENSSL_NO_EC
2622 ssl_print_point_formats(bio_s_out, con);
2623 ssl_print_curves(bio_s_out, con, 0);
2625 BIO_printf(bio_s_out, "CIPHER is %s\n", (str != NULL) ? str : "(NONE)");
2627 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2628 SSL_get0_next_proto_negotiated(con, &next_proto_neg, &next_proto_neg_len);
2629 if (next_proto_neg) {
2630 BIO_printf(bio_s_out, "NEXTPROTO is ");
2631 BIO_write(bio_s_out, next_proto_neg, next_proto_neg_len);
2632 BIO_printf(bio_s_out, "\n");
2635 #ifndef OPENSSL_NO_SRTP
2637 SRTP_PROTECTION_PROFILE *srtp_profile
2638 = SSL_get_selected_srtp_profile(con);
2641 BIO_printf(bio_s_out, "SRTP Extension negotiated, profile=%s\n",
2642 srtp_profile->name);
2645 if (SSL_cache_hit(con))
2646 BIO_printf(bio_s_out, "Reused session-id\n");
2647 if (SSL_ctrl(con, SSL_CTRL_GET_FLAGS, 0, NULL) &
2648 TLS1_FLAGS_TLS_PADDING_BUG)
2649 BIO_printf(bio_s_out, "Peer has incorrect TLSv1 block padding\n");
2650 #ifndef OPENSSL_NO_KRB5
2651 client_princ = kssl_ctx_get0_client_princ(SSL_get0_kssl_ctx(con));
2652 if (client_princ != NULL) {
2653 BIO_printf(bio_s_out, "Kerberos peer principal is %s\n",
2656 #endif /* OPENSSL_NO_KRB5 */
2657 BIO_printf(bio_s_out, "Secure Renegotiation IS%s supported\n",
2658 SSL_get_secure_renegotiation_support(con) ? "" : " NOT");
2659 if (keymatexportlabel != NULL) {
2660 BIO_printf(bio_s_out, "Keying material exporter:\n");
2661 BIO_printf(bio_s_out, " Label: '%s'\n", keymatexportlabel);
2662 BIO_printf(bio_s_out, " Length: %i bytes\n", keymatexportlen);
2663 exportedkeymat = OPENSSL_malloc(keymatexportlen);
2664 if (exportedkeymat != NULL) {
2665 if (!SSL_export_keying_material(con, exportedkeymat,
2668 strlen(keymatexportlabel),
2670 BIO_printf(bio_s_out, " Error\n");
2672 BIO_printf(bio_s_out, " Keying material: ");
2673 for (i = 0; i < keymatexportlen; i++)
2674 BIO_printf(bio_s_out, "%02X", exportedkeymat[i]);
2675 BIO_printf(bio_s_out, "\n");
2677 OPENSSL_free(exportedkeymat);
2684 #ifndef OPENSSL_NO_DH
2685 static DH *load_dh_param(const char *dhfile)
2690 if ((bio = BIO_new_file(dhfile, "r")) == NULL)
2692 ret = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
2699 #ifndef OPENSSL_NO_KRB5
2704 static int load_CA(SSL_CTX *ctx, char *file)
2709 if ((in = fopen(file, "r")) == NULL)
2713 if (PEM_read_X509(in, &x, NULL) == NULL)
2715 SSL_CTX_add_client_CA(ctx, x);
2724 static int www_body(char *hostname, int s, int stype, unsigned char *context)
2730 const SSL_CIPHER *c;
2731 BIO *io, *ssl_bio, *sbio;
2732 #ifndef OPENSSL_NO_KRB5
2736 buf = OPENSSL_malloc(bufsize);
2739 io = BIO_new(BIO_f_buffer());
2740 ssl_bio = BIO_new(BIO_f_ssl());
2741 if ((io == NULL) || (ssl_bio == NULL))
2746 unsigned long sl = 1;
2749 BIO_printf(bio_err, "turning on non blocking io\n");
2750 if (BIO_socket_ioctl(s, FIONBIO, &sl) < 0)
2751 ERR_print_errors(bio_err);
2755 /* lets make the output buffer a reasonable size */
2756 if (!BIO_set_write_buffer_size(io, bufsize))
2759 if ((con = SSL_new(ctx)) == NULL)
2761 #ifndef OPENSSL_NO_TLSEXT
2762 if (s_tlsextdebug) {
2763 SSL_set_tlsext_debug_callback(con, tlsext_cb);
2764 SSL_set_tlsext_debug_arg(con, bio_s_out);
2767 #ifndef OPENSSL_NO_KRB5
2768 if ((kctx = kssl_ctx_new()) != NULL) {
2769 kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
2770 kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
2772 #endif /* OPENSSL_NO_KRB5 */
2774 SSL_set_session_id_context(con, context, strlen((char *)context));
2776 sbio = BIO_new_socket(s, BIO_NOCLOSE);
2780 test = BIO_new(BIO_f_nbio_test());
2781 sbio = BIO_push(test, sbio);
2783 SSL_set_bio(con, sbio, sbio);
2784 SSL_set_accept_state(con);
2786 /* SSL_set_fd(con,s); */
2787 BIO_set_ssl(ssl_bio, con, BIO_CLOSE);
2788 BIO_push(io, ssl_bio);
2789 #ifdef CHARSET_EBCDIC
2790 io = BIO_push(BIO_new(BIO_f_ebcdic_filter()), io);
2794 SSL_set_debug(con, 1);
2795 BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
2796 BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
2799 #ifndef OPENSSL_NO_SSL_TRACE
2801 SSL_set_msg_callback(con, SSL_trace);
2804 SSL_set_msg_callback(con, msg_cb);
2805 SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
2810 i = SSL_accept(con);
2811 #ifndef OPENSSL_NO_SRP
2813 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2814 BIO_printf(bio_s_out, "LOOKUP during accept %s\n",
2815 srp_callback_parm.login);
2816 srp_callback_parm.user =
2817 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2818 srp_callback_parm.login);
2819 if (srp_callback_parm.user)
2820 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2821 srp_callback_parm.user->info);
2823 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2824 i = SSL_accept(con);
2827 switch (SSL_get_error(con, i)) {
2828 case SSL_ERROR_NONE:
2830 case SSL_ERROR_WANT_WRITE:
2831 case SSL_ERROR_WANT_READ:
2832 case SSL_ERROR_WANT_X509_LOOKUP:
2834 case SSL_ERROR_SYSCALL:
2836 case SSL_ERROR_ZERO_RETURN:
2842 SSL_renegotiate(con);
2843 SSL_write(con, NULL, 0);
2846 i = BIO_gets(io, buf, bufsize - 1);
2847 if (i < 0) { /* error */
2848 if (!BIO_should_retry(io)) {
2850 ERR_print_errors(bio_err);
2853 BIO_printf(bio_s_out, "read R BLOCK\n");
2854 #if defined(OPENSSL_SYS_NETWARE)
2856 #elif !defined(OPENSSL_SYS_MSDOS) && !defined(__DJGPP__)
2861 } else if (i == 0) { /* end of input */
2866 /* else we have data */
2867 if (((www == 1) && (strncmp("GET ", buf, 4) == 0)) ||
2868 ((www == 2) && (strncmp("GET /stats ", buf, 10) == 0))) {
2871 STACK_OF(SSL_CIPHER) *sk;
2872 static const char *space = " ";
2875 "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
2876 BIO_puts(io, "<HTML><BODY BGCOLOR=\"#ffffff\">\n");
2877 BIO_puts(io, "<pre>\n");
2878 /* BIO_puts(io,SSLeay_version(SSLEAY_VERSION));*/
2880 for (i = 0; i < local_argc; i++) {
2881 BIO_puts(io, local_argv[i]);
2882 BIO_write(io, " ", 1);
2887 "Secure Renegotiation IS%s supported\n",
2888 SSL_get_secure_renegotiation_support(con) ?
2892 * The following is evil and should not really be done
2894 BIO_printf(io, "Ciphers supported in s_server binary\n");
2895 sk = SSL_get_ciphers(con);
2896 j = sk_SSL_CIPHER_num(sk);
2897 for (i = 0; i < j; i++) {
2898 c = sk_SSL_CIPHER_value(sk, i);
2899 BIO_printf(io, "%-11s:%-25s",
2900 SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2901 if ((((i + 1) % 2) == 0) && (i + 1 != j))
2905 p = SSL_get_shared_ciphers(con, buf, bufsize);
2908 "---\nCiphers common between both SSL end points:\n");
2912 BIO_write(io, space, 26 - j);
2915 BIO_write(io, ((i % 3) ? " " : "\n"), 1);
2917 BIO_write(io, p, 1);
2924 ssl_print_sigalgs(io, con);
2925 #ifndef OPENSSL_NO_EC
2926 ssl_print_curves(io, con, 0);
2928 BIO_printf(io, (SSL_cache_hit(con)
2929 ? "---\nReused, " : "---\nNew, "));
2930 c = SSL_get_current_cipher(con);
2931 BIO_printf(io, "%s, Cipher is %s\n",
2932 SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2933 SSL_SESSION_print(io, SSL_get_session(con));
2934 BIO_printf(io, "---\n");
2935 print_stats(io, SSL_get_SSL_CTX(con));
2936 BIO_printf(io, "---\n");
2937 peer = SSL_get_peer_certificate(con);
2939 BIO_printf(io, "Client certificate\n");
2940 X509_print(io, peer);
2941 PEM_write_bio_X509(io, peer);
2943 BIO_puts(io, "no client certificate available\n");
2944 BIO_puts(io, "</BODY></HTML>\r\n\r\n");
2946 } else if ((www == 2 || www == 3)
2947 && (strncmp("GET /", buf, 5) == 0)) {
2950 static const char *text =
2951 "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n";
2957 for (e = p; *e != '\0'; e++) {
2963 dot = (e[0] == '.') ? 2 : 0;
2966 dot = (e[0] == '.') ? 3 : 0;
2969 dot = (e[0] == '/') ? -1 : 0;
2973 dot = (e[0] == '/') ? 1 : 0;
2975 dot = (dot == 3) || (dot == -1); /* filename contains ".."
2980 BIO_printf(io, "'%s' is an invalid file name\r\n", p);
2987 BIO_printf(io, "'%s' contains '..' reference\r\n", p);
2993 BIO_printf(io, "'%s' is an invalid path\r\n", p);
2997 /* append if a directory lookup */
2999 strcat(p, "index.html");
3002 /* if a directory, do the index thang */
3003 if (app_isdir(p) > 0) {
3004 #if 0 /* must check buffer size */
3005 strcat(p, "/index.html");
3008 BIO_printf(io, "'%s' is a directory\r\n", p);
3013 if ((file = BIO_new_file(p, "r")) == NULL) {
3015 BIO_printf(io, "Error opening '%s'\r\n", p);
3016 ERR_print_errors(io);
3021 BIO_printf(bio_err, "FILE:%s\n", p);
3025 if (((i > 5) && (strcmp(&(p[i - 5]), ".html") == 0)) ||
3026 ((i > 4) && (strcmp(&(p[i - 4]), ".php") == 0)) ||
3027 ((i > 4) && (strcmp(&(p[i - 4]), ".htm") == 0)))
3029 "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
3032 "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n");
3036 i = BIO_read(file, buf, bufsize);
3042 fprintf(stderr, "%d\n", i);
3043 if (total_bytes > 3 * 1024) {
3045 fprintf(stderr, "RENEGOTIATE\n");
3046 SSL_renegotiate(con);
3050 for (j = 0; j < i;) {
3054 if (++count == 13) {
3055 SSL_renegotiate(con);
3059 k = BIO_write(io, &(buf[j]), i - j);
3061 if (!BIO_should_retry(io))
3064 BIO_printf(bio_s_out, "rwrite W BLOCK\n");
3078 i = (int)BIO_flush(io);
3080 if (!BIO_should_retry(io))
3087 /* make sure we re-use sessions */
3088 SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
3090 /* This kills performance */
3092 * SSL_shutdown(con); A shutdown gets sent in the BIO_free_all(io)
3100 BIO_printf(bio_s_out, "ACCEPT\n");
3106 /* if (ssl_bio != NULL) BIO_free(ssl_bio);*/
3110 static int rev_body(char *hostname, int s, int stype, unsigned char *context)
3116 BIO *io, *ssl_bio, *sbio;
3117 #ifndef OPENSSL_NO_KRB5
3121 buf = OPENSSL_malloc(bufsize);
3124 io = BIO_new(BIO_f_buffer());
3125 ssl_bio = BIO_new(BIO_f_ssl());
3126 if ((io == NULL) || (ssl_bio == NULL))
3129 /* lets make the output buffer a reasonable size */
3130 if (!BIO_set_write_buffer_size(io, bufsize))
3133 if ((con = SSL_new(ctx)) == NULL)
3135 #ifndef OPENSSL_NO_TLSEXT
3136 if (s_tlsextdebug) {
3137 SSL_set_tlsext_debug_callback(con, tlsext_cb);
3138 SSL_set_tlsext_debug_arg(con, bio_s_out);
3141 #ifndef OPENSSL_NO_KRB5
3142 if ((kctx = kssl_ctx_new()) != NULL) {
3143 kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
3144 kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
3146 #endif /* OPENSSL_NO_KRB5 */
3148 SSL_set_session_id_context(con, context, strlen((char *)context));
3150 sbio = BIO_new_socket(s, BIO_NOCLOSE);
3151 SSL_set_bio(con, sbio, sbio);
3152 SSL_set_accept_state(con);
3154 BIO_set_ssl(ssl_bio, con, BIO_CLOSE);
3155 BIO_push(io, ssl_bio);
3156 #ifdef CHARSET_EBCDIC
3157 io = BIO_push(BIO_new(BIO_f_ebcdic_filter()), io);
3161 SSL_set_debug(con, 1);
3162 BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
3163 BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
3166 #ifndef OPENSSL_NO_SSL_TRACE
3168 SSL_set_msg_callback(con, SSL_trace);
3171 SSL_set_msg_callback(con, msg_cb);
3172 SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
3176 i = BIO_do_handshake(io);
3179 if (!BIO_should_retry(io)) {
3180 BIO_puts(bio_err, "CONNECTION FAILURE\n");
3181 ERR_print_errors(bio_err);
3185 BIO_printf(bio_err, "CONNECTION ESTABLISHED\n");
3186 print_ssl_summary(bio_err, con);
3189 i = BIO_gets(io, buf, bufsize - 1);
3190 if (i < 0) { /* error */
3191 if (!BIO_should_retry(io)) {
3193 ERR_print_errors(bio_err);
3196 BIO_printf(bio_s_out, "read R BLOCK\n");
3197 #if defined(OPENSSL_SYS_NETWARE)
3199 #elif !defined(OPENSSL_SYS_MSDOS) && !defined(__DJGPP__)
3204 } else if (i == 0) { /* end of input */
3206 BIO_printf(bio_err, "CONNECTION CLOSED\n");
3209 char *p = buf + i - 1;
3210 while (i && (*p == '\n' || *p == '\r')) {
3214 if (!s_ign_eof && i == 5 && !strncmp(buf, "CLOSE", 5)) {
3216 BIO_printf(bio_err, "CONNECTION CLOSED\n");
3219 BUF_reverse((unsigned char *)buf, NULL, i);
3221 BIO_write(io, buf, i + 1);
3226 if (!BIO_should_retry(io))
3232 /* make sure we re-use sessions */
3233 SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
3244 #ifndef OPENSSL_NO_RSA
3245 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
3248 static RSA *rsa_tmp = NULL;
3250 if (!rsa_tmp && ((bn = BN_new()) == NULL))
3251 BIO_printf(bio_err, "Allocation error in generating RSA key\n");
3252 if (!rsa_tmp && bn) {
3254 BIO_printf(bio_err, "Generating temp (%d bit) RSA key...",
3256 (void)BIO_flush(bio_err);
3258 if (!BN_set_word(bn, RSA_F4) || ((rsa_tmp = RSA_new()) == NULL) ||
3259 !RSA_generate_key_ex(rsa_tmp, keylength, bn, NULL)) {
3265 BIO_printf(bio_err, "\n");
3266 (void)BIO_flush(bio_err);
3274 #define MAX_SESSION_ID_ATTEMPTS 10
3275 static int generate_session_id(const SSL *ssl, unsigned char *id,
3276 unsigned int *id_len)
3278 unsigned int count = 0;
3280 RAND_pseudo_bytes(id, *id_len);
3282 * Prefix the session_id with the required prefix. NB: If our prefix
3283 * is too long, clip it - but there will be worse effects anyway, eg.
3284 * the server could only possibly create 1 session ID (ie. the
3285 * prefix!) so all future session negotiations will fail due to
3288 memcpy(id, session_id_prefix,
3289 (strlen(session_id_prefix) < *id_len) ?
3290 strlen(session_id_prefix) : *id_len);
3292 while (SSL_has_matching_session_id(ssl, id, *id_len) &&
3293 (++count < MAX_SESSION_ID_ATTEMPTS));
3294 if (count >= MAX_SESSION_ID_ATTEMPTS)
3300 * By default s_server uses an in-memory cache which caches SSL_SESSION
3301 * structures without any serialisation. This hides some bugs which only
3302 * become apparent in deployed servers. By implementing a basic external
3303 * session cache some issues can be debugged using s_server.
3306 typedef struct simple_ssl_session_st {
3311 struct simple_ssl_session_st *next;
3312 } simple_ssl_session;
3314 static simple_ssl_session *first = NULL;
3316 static int add_session(SSL *ssl, SSL_SESSION *session)
3318 simple_ssl_session *sess;
3321 sess = OPENSSL_malloc(sizeof(simple_ssl_session));
3323 SSL_SESSION_get_id(session, &sess->idlen);
3324 sess->derlen = i2d_SSL_SESSION(session, NULL);
3326 sess->id = BUF_memdup(SSL_SESSION_get_id(session, NULL), sess->idlen);
3328 sess->der = OPENSSL_malloc(sess->derlen);
3330 i2d_SSL_SESSION(session, &p);
3334 BIO_printf(bio_err, "New session added to external cache\n");
3338 static SSL_SESSION *get_session(SSL *ssl, unsigned char *id, int idlen,
3341 simple_ssl_session *sess;
3343 for (sess = first; sess; sess = sess->next) {
3344 if (idlen == (int)sess->idlen && !memcmp(sess->id, id, idlen)) {
3345 const unsigned char *p = sess->der;
3346 BIO_printf(bio_err, "Lookup session: cache hit\n");
3347 return d2i_SSL_SESSION(NULL, &p, sess->derlen);
3350 BIO_printf(bio_err, "Lookup session: cache miss\n");
3354 static void del_session(SSL_CTX *sctx, SSL_SESSION *session)
3356 simple_ssl_session *sess, *prev = NULL;
3357 const unsigned char *id;
3359 id = SSL_SESSION_get_id(session, &idlen);
3360 for (sess = first; sess; sess = sess->next) {
3361 if (idlen == sess->idlen && !memcmp(sess->id, id, idlen)) {
3363 prev->next = sess->next;
3366 OPENSSL_free(sess->id);
3367 OPENSSL_free(sess->der);
3375 static void init_session_cache_ctx(SSL_CTX *sctx)
3377 SSL_CTX_set_session_cache_mode(sctx,
3378 SSL_SESS_CACHE_NO_INTERNAL |
3379 SSL_SESS_CACHE_SERVER);
3380 SSL_CTX_sess_set_new_cb(sctx, add_session);
3381 SSL_CTX_sess_set_get_cb(sctx, get_session);
3382 SSL_CTX_sess_set_remove_cb(sctx, del_session);
3385 static void free_sessions(void)
3387 simple_ssl_session *sess, *tsess;
3388 for (sess = first; sess;) {
3389 OPENSSL_free(sess->id);
3390 OPENSSL_free(sess->der);
3393 OPENSSL_free(tsess);