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);
1740 * DTLS: partial reads end up discarding unread UDP bytes :-( Setting
1741 * read ahead solves this problem.
1743 if (socket_type == SOCK_DGRAM)
1744 SSL_CTX_set_read_ahead(ctx, 1);
1747 SSL_CTX_set_info_callback(ctx, apps_ssl_info_callback);
1749 SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
1751 init_session_cache_ctx(ctx);
1753 SSL_CTX_sess_set_cache_size(ctx, 128);
1755 #ifndef OPENSSL_NO_SRTP
1756 if (srtp_profiles != NULL)
1757 SSL_CTX_set_tlsext_use_srtp(ctx, srtp_profiles);
1762 cipher = getenv("SSL_CIPHER");
1766 if (s_cert_file == NULL) {
1768 "You must specify a certificate file for the server to use\n");
1773 if ((!SSL_CTX_load_verify_locations(ctx, CAfile, CApath)) ||
1774 (!SSL_CTX_set_default_verify_paths(ctx))) {
1775 /* BIO_printf(bio_err,"X509_load_verify_locations\n"); */
1776 ERR_print_errors(bio_err);
1780 SSL_CTX_set1_param(ctx, vpm);
1782 ssl_ctx_add_crls(ctx, crls, 0);
1784 if (!args_ssl_call(ctx, bio_err, cctx, ssl_args, no_ecdhe, no_jpake))
1787 if (!ssl_load_stores(ctx, vfyCApath, vfyCAfile, chCApath, chCAfile,
1788 crls, crl_download)) {
1789 BIO_printf(bio_err, "Error loading store locations\n");
1790 ERR_print_errors(bio_err);
1793 #ifndef OPENSSL_NO_TLSEXT
1795 ctx2 = SSL_CTX_new(meth);
1797 ERR_print_errors(bio_err);
1803 BIO_printf(bio_s_out, "Setting secondary ctx parameters\n");
1805 if (session_id_prefix) {
1806 if (strlen(session_id_prefix) >= 32)
1808 "warning: id_prefix is too long, only one new session will be possible\n");
1809 else if (strlen(session_id_prefix) >= 16)
1811 "warning: id_prefix is too long if you use SSLv2\n");
1812 if (!SSL_CTX_set_generate_session_id(ctx2, generate_session_id)) {
1813 BIO_printf(bio_err, "error setting 'id_prefix'\n");
1814 ERR_print_errors(bio_err);
1817 BIO_printf(bio_err, "id_prefix '%s' set.\n", session_id_prefix);
1819 SSL_CTX_set_quiet_shutdown(ctx2, 1);
1821 SSL_CTX_set_options(ctx2, SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG);
1823 ssl_ctx_set_excert(ctx2, exc);
1825 * DTLS: partial reads end up discarding unread UDP bytes :-(
1826 * Setting read ahead solves this problem.
1828 if (socket_type == SOCK_DGRAM)
1829 SSL_CTX_set_read_ahead(ctx2, 1);
1832 SSL_CTX_set_info_callback(ctx2, apps_ssl_info_callback);
1835 SSL_CTX_set_session_cache_mode(ctx2, SSL_SESS_CACHE_OFF);
1837 init_session_cache_ctx(ctx2);
1839 SSL_CTX_sess_set_cache_size(ctx2, 128);
1841 if ((!SSL_CTX_load_verify_locations(ctx2, CAfile, CApath)) ||
1842 (!SSL_CTX_set_default_verify_paths(ctx2))) {
1843 ERR_print_errors(bio_err);
1846 SSL_CTX_set1_param(ctx2, vpm);
1848 ssl_ctx_add_crls(ctx2, crls, 0);
1850 if (!args_ssl_call(ctx2, bio_err, cctx, ssl_args, no_ecdhe, no_jpake))
1854 # ifndef OPENSSL_NO_NEXTPROTONEG
1855 if (next_proto.data)
1856 SSL_CTX_set_next_protos_advertised_cb(ctx, next_proto_cb,
1860 SSL_CTX_set_alpn_select_cb(ctx, alpn_cb, &alpn_ctx);
1863 #ifndef OPENSSL_NO_DH
1868 dh = load_dh_param(dhfile);
1869 else if (s_cert_file)
1870 dh = load_dh_param(s_cert_file);
1873 BIO_printf(bio_s_out, "Setting temp DH parameters\n");
1875 BIO_printf(bio_s_out, "Using default temp DH parameters\n");
1878 (void)BIO_flush(bio_s_out);
1880 SSL_CTX_set_tmp_dh(ctx, dh);
1881 # ifndef OPENSSL_NO_TLSEXT
1884 DH *dh2 = load_dh_param(s_cert_file2);
1886 BIO_printf(bio_s_out, "Setting temp DH parameters\n");
1887 (void)BIO_flush(bio_s_out);
1893 SSL_CTX_set_tmp_dh(ctx2, dh);
1900 if (!set_cert_key_stuff(ctx, s_cert, s_key, s_chain, build_chain))
1902 #ifndef OPENSSL_NO_TLSEXT
1903 if (s_serverinfo_file != NULL
1904 && !SSL_CTX_use_serverinfo_file(ctx, s_serverinfo_file)) {
1905 ERR_print_errors(bio_err);
1909 #ifndef OPENSSL_NO_TLSEXT
1910 if (ctx2 && !set_cert_key_stuff(ctx2, s_cert2, s_key2, NULL, build_chain))
1913 if (s_dcert != NULL) {
1914 if (!set_cert_key_stuff(ctx, s_dcert, s_dkey, s_dchain, build_chain))
1917 #ifndef OPENSSL_NO_RSA
1920 SSL_CTX_set_tmp_rsa_callback(ctx, tmp_rsa_cb);
1921 # ifndef OPENSSL_NO_TLSEXT
1923 SSL_CTX_set_tmp_rsa_callback(ctx2, tmp_rsa_cb);
1927 if (!no_tmp_rsa && SSL_CTX_need_tmp_RSA(ctx)) {
1930 BIO_printf(bio_s_out, "Generating temp (512 bit) RSA key...");
1931 BIO_flush(bio_s_out);
1933 rsa = RSA_generate_key(512, RSA_F4, NULL);
1935 if (!SSL_CTX_set_tmp_rsa(ctx, rsa)) {
1936 ERR_print_errors(bio_err);
1939 # ifndef OPENSSL_NO_TLSEXT
1941 if (!SSL_CTX_set_tmp_rsa(ctx2, rsa)) {
1942 ERR_print_errors(bio_err);
1948 BIO_printf(bio_s_out, "\n");
1953 #ifndef OPENSSL_NO_PSK
1954 # ifdef OPENSSL_NO_JPAKE
1955 if (psk_key != NULL)
1957 if (psk_key != NULL || jpake_secret)
1961 BIO_printf(bio_s_out,
1962 "PSK key given or JPAKE in use, setting server callback\n");
1963 SSL_CTX_set_psk_server_callback(ctx, psk_server_cb);
1966 if (!SSL_CTX_use_psk_identity_hint(ctx, psk_identity_hint)) {
1967 BIO_printf(bio_err, "error setting PSK identity hint to context\n");
1968 ERR_print_errors(bio_err);
1973 SSL_CTX_set_verify(ctx, s_server_verify, verify_callback);
1974 SSL_CTX_set_session_id_context(ctx, (void *)&s_server_session_id_context,
1975 sizeof s_server_session_id_context);
1977 /* Set DTLS cookie generation and verification callbacks */
1978 SSL_CTX_set_cookie_generate_cb(ctx, generate_cookie_callback);
1979 SSL_CTX_set_cookie_verify_cb(ctx, verify_cookie_callback);
1981 #ifndef OPENSSL_NO_TLSEXT
1983 SSL_CTX_set_verify(ctx2, s_server_verify, verify_callback);
1984 SSL_CTX_set_session_id_context(ctx2,
1985 (void *)&s_server_session_id_context,
1986 sizeof s_server_session_id_context);
1988 tlsextcbp.biodebug = bio_s_out;
1989 SSL_CTX_set_tlsext_servername_callback(ctx2, ssl_servername_cb);
1990 SSL_CTX_set_tlsext_servername_arg(ctx2, &tlsextcbp);
1991 SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
1992 SSL_CTX_set_tlsext_servername_arg(ctx, &tlsextcbp);
1996 #ifndef OPENSSL_NO_SRP
1997 if (srp_verifier_file != NULL) {
1998 srp_callback_parm.vb = SRP_VBASE_new(srpuserseed);
1999 srp_callback_parm.user = NULL;
2000 srp_callback_parm.login = NULL;
2002 SRP_VBASE_init(srp_callback_parm.vb,
2003 srp_verifier_file)) != SRP_NO_ERROR) {
2005 "Cannot initialize SRP verifier file \"%s\":ret=%d\n",
2006 srp_verifier_file, ret);
2009 SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, verify_callback);
2010 SSL_CTX_set_srp_cb_arg(ctx, &srp_callback_parm);
2011 SSL_CTX_set_srp_username_callback(ctx, ssl_srp_server_param_cb);
2014 if (CAfile != NULL) {
2015 SSL_CTX_set_client_CA_list(ctx, SSL_load_client_CA_file(CAfile));
2016 #ifndef OPENSSL_NO_TLSEXT
2018 SSL_CTX_set_client_CA_list(ctx2, SSL_load_client_CA_file(CAfile));
2022 BIO_printf(bio_s_out, "ACCEPT\n");
2023 (void)BIO_flush(bio_s_out);
2025 do_server(port, socket_type, &accept_socket, rev_body, context,
2028 do_server(port, socket_type, &accept_socket, www_body, context,
2031 do_server(port, socket_type, &accept_socket, sv_body, context,
2033 print_stats(bio_s_out, ctx);
2041 sk_X509_CRL_pop_free(crls, X509_CRL_free);
2045 EVP_PKEY_free(s_key);
2047 EVP_PKEY_free(s_dkey);
2049 sk_X509_pop_free(s_chain, X509_free);
2051 sk_X509_pop_free(s_dchain, X509_free);
2055 OPENSSL_free(dpass);
2057 X509_VERIFY_PARAM_free(vpm);
2059 #ifndef OPENSSL_NO_TLSEXT
2061 OPENSSL_free(tlscstatp.host);
2063 OPENSSL_free(tlscstatp.port);
2065 OPENSSL_free(tlscstatp.path);
2071 EVP_PKEY_free(s_key2);
2072 if (serverinfo_in != NULL)
2073 BIO_free(serverinfo_in);
2074 # ifndef OPENSSL_NO_NEXTPROTONEG
2075 if (next_proto.data)
2076 OPENSSL_free(next_proto.data);
2079 OPENSSL_free(alpn_ctx.data);
2081 ssl_excert_free(exc);
2083 sk_OPENSSL_STRING_free(ssl_args);
2085 SSL_CONF_CTX_free(cctx);
2086 #ifndef OPENSSL_NO_JPAKE
2087 if (jpake_secret && psk_key)
2088 OPENSSL_free(psk_key);
2090 if (bio_s_out != NULL) {
2091 BIO_free(bio_s_out);
2094 if (bio_s_msg != NULL) {
2095 BIO_free(bio_s_msg);
2102 static void print_stats(BIO *bio, SSL_CTX *ssl_ctx)
2104 BIO_printf(bio, "%4ld items in the session cache\n",
2105 SSL_CTX_sess_number(ssl_ctx));
2106 BIO_printf(bio, "%4ld client connects (SSL_connect())\n",
2107 SSL_CTX_sess_connect(ssl_ctx));
2108 BIO_printf(bio, "%4ld client renegotiates (SSL_connect())\n",
2109 SSL_CTX_sess_connect_renegotiate(ssl_ctx));
2110 BIO_printf(bio, "%4ld client connects that finished\n",
2111 SSL_CTX_sess_connect_good(ssl_ctx));
2112 BIO_printf(bio, "%4ld server accepts (SSL_accept())\n",
2113 SSL_CTX_sess_accept(ssl_ctx));
2114 BIO_printf(bio, "%4ld server renegotiates (SSL_accept())\n",
2115 SSL_CTX_sess_accept_renegotiate(ssl_ctx));
2116 BIO_printf(bio, "%4ld server accepts that finished\n",
2117 SSL_CTX_sess_accept_good(ssl_ctx));
2118 BIO_printf(bio, "%4ld session cache hits\n", SSL_CTX_sess_hits(ssl_ctx));
2119 BIO_printf(bio, "%4ld session cache misses\n",
2120 SSL_CTX_sess_misses(ssl_ctx));
2121 BIO_printf(bio, "%4ld session cache timeouts\n",
2122 SSL_CTX_sess_timeouts(ssl_ctx));
2123 BIO_printf(bio, "%4ld callback cache hits\n",
2124 SSL_CTX_sess_cb_hits(ssl_ctx));
2125 BIO_printf(bio, "%4ld cache full overflows (%ld allowed)\n",
2126 SSL_CTX_sess_cache_full(ssl_ctx),
2127 SSL_CTX_sess_get_cache_size(ssl_ctx));
2130 static int sv_body(char *hostname, int s, int stype, unsigned char *context)
2139 #ifndef OPENSSL_NO_KRB5
2142 struct timeval timeout;
2143 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE) || defined(OPENSSL_SYS_BEOS_R5)
2146 struct timeval *timeoutp;
2149 if ((buf = OPENSSL_malloc(bufsize)) == NULL) {
2150 BIO_printf(bio_err, "out of memory\n");
2155 unsigned long sl = 1;
2158 BIO_printf(bio_err, "turning on non blocking io\n");
2159 if (BIO_socket_ioctl(s, FIONBIO, &sl) < 0)
2160 ERR_print_errors(bio_err);
2166 #ifndef OPENSSL_NO_TLSEXT
2167 if (s_tlsextdebug) {
2168 SSL_set_tlsext_debug_callback(con, tlsext_cb);
2169 SSL_set_tlsext_debug_arg(con, bio_s_out);
2171 if (s_tlsextstatus) {
2172 SSL_CTX_set_tlsext_status_cb(ctx, cert_status_cb);
2173 tlscstatp.err = bio_err;
2174 SSL_CTX_set_tlsext_status_arg(ctx, &tlscstatp);
2177 #ifndef OPENSSL_NO_KRB5
2178 if ((kctx = kssl_ctx_new()) != NULL) {
2179 SSL_set0_kssl_ctx(con, kctx);
2180 kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
2181 kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
2183 #endif /* OPENSSL_NO_KRB5 */
2185 SSL_set_session_id_context(con, context, strlen((char *)context));
2189 # ifdef TLSEXT_TYPE_opaque_prf_input
2190 SSL_set_tlsext_opaque_prf_input(con, "Test server", 11);
2194 if (stype == SOCK_DGRAM) {
2196 sbio = BIO_new_dgram(s, BIO_NOCLOSE);
2198 if (enable_timeouts) {
2200 timeout.tv_usec = DGRAM_RCV_TIMEOUT;
2201 BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout);
2204 timeout.tv_usec = DGRAM_SND_TIMEOUT;
2205 BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_SEND_TIMEOUT, 0, &timeout);
2209 if (socket_mtu < DTLS_get_link_min_mtu(con)) {
2210 BIO_printf(bio_err, "MTU too small. Must be at least %ld\n",
2211 DTLS_get_link_min_mtu(con));
2216 SSL_set_options(con, SSL_OP_NO_QUERY_MTU);
2217 if (!DTLS_set_link_mtu(con, socket_mtu)) {
2218 BIO_printf(bio_err, "Failed to set MTU\n");
2224 /* want to do MTU discovery */
2225 BIO_ctrl(sbio, BIO_CTRL_DGRAM_MTU_DISCOVER, 0, NULL);
2227 /* turn on cookie exchange */
2228 SSL_set_options(con, SSL_OP_COOKIE_EXCHANGE);
2230 sbio = BIO_new_socket(s, BIO_NOCLOSE);
2235 test = BIO_new(BIO_f_nbio_test());
2236 sbio = BIO_push(test, sbio);
2238 #ifndef OPENSSL_NO_JPAKE
2240 jpake_server_auth(bio_s_out, sbio, jpake_secret);
2243 SSL_set_bio(con, sbio, sbio);
2244 SSL_set_accept_state(con);
2245 /* SSL_set_fd(con,s); */
2248 SSL_set_debug(con, 1);
2249 BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
2250 BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
2253 #ifndef OPENSSL_NO_SSL_TRACE
2255 SSL_set_msg_callback(con, SSL_trace);
2258 SSL_set_msg_callback(con, msg_cb);
2259 SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
2261 #ifndef OPENSSL_NO_TLSEXT
2262 if (s_tlsextdebug) {
2263 SSL_set_tlsext_debug_callback(con, tlsext_cb);
2264 SSL_set_tlsext_debug_arg(con, bio_s_out);
2270 int read_from_terminal;
2271 int read_from_sslcon;
2273 read_from_terminal = 0;
2274 read_from_sslcon = SSL_pending(con);
2276 if (!read_from_sslcon) {
2278 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_NETWARE) && !defined(OPENSSL_SYS_BEOS_R5)
2279 openssl_fdset(fileno(stdin), &readfds);
2281 openssl_fdset(s, &readfds);
2283 * Note: under VMS with SOCKETSHR the second parameter is
2284 * currently of type (int *) whereas under other systems it is
2285 * (void *) if you don't have a cast it will choke the compiler:
2286 * if you do have a cast then you can either go for (int *) or
2289 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE)
2291 * Under DOS (non-djgpp) and Windows we can't select on stdin:
2292 * only on sockets. As a workaround we timeout the select every
2293 * second and check for any keypress. In a proper Windows
2294 * application we wouldn't do this because it is inefficient.
2298 i = select(width, (void *)&readfds, NULL, NULL, &tv);
2299 if ((i < 0) || (!i && !_kbhit()))
2302 read_from_terminal = 1;
2303 #elif defined(OPENSSL_SYS_BEOS_R5)
2304 /* Under BeOS-R5 the situation is similar to DOS */
2307 (void)fcntl(fileno(stdin), F_SETFL, O_NONBLOCK);
2308 i = select(width, (void *)&readfds, NULL, NULL, &tv);
2309 if ((i < 0) || (!i && read(fileno(stdin), buf, 0) < 0))
2311 if (read(fileno(stdin), buf, 0) >= 0)
2312 read_from_terminal = 1;
2313 (void)fcntl(fileno(stdin), F_SETFL, 0);
2315 if ((SSL_version(con) == DTLS1_VERSION) &&
2316 DTLSv1_get_timeout(con, &timeout))
2317 timeoutp = &timeout;
2321 i = select(width, (void *)&readfds, NULL, NULL, timeoutp);
2323 if ((SSL_version(con) == DTLS1_VERSION)
2324 && DTLSv1_handle_timeout(con) > 0) {
2325 BIO_printf(bio_err, "TIMEOUT occured\n");
2330 if (FD_ISSET(fileno(stdin), &readfds))
2331 read_from_terminal = 1;
2333 if (FD_ISSET(s, &readfds))
2334 read_from_sslcon = 1;
2336 if (read_from_terminal) {
2340 i = raw_read_stdin(buf, bufsize / 2);
2342 /* both loops are skipped when i <= 0 */
2343 for (j = 0; j < i; j++)
2346 for (j = i - 1; j >= 0; j--) {
2347 buf[j + lf_num] = buf[j];
2348 if (buf[j] == '\n') {
2351 buf[j + lf_num] = '\r';
2354 assert(lf_num == 0);
2356 i = raw_read_stdin(buf, bufsize);
2357 if (!s_quiet && !s_brief) {
2358 if ((i <= 0) || (buf[0] == 'Q')) {
2359 BIO_printf(bio_s_out, "DONE\n");
2361 close_accept_socket();
2365 if ((i <= 0) || (buf[0] == 'q')) {
2366 BIO_printf(bio_s_out, "DONE\n");
2367 if (SSL_version(con) != DTLS1_VERSION)
2370 * close_accept_socket(); ret= -11;
2374 #ifndef OPENSSL_NO_HEARTBEATS
2375 if ((buf[0] == 'B') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2376 BIO_printf(bio_err, "HEARTBEATING\n");
2382 if ((buf[0] == 'r') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2383 SSL_renegotiate(con);
2384 i = SSL_do_handshake(con);
2385 printf("SSL_do_handshake -> %d\n", i);
2389 * strcpy(buf,"server side RE-NEGOTIATE\n");
2392 if ((buf[0] == 'R') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2394 SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE,
2396 SSL_renegotiate(con);
2397 i = SSL_do_handshake(con);
2398 printf("SSL_do_handshake -> %d\n", i);
2402 * strcpy(buf,"server side RE-NEGOTIATE asking for client
2406 if (buf[0] == 'P') {
2407 static const char *str = "Lets print some clear text\n";
2408 BIO_write(SSL_get_wbio(con), str, strlen(str));
2410 if (buf[0] == 'S') {
2411 print_stats(bio_s_out, SSL_get_SSL_CTX(con));
2414 #ifdef CHARSET_EBCDIC
2415 ebcdic2ascii(buf, buf, i);
2419 /* should do a select for the write */
2423 if (++count == 100) {
2425 SSL_renegotiate(con);
2429 k = SSL_write(con, &(buf[l]), (unsigned int)i);
2430 #ifndef OPENSSL_NO_SRP
2431 while (SSL_get_error(con, k) == SSL_ERROR_WANT_X509_LOOKUP) {
2432 BIO_printf(bio_s_out, "LOOKUP renego during write\n");
2433 srp_callback_parm.user =
2434 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2435 srp_callback_parm.login);
2436 if (srp_callback_parm.user)
2437 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2438 srp_callback_parm.user->info);
2440 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2441 k = SSL_write(con, &(buf[l]), (unsigned int)i);
2444 switch (SSL_get_error(con, k)) {
2445 case SSL_ERROR_NONE:
2447 case SSL_ERROR_WANT_WRITE:
2448 case SSL_ERROR_WANT_READ:
2449 case SSL_ERROR_WANT_X509_LOOKUP:
2450 BIO_printf(bio_s_out, "Write BLOCK\n");
2452 case SSL_ERROR_SYSCALL:
2454 BIO_printf(bio_s_out, "ERROR\n");
2455 ERR_print_errors(bio_err);
2459 case SSL_ERROR_ZERO_RETURN:
2460 BIO_printf(bio_s_out, "DONE\n");
2470 if (read_from_sslcon) {
2471 if (!SSL_is_init_finished(con)) {
2472 i = init_ssl_connection(con);
2477 } else if (i == 0) {
2483 i = SSL_read(con, (char *)buf, bufsize);
2484 #ifndef OPENSSL_NO_SRP
2485 while (SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2486 BIO_printf(bio_s_out, "LOOKUP renego during read\n");
2487 srp_callback_parm.user =
2488 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2489 srp_callback_parm.login);
2490 if (srp_callback_parm.user)
2491 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2492 srp_callback_parm.user->info);
2494 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2495 i = SSL_read(con, (char *)buf, bufsize);
2498 switch (SSL_get_error(con, i)) {
2499 case SSL_ERROR_NONE:
2500 #ifdef CHARSET_EBCDIC
2501 ascii2ebcdic(buf, buf, i);
2503 raw_write_stdout(buf, (unsigned int)i);
2504 if (SSL_pending(con))
2507 case SSL_ERROR_WANT_WRITE:
2508 case SSL_ERROR_WANT_READ:
2509 BIO_printf(bio_s_out, "Read BLOCK\n");
2511 case SSL_ERROR_SYSCALL:
2513 BIO_printf(bio_s_out, "ERROR\n");
2514 ERR_print_errors(bio_err);
2517 case SSL_ERROR_ZERO_RETURN:
2518 BIO_printf(bio_s_out, "DONE\n");
2527 BIO_printf(bio_s_out, "shutting down SSL\n");
2529 SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
2535 BIO_printf(bio_s_out, "CONNECTION CLOSED\n");
2537 OPENSSL_cleanse(buf, bufsize);
2541 BIO_printf(bio_s_out, "ACCEPT\n");
2545 static void close_accept_socket(void)
2547 BIO_printf(bio_err, "shutdown accept socket\n");
2548 if (accept_socket >= 0) {
2549 SHUTDOWN2(accept_socket);
2553 static int init_ssl_connection(SSL *con)
2559 MS_STATIC char buf[BUFSIZ];
2560 #ifndef OPENSSL_NO_KRB5
2563 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2564 const unsigned char *next_proto_neg;
2565 unsigned next_proto_neg_len;
2567 unsigned char *exportedkeymat;
2569 i = SSL_accept(con);
2570 #ifdef CERT_CB_TEST_RETRY
2572 while (i <= 0 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP
2573 && SSL_state(con) == SSL3_ST_SR_CLNT_HELLO_C) {
2575 "LOOKUP from certificate callback during accept\n");
2576 i = SSL_accept(con);
2580 #ifndef OPENSSL_NO_SRP
2581 while (i <= 0 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2582 BIO_printf(bio_s_out, "LOOKUP during accept %s\n",
2583 srp_callback_parm.login);
2584 srp_callback_parm.user =
2585 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2586 srp_callback_parm.login);
2587 if (srp_callback_parm.user)
2588 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2589 srp_callback_parm.user->info);
2591 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2592 i = SSL_accept(con);
2597 if (BIO_sock_should_retry(i)) {
2598 BIO_printf(bio_s_out, "DELAY\n");
2602 BIO_printf(bio_err, "ERROR\n");
2603 verify_error = SSL_get_verify_result(con);
2604 if (verify_error != X509_V_OK) {
2605 BIO_printf(bio_err, "verify error:%s\n",
2606 X509_verify_cert_error_string(verify_error));
2608 /* Always print any error messages */
2609 ERR_print_errors(bio_err);
2614 print_ssl_summary(bio_err, con);
2616 PEM_write_bio_SSL_SESSION(bio_s_out, SSL_get_session(con));
2618 peer = SSL_get_peer_certificate(con);
2620 BIO_printf(bio_s_out, "Client certificate\n");
2621 PEM_write_bio_X509(bio_s_out, peer);
2622 X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof buf);
2623 BIO_printf(bio_s_out, "subject=%s\n", buf);
2624 X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof buf);
2625 BIO_printf(bio_s_out, "issuer=%s\n", buf);
2629 if (SSL_get_shared_ciphers(con, buf, sizeof buf) != NULL)
2630 BIO_printf(bio_s_out, "Shared ciphers:%s\n", buf);
2631 str = SSL_CIPHER_get_name(SSL_get_current_cipher(con));
2632 ssl_print_sigalgs(bio_s_out, con);
2633 #ifndef OPENSSL_NO_EC
2634 ssl_print_point_formats(bio_s_out, con);
2635 ssl_print_curves(bio_s_out, con, 0);
2637 BIO_printf(bio_s_out, "CIPHER is %s\n", (str != NULL) ? str : "(NONE)");
2639 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2640 SSL_get0_next_proto_negotiated(con, &next_proto_neg, &next_proto_neg_len);
2641 if (next_proto_neg) {
2642 BIO_printf(bio_s_out, "NEXTPROTO is ");
2643 BIO_write(bio_s_out, next_proto_neg, next_proto_neg_len);
2644 BIO_printf(bio_s_out, "\n");
2647 #ifndef OPENSSL_NO_SRTP
2649 SRTP_PROTECTION_PROFILE *srtp_profile
2650 = SSL_get_selected_srtp_profile(con);
2653 BIO_printf(bio_s_out, "SRTP Extension negotiated, profile=%s\n",
2654 srtp_profile->name);
2657 if (SSL_cache_hit(con))
2658 BIO_printf(bio_s_out, "Reused session-id\n");
2659 if (SSL_ctrl(con, SSL_CTRL_GET_FLAGS, 0, NULL) &
2660 TLS1_FLAGS_TLS_PADDING_BUG)
2661 BIO_printf(bio_s_out, "Peer has incorrect TLSv1 block padding\n");
2662 #ifndef OPENSSL_NO_KRB5
2663 client_princ = kssl_ctx_get0_client_princ(SSL_get0_kssl_ctx(con));
2664 if (client_princ != NULL) {
2665 BIO_printf(bio_s_out, "Kerberos peer principal is %s\n",
2668 #endif /* OPENSSL_NO_KRB5 */
2669 BIO_printf(bio_s_out, "Secure Renegotiation IS%s supported\n",
2670 SSL_get_secure_renegotiation_support(con) ? "" : " NOT");
2671 if (keymatexportlabel != NULL) {
2672 BIO_printf(bio_s_out, "Keying material exporter:\n");
2673 BIO_printf(bio_s_out, " Label: '%s'\n", keymatexportlabel);
2674 BIO_printf(bio_s_out, " Length: %i bytes\n", keymatexportlen);
2675 exportedkeymat = OPENSSL_malloc(keymatexportlen);
2676 if (exportedkeymat != NULL) {
2677 if (!SSL_export_keying_material(con, exportedkeymat,
2680 strlen(keymatexportlabel),
2682 BIO_printf(bio_s_out, " Error\n");
2684 BIO_printf(bio_s_out, " Keying material: ");
2685 for (i = 0; i < keymatexportlen; i++)
2686 BIO_printf(bio_s_out, "%02X", exportedkeymat[i]);
2687 BIO_printf(bio_s_out, "\n");
2689 OPENSSL_free(exportedkeymat);
2696 #ifndef OPENSSL_NO_DH
2697 static DH *load_dh_param(const char *dhfile)
2702 if ((bio = BIO_new_file(dhfile, "r")) == NULL)
2704 ret = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
2711 #ifndef OPENSSL_NO_KRB5
2716 static int load_CA(SSL_CTX *ctx, char *file)
2721 if ((in = fopen(file, "r")) == NULL)
2725 if (PEM_read_X509(in, &x, NULL) == NULL)
2727 SSL_CTX_add_client_CA(ctx, x);
2736 static int www_body(char *hostname, int s, int stype, unsigned char *context)
2742 const SSL_CIPHER *c;
2743 BIO *io, *ssl_bio, *sbio;
2744 #ifndef OPENSSL_NO_KRB5
2748 buf = OPENSSL_malloc(bufsize);
2751 io = BIO_new(BIO_f_buffer());
2752 ssl_bio = BIO_new(BIO_f_ssl());
2753 if ((io == NULL) || (ssl_bio == NULL))
2758 unsigned long sl = 1;
2761 BIO_printf(bio_err, "turning on non blocking io\n");
2762 if (BIO_socket_ioctl(s, FIONBIO, &sl) < 0)
2763 ERR_print_errors(bio_err);
2767 /* lets make the output buffer a reasonable size */
2768 if (!BIO_set_write_buffer_size(io, bufsize))
2771 if ((con = SSL_new(ctx)) == NULL)
2773 #ifndef OPENSSL_NO_TLSEXT
2774 if (s_tlsextdebug) {
2775 SSL_set_tlsext_debug_callback(con, tlsext_cb);
2776 SSL_set_tlsext_debug_arg(con, bio_s_out);
2779 #ifndef OPENSSL_NO_KRB5
2780 if ((kctx = kssl_ctx_new()) != NULL) {
2781 kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
2782 kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
2784 #endif /* OPENSSL_NO_KRB5 */
2786 SSL_set_session_id_context(con, context, strlen((char *)context));
2788 sbio = BIO_new_socket(s, BIO_NOCLOSE);
2792 test = BIO_new(BIO_f_nbio_test());
2793 sbio = BIO_push(test, sbio);
2795 SSL_set_bio(con, sbio, sbio);
2796 SSL_set_accept_state(con);
2798 /* SSL_set_fd(con,s); */
2799 BIO_set_ssl(ssl_bio, con, BIO_CLOSE);
2800 BIO_push(io, ssl_bio);
2801 #ifdef CHARSET_EBCDIC
2802 io = BIO_push(BIO_new(BIO_f_ebcdic_filter()), io);
2806 SSL_set_debug(con, 1);
2807 BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
2808 BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
2811 #ifndef OPENSSL_NO_SSL_TRACE
2813 SSL_set_msg_callback(con, SSL_trace);
2816 SSL_set_msg_callback(con, msg_cb);
2817 SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
2822 i = SSL_accept(con);
2823 #ifndef OPENSSL_NO_SRP
2825 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2826 BIO_printf(bio_s_out, "LOOKUP during accept %s\n",
2827 srp_callback_parm.login);
2828 srp_callback_parm.user =
2829 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2830 srp_callback_parm.login);
2831 if (srp_callback_parm.user)
2832 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2833 srp_callback_parm.user->info);
2835 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2836 i = SSL_accept(con);
2839 switch (SSL_get_error(con, i)) {
2840 case SSL_ERROR_NONE:
2842 case SSL_ERROR_WANT_WRITE:
2843 case SSL_ERROR_WANT_READ:
2844 case SSL_ERROR_WANT_X509_LOOKUP:
2846 case SSL_ERROR_SYSCALL:
2848 case SSL_ERROR_ZERO_RETURN:
2854 SSL_renegotiate(con);
2855 SSL_write(con, NULL, 0);
2858 i = BIO_gets(io, buf, bufsize - 1);
2859 if (i < 0) { /* error */
2860 if (!BIO_should_retry(io)) {
2862 ERR_print_errors(bio_err);
2865 BIO_printf(bio_s_out, "read R BLOCK\n");
2866 #if defined(OPENSSL_SYS_NETWARE)
2868 #elif !defined(OPENSSL_SYS_MSDOS) && !defined(__DJGPP__)
2873 } else if (i == 0) { /* end of input */
2878 /* else we have data */
2879 if (((www == 1) && (strncmp("GET ", buf, 4) == 0)) ||
2880 ((www == 2) && (strncmp("GET /stats ", buf, 10) == 0))) {
2883 STACK_OF(SSL_CIPHER) *sk;
2884 static const char *space = " ";
2887 "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
2888 BIO_puts(io, "<HTML><BODY BGCOLOR=\"#ffffff\">\n");
2889 BIO_puts(io, "<pre>\n");
2890 /* BIO_puts(io,SSLeay_version(SSLEAY_VERSION));*/
2892 for (i = 0; i < local_argc; i++) {
2893 BIO_puts(io, local_argv[i]);
2894 BIO_write(io, " ", 1);
2899 "Secure Renegotiation IS%s supported\n",
2900 SSL_get_secure_renegotiation_support(con) ?
2904 * The following is evil and should not really be done
2906 BIO_printf(io, "Ciphers supported in s_server binary\n");
2907 sk = SSL_get_ciphers(con);
2908 j = sk_SSL_CIPHER_num(sk);
2909 for (i = 0; i < j; i++) {
2910 c = sk_SSL_CIPHER_value(sk, i);
2911 BIO_printf(io, "%-11s:%-25s",
2912 SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2913 if ((((i + 1) % 2) == 0) && (i + 1 != j))
2917 p = SSL_get_shared_ciphers(con, buf, bufsize);
2920 "---\nCiphers common between both SSL end points:\n");
2924 BIO_write(io, space, 26 - j);
2927 BIO_write(io, ((i % 3) ? " " : "\n"), 1);
2929 BIO_write(io, p, 1);
2936 ssl_print_sigalgs(io, con);
2937 #ifndef OPENSSL_NO_EC
2938 ssl_print_curves(io, con, 0);
2940 BIO_printf(io, (SSL_cache_hit(con)
2941 ? "---\nReused, " : "---\nNew, "));
2942 c = SSL_get_current_cipher(con);
2943 BIO_printf(io, "%s, Cipher is %s\n",
2944 SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2945 SSL_SESSION_print(io, SSL_get_session(con));
2946 BIO_printf(io, "---\n");
2947 print_stats(io, SSL_get_SSL_CTX(con));
2948 BIO_printf(io, "---\n");
2949 peer = SSL_get_peer_certificate(con);
2951 BIO_printf(io, "Client certificate\n");
2952 X509_print(io, peer);
2953 PEM_write_bio_X509(io, peer);
2955 BIO_puts(io, "no client certificate available\n");
2956 BIO_puts(io, "</BODY></HTML>\r\n\r\n");
2958 } else if ((www == 2 || www == 3)
2959 && (strncmp("GET /", buf, 5) == 0)) {
2962 static const char *text =
2963 "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n";
2969 for (e = p; *e != '\0'; e++) {
2975 dot = (e[0] == '.') ? 2 : 0;
2978 dot = (e[0] == '.') ? 3 : 0;
2981 dot = (e[0] == '/') ? -1 : 0;
2985 dot = (e[0] == '/') ? 1 : 0;
2987 dot = (dot == 3) || (dot == -1); /* filename contains ".."
2992 BIO_printf(io, "'%s' is an invalid file name\r\n", p);
2999 BIO_printf(io, "'%s' contains '..' reference\r\n", p);
3005 BIO_printf(io, "'%s' is an invalid path\r\n", p);
3009 /* append if a directory lookup */
3011 strcat(p, "index.html");
3014 /* if a directory, do the index thang */
3015 if (app_isdir(p) > 0) {
3016 #if 0 /* must check buffer size */
3017 strcat(p, "/index.html");
3020 BIO_printf(io, "'%s' is a directory\r\n", p);
3025 if ((file = BIO_new_file(p, "r")) == NULL) {
3027 BIO_printf(io, "Error opening '%s'\r\n", p);
3028 ERR_print_errors(io);
3033 BIO_printf(bio_err, "FILE:%s\n", p);
3037 if (((i > 5) && (strcmp(&(p[i - 5]), ".html") == 0)) ||
3038 ((i > 4) && (strcmp(&(p[i - 4]), ".php") == 0)) ||
3039 ((i > 4) && (strcmp(&(p[i - 4]), ".htm") == 0)))
3041 "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
3044 "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n");
3048 i = BIO_read(file, buf, bufsize);
3054 fprintf(stderr, "%d\n", i);
3055 if (total_bytes > 3 * 1024) {
3057 fprintf(stderr, "RENEGOTIATE\n");
3058 SSL_renegotiate(con);
3062 for (j = 0; j < i;) {
3066 if (++count == 13) {
3067 SSL_renegotiate(con);
3071 k = BIO_write(io, &(buf[j]), i - j);
3073 if (!BIO_should_retry(io))
3076 BIO_printf(bio_s_out, "rwrite W BLOCK\n");
3090 i = (int)BIO_flush(io);
3092 if (!BIO_should_retry(io))
3099 /* make sure we re-use sessions */
3100 SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
3102 /* This kills performance */
3104 * SSL_shutdown(con); A shutdown gets sent in the BIO_free_all(io)
3112 BIO_printf(bio_s_out, "ACCEPT\n");
3118 /* if (ssl_bio != NULL) BIO_free(ssl_bio);*/
3122 static int rev_body(char *hostname, int s, int stype, unsigned char *context)
3128 BIO *io, *ssl_bio, *sbio;
3129 #ifndef OPENSSL_NO_KRB5
3133 buf = OPENSSL_malloc(bufsize);
3136 io = BIO_new(BIO_f_buffer());
3137 ssl_bio = BIO_new(BIO_f_ssl());
3138 if ((io == NULL) || (ssl_bio == NULL))
3141 /* lets make the output buffer a reasonable size */
3142 if (!BIO_set_write_buffer_size(io, bufsize))
3145 if ((con = SSL_new(ctx)) == NULL)
3147 #ifndef OPENSSL_NO_TLSEXT
3148 if (s_tlsextdebug) {
3149 SSL_set_tlsext_debug_callback(con, tlsext_cb);
3150 SSL_set_tlsext_debug_arg(con, bio_s_out);
3153 #ifndef OPENSSL_NO_KRB5
3154 if ((kctx = kssl_ctx_new()) != NULL) {
3155 kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
3156 kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
3158 #endif /* OPENSSL_NO_KRB5 */
3160 SSL_set_session_id_context(con, context, strlen((char *)context));
3162 sbio = BIO_new_socket(s, BIO_NOCLOSE);
3163 SSL_set_bio(con, sbio, sbio);
3164 SSL_set_accept_state(con);
3166 BIO_set_ssl(ssl_bio, con, BIO_CLOSE);
3167 BIO_push(io, ssl_bio);
3168 #ifdef CHARSET_EBCDIC
3169 io = BIO_push(BIO_new(BIO_f_ebcdic_filter()), io);
3173 SSL_set_debug(con, 1);
3174 BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
3175 BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
3178 #ifndef OPENSSL_NO_SSL_TRACE
3180 SSL_set_msg_callback(con, SSL_trace);
3183 SSL_set_msg_callback(con, msg_cb);
3184 SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
3188 i = BIO_do_handshake(io);
3191 if (!BIO_should_retry(io)) {
3192 BIO_puts(bio_err, "CONNECTION FAILURE\n");
3193 ERR_print_errors(bio_err);
3197 BIO_printf(bio_err, "CONNECTION ESTABLISHED\n");
3198 print_ssl_summary(bio_err, con);
3201 i = BIO_gets(io, buf, bufsize - 1);
3202 if (i < 0) { /* error */
3203 if (!BIO_should_retry(io)) {
3205 ERR_print_errors(bio_err);
3208 BIO_printf(bio_s_out, "read R BLOCK\n");
3209 #if defined(OPENSSL_SYS_NETWARE)
3211 #elif !defined(OPENSSL_SYS_MSDOS) && !defined(__DJGPP__)
3216 } else if (i == 0) { /* end of input */
3218 BIO_printf(bio_err, "CONNECTION CLOSED\n");
3221 char *p = buf + i - 1;
3222 while (i && (*p == '\n' || *p == '\r')) {
3226 if (!s_ign_eof && i == 5 && !strncmp(buf, "CLOSE", 5)) {
3228 BIO_printf(bio_err, "CONNECTION CLOSED\n");
3231 BUF_reverse((unsigned char *)buf, NULL, i);
3233 BIO_write(io, buf, i + 1);
3238 if (!BIO_should_retry(io))
3244 /* make sure we re-use sessions */
3245 SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
3256 #ifndef OPENSSL_NO_RSA
3257 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
3260 static RSA *rsa_tmp = NULL;
3262 if (!rsa_tmp && ((bn = BN_new()) == NULL))
3263 BIO_printf(bio_err, "Allocation error in generating RSA key\n");
3264 if (!rsa_tmp && bn) {
3266 BIO_printf(bio_err, "Generating temp (%d bit) RSA key...",
3268 (void)BIO_flush(bio_err);
3270 if (!BN_set_word(bn, RSA_F4) || ((rsa_tmp = RSA_new()) == NULL) ||
3271 !RSA_generate_key_ex(rsa_tmp, keylength, bn, NULL)) {
3277 BIO_printf(bio_err, "\n");
3278 (void)BIO_flush(bio_err);
3286 #define MAX_SESSION_ID_ATTEMPTS 10
3287 static int generate_session_id(const SSL *ssl, unsigned char *id,
3288 unsigned int *id_len)
3290 unsigned int count = 0;
3292 RAND_pseudo_bytes(id, *id_len);
3294 * Prefix the session_id with the required prefix. NB: If our prefix
3295 * is too long, clip it - but there will be worse effects anyway, eg.
3296 * the server could only possibly create 1 session ID (ie. the
3297 * prefix!) so all future session negotiations will fail due to
3300 memcpy(id, session_id_prefix,
3301 (strlen(session_id_prefix) < *id_len) ?
3302 strlen(session_id_prefix) : *id_len);
3304 while (SSL_has_matching_session_id(ssl, id, *id_len) &&
3305 (++count < MAX_SESSION_ID_ATTEMPTS));
3306 if (count >= MAX_SESSION_ID_ATTEMPTS)
3312 * By default s_server uses an in-memory cache which caches SSL_SESSION
3313 * structures without any serialisation. This hides some bugs which only
3314 * become apparent in deployed servers. By implementing a basic external
3315 * session cache some issues can be debugged using s_server.
3318 typedef struct simple_ssl_session_st {
3323 struct simple_ssl_session_st *next;
3324 } simple_ssl_session;
3326 static simple_ssl_session *first = NULL;
3328 static int add_session(SSL *ssl, SSL_SESSION *session)
3330 simple_ssl_session *sess;
3333 sess = OPENSSL_malloc(sizeof(simple_ssl_session));
3335 SSL_SESSION_get_id(session, &sess->idlen);
3336 sess->derlen = i2d_SSL_SESSION(session, NULL);
3338 sess->id = BUF_memdup(SSL_SESSION_get_id(session, NULL), sess->idlen);
3340 sess->der = OPENSSL_malloc(sess->derlen);
3342 i2d_SSL_SESSION(session, &p);
3346 BIO_printf(bio_err, "New session added to external cache\n");
3350 static SSL_SESSION *get_session(SSL *ssl, unsigned char *id, int idlen,
3353 simple_ssl_session *sess;
3355 for (sess = first; sess; sess = sess->next) {
3356 if (idlen == (int)sess->idlen && !memcmp(sess->id, id, idlen)) {
3357 const unsigned char *p = sess->der;
3358 BIO_printf(bio_err, "Lookup session: cache hit\n");
3359 return d2i_SSL_SESSION(NULL, &p, sess->derlen);
3362 BIO_printf(bio_err, "Lookup session: cache miss\n");
3366 static void del_session(SSL_CTX *sctx, SSL_SESSION *session)
3368 simple_ssl_session *sess, *prev = NULL;
3369 const unsigned char *id;
3371 id = SSL_SESSION_get_id(session, &idlen);
3372 for (sess = first; sess; sess = sess->next) {
3373 if (idlen == sess->idlen && !memcmp(sess->id, id, idlen)) {
3375 prev->next = sess->next;
3378 OPENSSL_free(sess->id);
3379 OPENSSL_free(sess->der);
3387 static void init_session_cache_ctx(SSL_CTX *sctx)
3389 SSL_CTX_set_session_cache_mode(sctx,
3390 SSL_SESS_CACHE_NO_INTERNAL |
3391 SSL_SESS_CACHE_SERVER);
3392 SSL_CTX_sess_set_new_cb(sctx, add_session);
3393 SSL_CTX_sess_set_get_cb(sctx, get_session);
3394 SSL_CTX_sess_set_remove_cb(sctx, del_session);
3397 static void free_sessions(void)
3399 simple_ssl_session *sess, *tsess;
3400 for (sess = first; sess;) {
3401 OPENSSL_free(sess->id);
3402 OPENSSL_free(sess->der);
3405 OPENSSL_free(tsess);