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);
701 wbuf->alloced = 1024;
702 wbuf->buff[0] = '\0';
704 bi->ptr = (char *)wbuf;
710 static int ebcdic_free(BIO *a)
715 OPENSSL_free(a->ptr);
722 static int ebcdic_read(BIO *b, char *out, int outl)
726 if (out == NULL || outl == 0)
728 if (b->next_bio == NULL)
731 ret = BIO_read(b->next_bio, out, outl);
733 ascii2ebcdic(out, out, ret);
737 static int ebcdic_write(BIO *b, const char *in, int inl)
739 EBCDIC_OUTBUFF *wbuf;
744 if ((in == NULL) || (inl <= 0))
746 if (b->next_bio == NULL)
749 wbuf = (EBCDIC_OUTBUFF *) b->ptr;
751 if (inl > (num = wbuf->alloced)) {
752 num = num + num; /* double the size */
756 (EBCDIC_OUTBUFF *) OPENSSL_malloc(sizeof(EBCDIC_OUTBUFF) + num);
759 OPENSSL_free(b->ptr);
762 wbuf->buff[0] = '\0';
764 b->ptr = (char *)wbuf;
767 ebcdic2ascii(wbuf->buff, in, inl);
769 ret = BIO_write(b->next_bio, wbuf->buff, inl);
774 static long ebcdic_ctrl(BIO *b, int cmd, long num, void *ptr)
778 if (b->next_bio == NULL)
785 ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
791 static int ebcdic_gets(BIO *bp, char *buf, int size)
794 if (bp->next_bio == NULL)
796 /* return(BIO_gets(bp->next_bio,buf,size));*/
797 for (i = 0; i < size - 1; ++i) {
798 ret = ebcdic_read(bp, &buf[i], 1);
801 else if (buf[i] == '\n') {
808 return (ret < 0 && i == 0) ? ret : i;
811 static int ebcdic_puts(BIO *bp, const char *str)
813 if (bp->next_bio == NULL)
815 return ebcdic_write(bp, str, strlen(str));
819 #ifndef OPENSSL_NO_TLSEXT
821 /* This is a context that we pass to callbacks */
822 typedef struct tlsextctx_st {
828 static int MS_CALLBACK ssl_servername_cb(SSL *s, int *ad, void *arg)
830 tlsextctx *p = (tlsextctx *) arg;
831 const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
832 if (servername && p->biodebug)
833 BIO_printf(p->biodebug, "Hostname in TLS extension: \"%s\"\n",
837 return SSL_TLSEXT_ERR_NOACK;
840 if (strcasecmp(servername, p->servername))
841 return p->extension_error;
843 BIO_printf(p->biodebug, "Switching server context.\n");
844 SSL_set_SSL_CTX(s, ctx2);
847 return SSL_TLSEXT_ERR_OK;
850 /* Structure passed to cert status callback */
852 typedef struct tlsextstatusctx_st {
853 /* Default responder to use */
854 char *host, *path, *port;
861 static tlsextstatusctx tlscstatp = { NULL, NULL, NULL, 0, -1, NULL, 0 };
864 * Certificate Status callback. This is called when a client includes a
865 * certificate status request extension. This is a simplified version. It
866 * examines certificates each time and makes one OCSP responder query for
867 * each request. A full version would store details such as the OCSP
868 * certificate IDs and minimise the number of OCSP responses by caching them
869 * until they were considered "expired".
872 static int cert_status_cb(SSL *s, void *arg)
874 tlsextstatusctx *srctx = arg;
875 BIO *err = srctx->err;
876 char *host, *port, *path;
878 unsigned char *rspder = NULL;
880 STACK_OF(OPENSSL_STRING) *aia = NULL;
882 X509_STORE_CTX inctx;
884 OCSP_REQUEST *req = NULL;
885 OCSP_RESPONSE *resp = NULL;
886 OCSP_CERTID *id = NULL;
887 STACK_OF(X509_EXTENSION) *exts;
888 int ret = SSL_TLSEXT_ERR_NOACK;
891 STACK_OF(OCSP_RESPID) *ids;
892 SSL_get_tlsext_status_ids(s, &ids);
893 BIO_printf(err, "cert_status: received %d ids\n",
894 sk_OCSP_RESPID_num(ids));
897 BIO_puts(err, "cert_status: callback called\n");
898 /* Build up OCSP query from server certificate */
899 x = SSL_get_certificate(s);
900 aia = X509_get1_ocsp(x);
902 if (!OCSP_parse_url(sk_OPENSSL_STRING_value(aia, 0),
903 &host, &port, &path, &use_ssl)) {
904 BIO_puts(err, "cert_status: can't parse AIA URL\n");
908 BIO_printf(err, "cert_status: AIA URL: %s\n",
909 sk_OPENSSL_STRING_value(aia, 0));
913 "cert_status: no AIA and no default responder URL\n");
919 use_ssl = srctx->use_ssl;
922 if (!X509_STORE_CTX_init(&inctx,
923 SSL_CTX_get_cert_store(SSL_get_SSL_CTX(s)),
926 if (X509_STORE_get_by_subject(&inctx, X509_LU_X509,
927 X509_get_issuer_name(x), &obj) <= 0) {
928 BIO_puts(err, "cert_status: Can't retrieve issuer certificate.\n");
929 X509_STORE_CTX_cleanup(&inctx);
932 req = OCSP_REQUEST_new();
935 id = OCSP_cert_to_id(NULL, x, obj.data.x509);
936 X509_free(obj.data.x509);
937 X509_STORE_CTX_cleanup(&inctx);
940 if (!OCSP_request_add0_id(req, id))
943 /* Add any extensions to the request */
944 SSL_get_tlsext_status_exts(s, &exts);
945 for (i = 0; i < sk_X509_EXTENSION_num(exts); i++) {
946 X509_EXTENSION *ext = sk_X509_EXTENSION_value(exts, i);
947 if (!OCSP_REQUEST_add_ext(req, ext, -1))
950 resp = process_responder(err, req, host, path, port, use_ssl, NULL,
953 BIO_puts(err, "cert_status: error querying responder\n");
956 rspderlen = i2d_OCSP_RESPONSE(resp, &rspder);
959 SSL_set_tlsext_status_ocsp_resp(s, rspder, rspderlen);
960 if (srctx->verbose) {
961 BIO_puts(err, "cert_status: ocsp response sent:\n");
962 OCSP_RESPONSE_print(err, resp, 2);
964 ret = SSL_TLSEXT_ERR_OK;
966 if (ret != SSL_TLSEXT_ERR_OK)
967 ERR_print_errors(err);
972 X509_email_free(aia);
975 OCSP_CERTID_free(id);
977 OCSP_REQUEST_free(req);
979 OCSP_RESPONSE_free(resp);
982 ret = SSL_TLSEXT_ERR_ALERT_FATAL;
986 # ifndef OPENSSL_NO_NEXTPROTONEG
987 /* This is the context that we pass to next_proto_cb */
988 typedef struct tlsextnextprotoctx_st {
991 } tlsextnextprotoctx;
993 static int next_proto_cb(SSL *s, const unsigned char **data,
994 unsigned int *len, void *arg)
996 tlsextnextprotoctx *next_proto = arg;
998 *data = next_proto->data;
999 *len = next_proto->len;
1001 return SSL_TLSEXT_ERR_OK;
1003 # endif /* ndef OPENSSL_NO_NEXTPROTONEG */
1005 /* This the context that we pass to alpn_cb */
1006 typedef struct tlsextalpnctx_st {
1007 unsigned char *data;
1011 static int alpn_cb(SSL *s, const unsigned char **out, unsigned char *outlen,
1012 const unsigned char *in, unsigned int inlen, void *arg)
1014 tlsextalpnctx *alpn_ctx = arg;
1017 /* We can assume that |in| is syntactically valid. */
1019 BIO_printf(bio_s_out, "ALPN protocols advertised by the client: ");
1020 for (i = 0; i < inlen;) {
1022 BIO_write(bio_s_out, ", ", 2);
1023 BIO_write(bio_s_out, &in[i + 1], in[i]);
1026 BIO_write(bio_s_out, "\n", 1);
1029 if (SSL_select_next_proto
1030 ((unsigned char **)out, outlen, alpn_ctx->data, alpn_ctx->len, in,
1031 inlen) != OPENSSL_NPN_NEGOTIATED) {
1032 return SSL_TLSEXT_ERR_NOACK;
1036 BIO_printf(bio_s_out, "ALPN protocols selected: ");
1037 BIO_write(bio_s_out, *out, *outlen);
1038 BIO_write(bio_s_out, "\n", 1);
1041 return SSL_TLSEXT_ERR_OK;
1043 #endif /* ndef OPENSSL_NO_TLSEXT */
1045 int MAIN(int, char **);
1047 #ifndef OPENSSL_NO_JPAKE
1048 static char *jpake_secret = NULL;
1049 # define no_jpake !jpake_secret
1053 #ifndef OPENSSL_NO_SRP
1054 static srpsrvparm srp_callback_parm;
1056 #ifndef OPENSSL_NO_SRTP
1057 static char *srtp_profiles = NULL;
1060 int MAIN(int argc, char *argv[])
1062 X509_VERIFY_PARAM *vpm = NULL;
1065 char *CApath = NULL, *CAfile = NULL;
1066 char *chCApath = NULL, *chCAfile = NULL;
1067 char *vfyCApath = NULL, *vfyCAfile = NULL;
1068 unsigned char *context = NULL;
1069 char *dhfile = NULL;
1072 int build_chain = 0;
1073 int no_tmp_rsa = 0, no_dhe = 0, no_ecdhe = 0, nocert = 0;
1075 const SSL_METHOD *meth = NULL;
1076 int socket_type = SOCK_STREAM;
1078 char *inrand = NULL;
1079 int s_cert_format = FORMAT_PEM, s_key_format = FORMAT_PEM;
1080 char *passarg = NULL, *pass = NULL;
1081 char *dpassarg = NULL, *dpass = NULL;
1082 int s_dcert_format = FORMAT_PEM, s_dkey_format = FORMAT_PEM;
1083 X509 *s_cert = NULL, *s_dcert = NULL;
1084 STACK_OF(X509) *s_chain = NULL, *s_dchain = NULL;
1085 EVP_PKEY *s_key = NULL, *s_dkey = NULL;
1086 int no_cache = 0, ext_cache = 0;
1087 int rev = 0, naccept = -1;
1088 #ifndef OPENSSL_NO_TLSEXT
1089 EVP_PKEY *s_key2 = NULL;
1090 X509 *s_cert2 = NULL;
1091 tlsextctx tlsextcbp = { NULL, NULL, SSL_TLSEXT_ERR_ALERT_WARNING };
1092 # ifndef OPENSSL_NO_NEXTPROTONEG
1093 const char *next_proto_neg_in = NULL;
1094 tlsextnextprotoctx next_proto = { NULL, 0 };
1096 const char *alpn_in = NULL;
1097 tlsextalpnctx alpn_ctx = { NULL, 0 };
1099 #ifndef OPENSSL_NO_PSK
1100 /* by default do not send a PSK identity hint */
1101 static char *psk_identity_hint = NULL;
1103 #ifndef OPENSSL_NO_SRP
1104 char *srpuserseed = NULL;
1105 char *srp_verifier_file = NULL;
1107 SSL_EXCERT *exc = NULL;
1108 SSL_CONF_CTX *cctx = NULL;
1109 STACK_OF(OPENSSL_STRING) *ssl_args = NULL;
1111 char *crl_file = NULL;
1112 int crl_format = FORMAT_PEM;
1113 int crl_download = 0;
1114 STACK_OF(X509_CRL) *crls = NULL;
1116 meth = SSLv23_server_method();
1126 if (bio_err == NULL)
1127 bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);
1129 if (!load_config(bio_err, NULL))
1132 cctx = SSL_CONF_CTX_new();
1135 SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_SERVER);
1136 SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CMDLINE);
1148 if ((strcmp(*argv, "-port") == 0) || (strcmp(*argv, "-accept") == 0)) {
1151 if (!extract_port(*(++argv), &port))
1153 } else if (strcmp(*argv, "-naccept") == 0) {
1156 naccept = atol(*(++argv));
1158 BIO_printf(bio_err, "bad accept value %s\n", *argv);
1161 } else if (strcmp(*argv, "-verify") == 0) {
1162 s_server_verify = SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE;
1165 verify_depth = atoi(*(++argv));
1167 BIO_printf(bio_err, "verify depth is %d\n", verify_depth);
1168 } else if (strcmp(*argv, "-Verify") == 0) {
1170 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT |
1171 SSL_VERIFY_CLIENT_ONCE;
1174 verify_depth = atoi(*(++argv));
1177 "verify depth is %d, must return a certificate\n",
1179 } else if (strcmp(*argv, "-context") == 0) {
1182 context = (unsigned char *)*(++argv);
1183 } else if (strcmp(*argv, "-cert") == 0) {
1186 s_cert_file = *(++argv);
1187 } else if (strcmp(*argv, "-CRL") == 0) {
1190 crl_file = *(++argv);
1191 } else if (strcmp(*argv, "-crl_download") == 0)
1193 #ifndef OPENSSL_NO_TLSEXT
1194 else if (strcmp(*argv, "-serverinfo") == 0) {
1197 s_serverinfo_file = *(++argv);
1200 else if (strcmp(*argv, "-certform") == 0) {
1203 s_cert_format = str2fmt(*(++argv));
1204 } else if (strcmp(*argv, "-key") == 0) {
1207 s_key_file = *(++argv);
1208 } else if (strcmp(*argv, "-keyform") == 0) {
1211 s_key_format = str2fmt(*(++argv));
1212 } else if (strcmp(*argv, "-pass") == 0) {
1215 passarg = *(++argv);
1216 } else if (strcmp(*argv, "-cert_chain") == 0) {
1219 s_chain_file = *(++argv);
1220 } else if (strcmp(*argv, "-dhparam") == 0) {
1224 } else if (strcmp(*argv, "-dcertform") == 0) {
1227 s_dcert_format = str2fmt(*(++argv));
1228 } else if (strcmp(*argv, "-dcert") == 0) {
1231 s_dcert_file = *(++argv);
1232 } else if (strcmp(*argv, "-dkeyform") == 0) {
1235 s_dkey_format = str2fmt(*(++argv));
1236 } else if (strcmp(*argv, "-dpass") == 0) {
1239 dpassarg = *(++argv);
1240 } else if (strcmp(*argv, "-dkey") == 0) {
1243 s_dkey_file = *(++argv);
1244 } else if (strcmp(*argv, "-dcert_chain") == 0) {
1247 s_dchain_file = *(++argv);
1248 } else if (strcmp(*argv, "-nocert") == 0) {
1250 } else if (strcmp(*argv, "-CApath") == 0) {
1254 } else if (strcmp(*argv, "-chainCApath") == 0) {
1257 chCApath = *(++argv);
1258 } else if (strcmp(*argv, "-verifyCApath") == 0) {
1261 vfyCApath = *(++argv);
1262 } else if (strcmp(*argv, "-no_cache") == 0)
1264 else if (strcmp(*argv, "-ext_cache") == 0)
1266 else if (strcmp(*argv, "-CRLform") == 0) {
1269 crl_format = str2fmt(*(++argv));
1270 } else if (args_verify(&argv, &argc, &badarg, bio_err, &vpm)) {
1274 } else if (args_excert(&argv, &argc, &badarg, bio_err, &exc)) {
1278 } else if (args_ssl(&argv, &argc, cctx, &badarg, bio_err, &ssl_args)) {
1282 } else if (strcmp(*argv, "-verify_return_error") == 0)
1283 verify_return_error = 1;
1284 else if (strcmp(*argv, "-verify_quiet") == 0)
1286 else if (strcmp(*argv, "-build_chain") == 0)
1288 else if (strcmp(*argv, "-CAfile") == 0) {
1292 } else if (strcmp(*argv, "-chainCAfile") == 0) {
1295 chCAfile = *(++argv);
1296 } else if (strcmp(*argv, "-verifyCAfile") == 0) {
1299 vfyCAfile = *(++argv);
1302 else if (strcmp(*argv, "-nbio") == 0) {
1306 else if (strcmp(*argv, "-nbio_test") == 0) {
1311 } else if (strcmp(*argv, "-ign_eof") == 0)
1313 else if (strcmp(*argv, "-no_ign_eof") == 0)
1315 else if (strcmp(*argv, "-debug") == 0) {
1318 #ifndef OPENSSL_NO_TLSEXT
1319 else if (strcmp(*argv, "-tlsextdebug") == 0)
1321 else if (strcmp(*argv, "-status") == 0)
1323 else if (strcmp(*argv, "-status_verbose") == 0) {
1325 tlscstatp.verbose = 1;
1326 } else if (!strcmp(*argv, "-status_timeout")) {
1330 tlscstatp.timeout = atoi(*(++argv));
1331 } else if (!strcmp(*argv, "-status_url")) {
1335 if (!OCSP_parse_url(*(++argv),
1338 &tlscstatp.path, &tlscstatp.use_ssl)) {
1339 BIO_printf(bio_err, "Error parsing URL\n");
1344 else if (strcmp(*argv, "-msg") == 0) {
1346 } else if (strcmp(*argv, "-msgfile") == 0) {
1349 bio_s_msg = BIO_new_file(*(++argv), "w");
1351 #ifndef OPENSSL_NO_SSL_TRACE
1352 else if (strcmp(*argv, "-trace") == 0) {
1356 else if (strcmp(*argv, "-hack") == 0) {
1358 } else if (strcmp(*argv, "-state") == 0) {
1360 } else if (strcmp(*argv, "-crlf") == 0) {
1362 } else if (strcmp(*argv, "-quiet") == 0) {
1364 } else if (strcmp(*argv, "-brief") == 0) {
1368 } else if (strcmp(*argv, "-no_tmp_rsa") == 0) {
1370 } else if (strcmp(*argv, "-no_dhe") == 0) {
1372 } else if (strcmp(*argv, "-no_ecdhe") == 0) {
1374 } else if (strcmp(*argv, "-no_resume_ephemeral") == 0) {
1375 no_resume_ephemeral = 1;
1377 #ifndef OPENSSL_NO_PSK
1378 else if (strcmp(*argv, "-psk_hint") == 0) {
1381 psk_identity_hint = *(++argv);
1382 } else if (strcmp(*argv, "-psk") == 0) {
1387 psk_key = *(++argv);
1388 for (i = 0; i < strlen(psk_key); i++) {
1389 if (isxdigit((unsigned char)psk_key[i]))
1391 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
1396 #ifndef OPENSSL_NO_SRP
1397 else if (strcmp(*argv, "-srpvfile") == 0) {
1400 srp_verifier_file = *(++argv);
1401 meth = TLSv1_server_method();
1402 } else if (strcmp(*argv, "-srpuserseed") == 0) {
1405 srpuserseed = *(++argv);
1406 meth = TLSv1_server_method();
1409 else if (strcmp(*argv, "-rev") == 0) {
1411 } else if (strcmp(*argv, "-www") == 0) {
1413 } else if (strcmp(*argv, "-WWW") == 0) {
1415 } else if (strcmp(*argv, "-HTTP") == 0) {
1418 #ifndef OPENSSL_NO_SSL2
1419 else if (strcmp(*argv, "-ssl2") == 0) {
1421 meth = SSLv2_server_method();
1424 #ifndef OPENSSL_NO_SSL3_METHOD
1425 else if (strcmp(*argv, "-ssl3") == 0) {
1426 meth = SSLv3_server_method();
1429 #ifndef OPENSSL_NO_TLS1
1430 else if (strcmp(*argv, "-tls1") == 0) {
1431 meth = TLSv1_server_method();
1432 } else if (strcmp(*argv, "-tls1_1") == 0) {
1433 meth = TLSv1_1_server_method();
1434 } else if (strcmp(*argv, "-tls1_2") == 0) {
1435 meth = TLSv1_2_server_method();
1438 #ifndef OPENSSL_NO_DTLS1
1439 else if (strcmp(*argv, "-dtls") == 0) {
1440 meth = DTLS_server_method();
1441 socket_type = SOCK_DGRAM;
1442 } else if (strcmp(*argv, "-dtls1") == 0) {
1443 meth = DTLSv1_server_method();
1444 socket_type = SOCK_DGRAM;
1445 } else if (strcmp(*argv, "-dtls1_2") == 0) {
1446 meth = DTLSv1_2_server_method();
1447 socket_type = SOCK_DGRAM;
1448 } else if (strcmp(*argv, "-timeout") == 0)
1449 enable_timeouts = 1;
1450 else if (strcmp(*argv, "-mtu") == 0) {
1453 socket_mtu = atol(*(++argv));
1454 } else if (strcmp(*argv, "-chain") == 0)
1457 else if (strcmp(*argv, "-id_prefix") == 0) {
1460 session_id_prefix = *(++argv);
1462 #ifndef OPENSSL_NO_ENGINE
1463 else if (strcmp(*argv, "-engine") == 0) {
1466 engine_id = *(++argv);
1469 else if (strcmp(*argv, "-rand") == 0) {
1474 #ifndef OPENSSL_NO_TLSEXT
1475 else if (strcmp(*argv, "-servername") == 0) {
1478 tlsextcbp.servername = *(++argv);
1479 } else if (strcmp(*argv, "-servername_fatal") == 0) {
1480 tlsextcbp.extension_error = SSL_TLSEXT_ERR_ALERT_FATAL;
1481 } else if (strcmp(*argv, "-cert2") == 0) {
1484 s_cert_file2 = *(++argv);
1485 } else if (strcmp(*argv, "-key2") == 0) {
1488 s_key_file2 = *(++argv);
1490 # ifndef OPENSSL_NO_NEXTPROTONEG
1491 else if (strcmp(*argv, "-nextprotoneg") == 0) {
1494 next_proto_neg_in = *(++argv);
1497 else if (strcmp(*argv, "-alpn") == 0) {
1500 alpn_in = *(++argv);
1503 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
1504 else if (strcmp(*argv, "-jpake") == 0) {
1507 jpake_secret = *(++argv);
1510 #ifndef OPENSSL_NO_SRTP
1511 else if (strcmp(*argv, "-use_srtp") == 0) {
1514 srtp_profiles = *(++argv);
1517 else if (strcmp(*argv, "-keymatexport") == 0) {
1520 keymatexportlabel = *(++argv);
1521 } else if (strcmp(*argv, "-keymatexportlen") == 0) {
1524 keymatexportlen = atoi(*(++argv));
1525 if (keymatexportlen == 0)
1528 BIO_printf(bio_err, "unknown option %s\n", *argv);
1540 #ifndef OPENSSL_NO_DTLS1
1541 if (www && socket_type == SOCK_DGRAM) {
1542 BIO_printf(bio_err, "Can't use -HTTP, -www or -WWW with DTLS\n");
1547 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
1550 BIO_printf(bio_err, "Can't use JPAKE and PSK together\n");
1553 psk_identity = "JPAKE";
1557 SSL_load_error_strings();
1558 OpenSSL_add_ssl_algorithms();
1560 #ifndef OPENSSL_NO_ENGINE
1561 e = setup_engine(bio_err, engine_id, 1);
1564 if (!app_passwd(bio_err, passarg, dpassarg, &pass, &dpass)) {
1565 BIO_printf(bio_err, "Error getting password\n");
1569 if (s_key_file == NULL)
1570 s_key_file = s_cert_file;
1571 #ifndef OPENSSL_NO_TLSEXT
1572 if (s_key_file2 == NULL)
1573 s_key_file2 = s_cert_file2;
1576 if (!load_excert(&exc, bio_err))
1580 s_key = load_key(bio_err, s_key_file, s_key_format, 0, pass, e,
1581 "server certificate private key file");
1583 ERR_print_errors(bio_err);
1587 s_cert = load_cert(bio_err, s_cert_file, s_cert_format,
1588 NULL, e, "server certificate file");
1591 ERR_print_errors(bio_err);
1595 s_chain = load_certs(bio_err, s_chain_file, FORMAT_PEM,
1596 NULL, e, "server certificate chain");
1600 #ifndef OPENSSL_NO_TLSEXT
1601 if (tlsextcbp.servername) {
1602 s_key2 = load_key(bio_err, s_key_file2, s_key_format, 0, pass, e,
1603 "second server certificate private key file");
1605 ERR_print_errors(bio_err);
1609 s_cert2 = load_cert(bio_err, s_cert_file2, s_cert_format,
1610 NULL, e, "second server certificate file");
1613 ERR_print_errors(bio_err);
1617 #endif /* OPENSSL_NO_TLSEXT */
1619 #if !defined(OPENSSL_NO_TLSEXT)
1620 # if !defined(OPENSSL_NO_NEXTPROTONEG)
1621 if (next_proto_neg_in) {
1623 next_proto.data = next_protos_parse(&len, next_proto_neg_in);
1624 if (next_proto.data == NULL)
1626 next_proto.len = len;
1628 next_proto.data = NULL;
1631 alpn_ctx.data = NULL;
1634 alpn_ctx.data = next_protos_parse(&len, alpn_in);
1635 if (alpn_ctx.data == NULL)
1643 crl = load_crl(crl_file, crl_format);
1645 BIO_puts(bio_err, "Error loading CRL\n");
1646 ERR_print_errors(bio_err);
1649 crls = sk_X509_CRL_new_null();
1650 if (!crls || !sk_X509_CRL_push(crls, crl)) {
1651 BIO_puts(bio_err, "Error adding CRL\n");
1652 ERR_print_errors(bio_err);
1660 if (s_dkey_file == NULL)
1661 s_dkey_file = s_dcert_file;
1663 s_dkey = load_key(bio_err, s_dkey_file, s_dkey_format,
1664 0, dpass, e, "second certificate private key file");
1666 ERR_print_errors(bio_err);
1670 s_dcert = load_cert(bio_err, s_dcert_file, s_dcert_format,
1671 NULL, e, "second server certificate file");
1674 ERR_print_errors(bio_err);
1677 if (s_dchain_file) {
1678 s_dchain = load_certs(bio_err, s_dchain_file, FORMAT_PEM,
1679 NULL, e, "second server certificate chain");
1686 if (!app_RAND_load_file(NULL, bio_err, 1) && inrand == NULL
1687 && !RAND_status()) {
1689 "warning, not much extra random data, consider using the -rand option\n");
1692 BIO_printf(bio_err, "%ld semi-random bytes loaded\n",
1693 app_RAND_load_files(inrand));
1695 if (bio_s_out == NULL) {
1696 if (s_quiet && !s_debug) {
1697 bio_s_out = BIO_new(BIO_s_null());
1698 if (s_msg && !bio_s_msg)
1699 bio_s_msg = BIO_new_fp(stdout, BIO_NOCLOSE);
1701 if (bio_s_out == NULL)
1702 bio_s_out = BIO_new_fp(stdout, BIO_NOCLOSE);
1705 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_ECDSA)
1711 s_dcert_file = NULL;
1713 #ifndef OPENSSL_NO_TLSEXT
1714 s_cert_file2 = NULL;
1719 ctx = SSL_CTX_new(meth);
1721 ERR_print_errors(bio_err);
1724 if (session_id_prefix) {
1725 if (strlen(session_id_prefix) >= 32)
1727 "warning: id_prefix is too long, only one new session will be possible\n");
1728 else if (strlen(session_id_prefix) >= 16)
1730 "warning: id_prefix is too long if you use SSLv2\n");
1731 if (!SSL_CTX_set_generate_session_id(ctx, generate_session_id)) {
1732 BIO_printf(bio_err, "error setting 'id_prefix'\n");
1733 ERR_print_errors(bio_err);
1736 BIO_printf(bio_err, "id_prefix '%s' set.\n", session_id_prefix);
1738 SSL_CTX_set_quiet_shutdown(ctx, 1);
1740 SSL_CTX_set_options(ctx, SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG);
1742 ssl_ctx_set_excert(ctx, exc);
1745 SSL_CTX_set_info_callback(ctx, apps_ssl_info_callback);
1747 SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
1749 init_session_cache_ctx(ctx);
1751 SSL_CTX_sess_set_cache_size(ctx, 128);
1753 #ifndef OPENSSL_NO_SRTP
1754 if (srtp_profiles != NULL)
1755 SSL_CTX_set_tlsext_use_srtp(ctx, srtp_profiles);
1760 cipher = getenv("SSL_CIPHER");
1764 if (s_cert_file == NULL) {
1766 "You must specify a certificate file for the server to use\n");
1771 if ((!SSL_CTX_load_verify_locations(ctx, CAfile, CApath)) ||
1772 (!SSL_CTX_set_default_verify_paths(ctx))) {
1773 /* BIO_printf(bio_err,"X509_load_verify_locations\n"); */
1774 ERR_print_errors(bio_err);
1778 SSL_CTX_set1_param(ctx, vpm);
1780 ssl_ctx_add_crls(ctx, crls, 0);
1782 if (!args_ssl_call(ctx, bio_err, cctx, ssl_args, no_ecdhe, no_jpake))
1785 if (!ssl_load_stores(ctx, vfyCApath, vfyCAfile, chCApath, chCAfile,
1786 crls, crl_download)) {
1787 BIO_printf(bio_err, "Error loading store locations\n");
1788 ERR_print_errors(bio_err);
1791 #ifndef OPENSSL_NO_TLSEXT
1793 ctx2 = SSL_CTX_new(meth);
1795 ERR_print_errors(bio_err);
1801 BIO_printf(bio_s_out, "Setting secondary ctx parameters\n");
1803 if (session_id_prefix) {
1804 if (strlen(session_id_prefix) >= 32)
1806 "warning: id_prefix is too long, only one new session will be possible\n");
1807 else if (strlen(session_id_prefix) >= 16)
1809 "warning: id_prefix is too long if you use SSLv2\n");
1810 if (!SSL_CTX_set_generate_session_id(ctx2, generate_session_id)) {
1811 BIO_printf(bio_err, "error setting 'id_prefix'\n");
1812 ERR_print_errors(bio_err);
1815 BIO_printf(bio_err, "id_prefix '%s' set.\n", session_id_prefix);
1817 SSL_CTX_set_quiet_shutdown(ctx2, 1);
1819 SSL_CTX_set_options(ctx2, SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG);
1821 ssl_ctx_set_excert(ctx2, exc);
1824 SSL_CTX_set_info_callback(ctx2, apps_ssl_info_callback);
1827 SSL_CTX_set_session_cache_mode(ctx2, SSL_SESS_CACHE_OFF);
1829 init_session_cache_ctx(ctx2);
1831 SSL_CTX_sess_set_cache_size(ctx2, 128);
1833 if ((!SSL_CTX_load_verify_locations(ctx2, CAfile, CApath)) ||
1834 (!SSL_CTX_set_default_verify_paths(ctx2))) {
1835 ERR_print_errors(bio_err);
1838 SSL_CTX_set1_param(ctx2, vpm);
1840 ssl_ctx_add_crls(ctx2, crls, 0);
1842 if (!args_ssl_call(ctx2, bio_err, cctx, ssl_args, no_ecdhe, no_jpake))
1846 # ifndef OPENSSL_NO_NEXTPROTONEG
1847 if (next_proto.data)
1848 SSL_CTX_set_next_protos_advertised_cb(ctx, next_proto_cb,
1852 SSL_CTX_set_alpn_select_cb(ctx, alpn_cb, &alpn_ctx);
1855 #ifndef OPENSSL_NO_DH
1860 dh = load_dh_param(dhfile);
1861 else if (s_cert_file)
1862 dh = load_dh_param(s_cert_file);
1865 BIO_printf(bio_s_out, "Setting temp DH parameters\n");
1867 BIO_printf(bio_s_out, "Using default temp DH parameters\n");
1870 (void)BIO_flush(bio_s_out);
1872 SSL_CTX_set_tmp_dh(ctx, dh);
1873 # ifndef OPENSSL_NO_TLSEXT
1876 DH *dh2 = load_dh_param(s_cert_file2);
1878 BIO_printf(bio_s_out, "Setting temp DH parameters\n");
1879 (void)BIO_flush(bio_s_out);
1885 SSL_CTX_set_tmp_dh(ctx2, dh);
1892 if (!set_cert_key_stuff(ctx, s_cert, s_key, s_chain, build_chain))
1894 #ifndef OPENSSL_NO_TLSEXT
1895 if (s_serverinfo_file != NULL
1896 && !SSL_CTX_use_serverinfo_file(ctx, s_serverinfo_file)) {
1897 ERR_print_errors(bio_err);
1901 #ifndef OPENSSL_NO_TLSEXT
1902 if (ctx2 && !set_cert_key_stuff(ctx2, s_cert2, s_key2, NULL, build_chain))
1905 if (s_dcert != NULL) {
1906 if (!set_cert_key_stuff(ctx, s_dcert, s_dkey, s_dchain, build_chain))
1909 #ifndef OPENSSL_NO_RSA
1912 SSL_CTX_set_tmp_rsa_callback(ctx, tmp_rsa_cb);
1913 # ifndef OPENSSL_NO_TLSEXT
1915 SSL_CTX_set_tmp_rsa_callback(ctx2, tmp_rsa_cb);
1919 if (!no_tmp_rsa && SSL_CTX_need_tmp_RSA(ctx)) {
1922 BIO_printf(bio_s_out, "Generating temp (512 bit) RSA key...");
1923 BIO_flush(bio_s_out);
1925 rsa = RSA_generate_key(512, RSA_F4, NULL);
1927 if (!SSL_CTX_set_tmp_rsa(ctx, rsa)) {
1928 ERR_print_errors(bio_err);
1931 # ifndef OPENSSL_NO_TLSEXT
1933 if (!SSL_CTX_set_tmp_rsa(ctx2, rsa)) {
1934 ERR_print_errors(bio_err);
1940 BIO_printf(bio_s_out, "\n");
1945 #ifndef OPENSSL_NO_PSK
1946 # ifdef OPENSSL_NO_JPAKE
1947 if (psk_key != NULL)
1949 if (psk_key != NULL || jpake_secret)
1953 BIO_printf(bio_s_out,
1954 "PSK key given or JPAKE in use, setting server callback\n");
1955 SSL_CTX_set_psk_server_callback(ctx, psk_server_cb);
1958 if (!SSL_CTX_use_psk_identity_hint(ctx, psk_identity_hint)) {
1959 BIO_printf(bio_err, "error setting PSK identity hint to context\n");
1960 ERR_print_errors(bio_err);
1965 SSL_CTX_set_verify(ctx, s_server_verify, verify_callback);
1966 SSL_CTX_set_session_id_context(ctx, (void *)&s_server_session_id_context,
1967 sizeof s_server_session_id_context);
1969 /* Set DTLS cookie generation and verification callbacks */
1970 SSL_CTX_set_cookie_generate_cb(ctx, generate_cookie_callback);
1971 SSL_CTX_set_cookie_verify_cb(ctx, verify_cookie_callback);
1973 #ifndef OPENSSL_NO_TLSEXT
1975 SSL_CTX_set_verify(ctx2, s_server_verify, verify_callback);
1976 SSL_CTX_set_session_id_context(ctx2,
1977 (void *)&s_server_session_id_context,
1978 sizeof s_server_session_id_context);
1980 tlsextcbp.biodebug = bio_s_out;
1981 SSL_CTX_set_tlsext_servername_callback(ctx2, ssl_servername_cb);
1982 SSL_CTX_set_tlsext_servername_arg(ctx2, &tlsextcbp);
1983 SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
1984 SSL_CTX_set_tlsext_servername_arg(ctx, &tlsextcbp);
1988 #ifndef OPENSSL_NO_SRP
1989 if (srp_verifier_file != NULL) {
1990 srp_callback_parm.vb = SRP_VBASE_new(srpuserseed);
1991 srp_callback_parm.user = NULL;
1992 srp_callback_parm.login = NULL;
1994 SRP_VBASE_init(srp_callback_parm.vb,
1995 srp_verifier_file)) != SRP_NO_ERROR) {
1997 "Cannot initialize SRP verifier file \"%s\":ret=%d\n",
1998 srp_verifier_file, ret);
2001 SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, verify_callback);
2002 SSL_CTX_set_srp_cb_arg(ctx, &srp_callback_parm);
2003 SSL_CTX_set_srp_username_callback(ctx, ssl_srp_server_param_cb);
2006 if (CAfile != NULL) {
2007 SSL_CTX_set_client_CA_list(ctx, SSL_load_client_CA_file(CAfile));
2008 #ifndef OPENSSL_NO_TLSEXT
2010 SSL_CTX_set_client_CA_list(ctx2, SSL_load_client_CA_file(CAfile));
2014 BIO_printf(bio_s_out, "ACCEPT\n");
2015 (void)BIO_flush(bio_s_out);
2017 do_server(port, socket_type, &accept_socket, rev_body, context,
2020 do_server(port, socket_type, &accept_socket, www_body, context,
2023 do_server(port, socket_type, &accept_socket, sv_body, context,
2025 print_stats(bio_s_out, ctx);
2033 sk_X509_CRL_pop_free(crls, X509_CRL_free);
2037 EVP_PKEY_free(s_key);
2039 EVP_PKEY_free(s_dkey);
2041 sk_X509_pop_free(s_chain, X509_free);
2043 sk_X509_pop_free(s_dchain, X509_free);
2047 OPENSSL_free(dpass);
2049 X509_VERIFY_PARAM_free(vpm);
2051 #ifndef OPENSSL_NO_TLSEXT
2053 OPENSSL_free(tlscstatp.host);
2055 OPENSSL_free(tlscstatp.port);
2057 OPENSSL_free(tlscstatp.path);
2063 EVP_PKEY_free(s_key2);
2064 if (serverinfo_in != NULL)
2065 BIO_free(serverinfo_in);
2066 # ifndef OPENSSL_NO_NEXTPROTONEG
2067 if (next_proto.data)
2068 OPENSSL_free(next_proto.data);
2071 OPENSSL_free(alpn_ctx.data);
2073 ssl_excert_free(exc);
2075 sk_OPENSSL_STRING_free(ssl_args);
2077 SSL_CONF_CTX_free(cctx);
2078 #ifndef OPENSSL_NO_JPAKE
2079 if (jpake_secret && psk_key)
2080 OPENSSL_free(psk_key);
2082 if (bio_s_out != NULL) {
2083 BIO_free(bio_s_out);
2086 if (bio_s_msg != NULL) {
2087 BIO_free(bio_s_msg);
2094 static void print_stats(BIO *bio, SSL_CTX *ssl_ctx)
2096 BIO_printf(bio, "%4ld items in the session cache\n",
2097 SSL_CTX_sess_number(ssl_ctx));
2098 BIO_printf(bio, "%4ld client connects (SSL_connect())\n",
2099 SSL_CTX_sess_connect(ssl_ctx));
2100 BIO_printf(bio, "%4ld client renegotiates (SSL_connect())\n",
2101 SSL_CTX_sess_connect_renegotiate(ssl_ctx));
2102 BIO_printf(bio, "%4ld client connects that finished\n",
2103 SSL_CTX_sess_connect_good(ssl_ctx));
2104 BIO_printf(bio, "%4ld server accepts (SSL_accept())\n",
2105 SSL_CTX_sess_accept(ssl_ctx));
2106 BIO_printf(bio, "%4ld server renegotiates (SSL_accept())\n",
2107 SSL_CTX_sess_accept_renegotiate(ssl_ctx));
2108 BIO_printf(bio, "%4ld server accepts that finished\n",
2109 SSL_CTX_sess_accept_good(ssl_ctx));
2110 BIO_printf(bio, "%4ld session cache hits\n", SSL_CTX_sess_hits(ssl_ctx));
2111 BIO_printf(bio, "%4ld session cache misses\n",
2112 SSL_CTX_sess_misses(ssl_ctx));
2113 BIO_printf(bio, "%4ld session cache timeouts\n",
2114 SSL_CTX_sess_timeouts(ssl_ctx));
2115 BIO_printf(bio, "%4ld callback cache hits\n",
2116 SSL_CTX_sess_cb_hits(ssl_ctx));
2117 BIO_printf(bio, "%4ld cache full overflows (%ld allowed)\n",
2118 SSL_CTX_sess_cache_full(ssl_ctx),
2119 SSL_CTX_sess_get_cache_size(ssl_ctx));
2122 static int sv_body(char *hostname, int s, int stype, unsigned char *context)
2131 #ifndef OPENSSL_NO_KRB5
2134 struct timeval timeout;
2135 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE) || defined(OPENSSL_SYS_BEOS_R5)
2138 struct timeval *timeoutp;
2141 if ((buf = OPENSSL_malloc(bufsize)) == NULL) {
2142 BIO_printf(bio_err, "out of memory\n");
2147 unsigned long sl = 1;
2150 BIO_printf(bio_err, "turning on non blocking io\n");
2151 if (BIO_socket_ioctl(s, FIONBIO, &sl) < 0)
2152 ERR_print_errors(bio_err);
2158 #ifndef OPENSSL_NO_TLSEXT
2159 if (s_tlsextdebug) {
2160 SSL_set_tlsext_debug_callback(con, tlsext_cb);
2161 SSL_set_tlsext_debug_arg(con, bio_s_out);
2163 if (s_tlsextstatus) {
2164 SSL_CTX_set_tlsext_status_cb(ctx, cert_status_cb);
2165 tlscstatp.err = bio_err;
2166 SSL_CTX_set_tlsext_status_arg(ctx, &tlscstatp);
2169 #ifndef OPENSSL_NO_KRB5
2170 if ((kctx = kssl_ctx_new()) != NULL) {
2171 SSL_set0_kssl_ctx(con, kctx);
2172 kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
2173 kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
2175 #endif /* OPENSSL_NO_KRB5 */
2177 SSL_set_session_id_context(con, context, strlen((char *)context));
2181 # ifdef TLSEXT_TYPE_opaque_prf_input
2182 SSL_set_tlsext_opaque_prf_input(con, "Test server", 11);
2186 if (stype == SOCK_DGRAM) {
2188 sbio = BIO_new_dgram(s, BIO_NOCLOSE);
2190 if (enable_timeouts) {
2192 timeout.tv_usec = DGRAM_RCV_TIMEOUT;
2193 BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout);
2196 timeout.tv_usec = DGRAM_SND_TIMEOUT;
2197 BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_SEND_TIMEOUT, 0, &timeout);
2201 if (socket_mtu < DTLS_get_link_min_mtu(con)) {
2202 BIO_printf(bio_err, "MTU too small. Must be at least %ld\n",
2203 DTLS_get_link_min_mtu(con));
2208 SSL_set_options(con, SSL_OP_NO_QUERY_MTU);
2209 if (!DTLS_set_link_mtu(con, socket_mtu)) {
2210 BIO_printf(bio_err, "Failed to set MTU\n");
2216 /* want to do MTU discovery */
2217 BIO_ctrl(sbio, BIO_CTRL_DGRAM_MTU_DISCOVER, 0, NULL);
2219 /* turn on cookie exchange */
2220 SSL_set_options(con, SSL_OP_COOKIE_EXCHANGE);
2222 sbio = BIO_new_socket(s, BIO_NOCLOSE);
2227 test = BIO_new(BIO_f_nbio_test());
2228 sbio = BIO_push(test, sbio);
2230 #ifndef OPENSSL_NO_JPAKE
2232 jpake_server_auth(bio_s_out, sbio, jpake_secret);
2235 SSL_set_bio(con, sbio, sbio);
2236 SSL_set_accept_state(con);
2237 /* SSL_set_fd(con,s); */
2240 SSL_set_debug(con, 1);
2241 BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
2242 BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
2245 #ifndef OPENSSL_NO_SSL_TRACE
2247 SSL_set_msg_callback(con, SSL_trace);
2250 SSL_set_msg_callback(con, msg_cb);
2251 SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
2253 #ifndef OPENSSL_NO_TLSEXT
2254 if (s_tlsextdebug) {
2255 SSL_set_tlsext_debug_callback(con, tlsext_cb);
2256 SSL_set_tlsext_debug_arg(con, bio_s_out);
2262 int read_from_terminal;
2263 int read_from_sslcon;
2265 read_from_terminal = 0;
2266 read_from_sslcon = SSL_pending(con);
2268 if (!read_from_sslcon) {
2270 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_NETWARE) && !defined(OPENSSL_SYS_BEOS_R5)
2271 openssl_fdset(fileno(stdin), &readfds);
2273 openssl_fdset(s, &readfds);
2275 * Note: under VMS with SOCKETSHR the second parameter is
2276 * currently of type (int *) whereas under other systems it is
2277 * (void *) if you don't have a cast it will choke the compiler:
2278 * if you do have a cast then you can either go for (int *) or
2281 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE)
2283 * Under DOS (non-djgpp) and Windows we can't select on stdin:
2284 * only on sockets. As a workaround we timeout the select every
2285 * second and check for any keypress. In a proper Windows
2286 * application we wouldn't do this because it is inefficient.
2290 i = select(width, (void *)&readfds, NULL, NULL, &tv);
2291 if ((i < 0) || (!i && !_kbhit()))
2294 read_from_terminal = 1;
2295 #elif defined(OPENSSL_SYS_BEOS_R5)
2296 /* Under BeOS-R5 the situation is similar to DOS */
2299 (void)fcntl(fileno(stdin), F_SETFL, O_NONBLOCK);
2300 i = select(width, (void *)&readfds, NULL, NULL, &tv);
2301 if ((i < 0) || (!i && read(fileno(stdin), buf, 0) < 0))
2303 if (read(fileno(stdin), buf, 0) >= 0)
2304 read_from_terminal = 1;
2305 (void)fcntl(fileno(stdin), F_SETFL, 0);
2307 if ((SSL_version(con) == DTLS1_VERSION) &&
2308 DTLSv1_get_timeout(con, &timeout))
2309 timeoutp = &timeout;
2313 i = select(width, (void *)&readfds, NULL, NULL, timeoutp);
2315 if ((SSL_version(con) == DTLS1_VERSION)
2316 && DTLSv1_handle_timeout(con) > 0) {
2317 BIO_printf(bio_err, "TIMEOUT occured\n");
2322 if (FD_ISSET(fileno(stdin), &readfds))
2323 read_from_terminal = 1;
2325 if (FD_ISSET(s, &readfds))
2326 read_from_sslcon = 1;
2328 if (read_from_terminal) {
2332 i = raw_read_stdin(buf, bufsize / 2);
2334 /* both loops are skipped when i <= 0 */
2335 for (j = 0; j < i; j++)
2338 for (j = i - 1; j >= 0; j--) {
2339 buf[j + lf_num] = buf[j];
2340 if (buf[j] == '\n') {
2343 buf[j + lf_num] = '\r';
2346 assert(lf_num == 0);
2348 i = raw_read_stdin(buf, bufsize);
2349 if (!s_quiet && !s_brief) {
2350 if ((i <= 0) || (buf[0] == 'Q')) {
2351 BIO_printf(bio_s_out, "DONE\n");
2353 close_accept_socket();
2357 if ((i <= 0) || (buf[0] == 'q')) {
2358 BIO_printf(bio_s_out, "DONE\n");
2359 if (SSL_version(con) != DTLS1_VERSION)
2362 * close_accept_socket(); ret= -11;
2366 #ifndef OPENSSL_NO_HEARTBEATS
2367 if ((buf[0] == 'B') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2368 BIO_printf(bio_err, "HEARTBEATING\n");
2374 if ((buf[0] == 'r') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2375 SSL_renegotiate(con);
2376 i = SSL_do_handshake(con);
2377 printf("SSL_do_handshake -> %d\n", i);
2381 * strcpy(buf,"server side RE-NEGOTIATE\n");
2384 if ((buf[0] == 'R') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2386 SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE,
2388 SSL_renegotiate(con);
2389 i = SSL_do_handshake(con);
2390 printf("SSL_do_handshake -> %d\n", i);
2394 * strcpy(buf,"server side RE-NEGOTIATE asking for client
2398 if (buf[0] == 'P') {
2399 static const char *str = "Lets print some clear text\n";
2400 BIO_write(SSL_get_wbio(con), str, strlen(str));
2402 if (buf[0] == 'S') {
2403 print_stats(bio_s_out, SSL_get_SSL_CTX(con));
2406 #ifdef CHARSET_EBCDIC
2407 ebcdic2ascii(buf, buf, i);
2411 /* should do a select for the write */
2415 if (++count == 100) {
2417 SSL_renegotiate(con);
2421 k = SSL_write(con, &(buf[l]), (unsigned int)i);
2422 #ifndef OPENSSL_NO_SRP
2423 while (SSL_get_error(con, k) == SSL_ERROR_WANT_X509_LOOKUP) {
2424 BIO_printf(bio_s_out, "LOOKUP renego during write\n");
2425 srp_callback_parm.user =
2426 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2427 srp_callback_parm.login);
2428 if (srp_callback_parm.user)
2429 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2430 srp_callback_parm.user->info);
2432 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2433 k = SSL_write(con, &(buf[l]), (unsigned int)i);
2436 switch (SSL_get_error(con, k)) {
2437 case SSL_ERROR_NONE:
2439 case SSL_ERROR_WANT_WRITE:
2440 case SSL_ERROR_WANT_READ:
2441 case SSL_ERROR_WANT_X509_LOOKUP:
2442 BIO_printf(bio_s_out, "Write BLOCK\n");
2444 case SSL_ERROR_SYSCALL:
2446 BIO_printf(bio_s_out, "ERROR\n");
2447 ERR_print_errors(bio_err);
2451 case SSL_ERROR_ZERO_RETURN:
2452 BIO_printf(bio_s_out, "DONE\n");
2462 if (read_from_sslcon) {
2463 if (!SSL_is_init_finished(con)) {
2464 i = init_ssl_connection(con);
2469 } else if (i == 0) {
2475 i = SSL_read(con, (char *)buf, bufsize);
2476 #ifndef OPENSSL_NO_SRP
2477 while (SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2478 BIO_printf(bio_s_out, "LOOKUP renego during read\n");
2479 srp_callback_parm.user =
2480 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2481 srp_callback_parm.login);
2482 if (srp_callback_parm.user)
2483 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2484 srp_callback_parm.user->info);
2486 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2487 i = SSL_read(con, (char *)buf, bufsize);
2490 switch (SSL_get_error(con, i)) {
2491 case SSL_ERROR_NONE:
2492 #ifdef CHARSET_EBCDIC
2493 ascii2ebcdic(buf, buf, i);
2495 raw_write_stdout(buf, (unsigned int)i);
2496 if (SSL_pending(con))
2499 case SSL_ERROR_WANT_WRITE:
2500 case SSL_ERROR_WANT_READ:
2501 BIO_printf(bio_s_out, "Read BLOCK\n");
2503 case SSL_ERROR_SYSCALL:
2505 BIO_printf(bio_s_out, "ERROR\n");
2506 ERR_print_errors(bio_err);
2509 case SSL_ERROR_ZERO_RETURN:
2510 BIO_printf(bio_s_out, "DONE\n");
2519 BIO_printf(bio_s_out, "shutting down SSL\n");
2521 SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
2527 BIO_printf(bio_s_out, "CONNECTION CLOSED\n");
2529 OPENSSL_cleanse(buf, bufsize);
2533 BIO_printf(bio_s_out, "ACCEPT\n");
2537 static void close_accept_socket(void)
2539 BIO_printf(bio_err, "shutdown accept socket\n");
2540 if (accept_socket >= 0) {
2541 SHUTDOWN2(accept_socket);
2545 static int init_ssl_connection(SSL *con)
2551 MS_STATIC char buf[BUFSIZ];
2552 #ifndef OPENSSL_NO_KRB5
2555 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2556 const unsigned char *next_proto_neg;
2557 unsigned next_proto_neg_len;
2559 unsigned char *exportedkeymat;
2561 i = SSL_accept(con);
2562 #ifdef CERT_CB_TEST_RETRY
2564 while (i <= 0 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP
2565 && SSL_state(con) == SSL3_ST_SR_CLNT_HELLO_C) {
2567 "LOOKUP from certificate callback during accept\n");
2568 i = SSL_accept(con);
2572 #ifndef OPENSSL_NO_SRP
2573 while (i <= 0 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2574 BIO_printf(bio_s_out, "LOOKUP during accept %s\n",
2575 srp_callback_parm.login);
2576 srp_callback_parm.user =
2577 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2578 srp_callback_parm.login);
2579 if (srp_callback_parm.user)
2580 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2581 srp_callback_parm.user->info);
2583 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2584 i = SSL_accept(con);
2589 if (BIO_sock_should_retry(i)) {
2590 BIO_printf(bio_s_out, "DELAY\n");
2594 BIO_printf(bio_err, "ERROR\n");
2595 verify_error = SSL_get_verify_result(con);
2596 if (verify_error != X509_V_OK) {
2597 BIO_printf(bio_err, "verify error:%s\n",
2598 X509_verify_cert_error_string(verify_error));
2600 /* Always print any error messages */
2601 ERR_print_errors(bio_err);
2606 print_ssl_summary(bio_err, con);
2608 PEM_write_bio_SSL_SESSION(bio_s_out, SSL_get_session(con));
2610 peer = SSL_get_peer_certificate(con);
2612 BIO_printf(bio_s_out, "Client certificate\n");
2613 PEM_write_bio_X509(bio_s_out, peer);
2614 X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof buf);
2615 BIO_printf(bio_s_out, "subject=%s\n", buf);
2616 X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof buf);
2617 BIO_printf(bio_s_out, "issuer=%s\n", buf);
2621 if (SSL_get_shared_ciphers(con, buf, sizeof buf) != NULL)
2622 BIO_printf(bio_s_out, "Shared ciphers:%s\n", buf);
2623 str = SSL_CIPHER_get_name(SSL_get_current_cipher(con));
2624 ssl_print_sigalgs(bio_s_out, con);
2625 #ifndef OPENSSL_NO_EC
2626 ssl_print_point_formats(bio_s_out, con);
2627 ssl_print_curves(bio_s_out, con, 0);
2629 BIO_printf(bio_s_out, "CIPHER is %s\n", (str != NULL) ? str : "(NONE)");
2631 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2632 SSL_get0_next_proto_negotiated(con, &next_proto_neg, &next_proto_neg_len);
2633 if (next_proto_neg) {
2634 BIO_printf(bio_s_out, "NEXTPROTO is ");
2635 BIO_write(bio_s_out, next_proto_neg, next_proto_neg_len);
2636 BIO_printf(bio_s_out, "\n");
2639 #ifndef OPENSSL_NO_SRTP
2641 SRTP_PROTECTION_PROFILE *srtp_profile
2642 = SSL_get_selected_srtp_profile(con);
2645 BIO_printf(bio_s_out, "SRTP Extension negotiated, profile=%s\n",
2646 srtp_profile->name);
2649 if (SSL_cache_hit(con))
2650 BIO_printf(bio_s_out, "Reused session-id\n");
2651 if (SSL_ctrl(con, SSL_CTRL_GET_FLAGS, 0, NULL) &
2652 TLS1_FLAGS_TLS_PADDING_BUG)
2653 BIO_printf(bio_s_out, "Peer has incorrect TLSv1 block padding\n");
2654 #ifndef OPENSSL_NO_KRB5
2655 client_princ = kssl_ctx_get0_client_princ(SSL_get0_kssl_ctx(con));
2656 if (client_princ != NULL) {
2657 BIO_printf(bio_s_out, "Kerberos peer principal is %s\n",
2660 #endif /* OPENSSL_NO_KRB5 */
2661 BIO_printf(bio_s_out, "Secure Renegotiation IS%s supported\n",
2662 SSL_get_secure_renegotiation_support(con) ? "" : " NOT");
2663 if (keymatexportlabel != NULL) {
2664 BIO_printf(bio_s_out, "Keying material exporter:\n");
2665 BIO_printf(bio_s_out, " Label: '%s'\n", keymatexportlabel);
2666 BIO_printf(bio_s_out, " Length: %i bytes\n", keymatexportlen);
2667 exportedkeymat = OPENSSL_malloc(keymatexportlen);
2668 if (exportedkeymat != NULL) {
2669 if (!SSL_export_keying_material(con, exportedkeymat,
2672 strlen(keymatexportlabel),
2674 BIO_printf(bio_s_out, " Error\n");
2676 BIO_printf(bio_s_out, " Keying material: ");
2677 for (i = 0; i < keymatexportlen; i++)
2678 BIO_printf(bio_s_out, "%02X", exportedkeymat[i]);
2679 BIO_printf(bio_s_out, "\n");
2681 OPENSSL_free(exportedkeymat);
2688 #ifndef OPENSSL_NO_DH
2689 static DH *load_dh_param(const char *dhfile)
2694 if ((bio = BIO_new_file(dhfile, "r")) == NULL)
2696 ret = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
2703 #ifndef OPENSSL_NO_KRB5
2708 static int load_CA(SSL_CTX *ctx, char *file)
2713 if ((in = fopen(file, "r")) == NULL)
2717 if (PEM_read_X509(in, &x, NULL) == NULL)
2719 SSL_CTX_add_client_CA(ctx, x);
2728 static int www_body(char *hostname, int s, int stype, unsigned char *context)
2734 const SSL_CIPHER *c;
2735 BIO *io, *ssl_bio, *sbio;
2736 #ifndef OPENSSL_NO_KRB5
2740 buf = OPENSSL_malloc(bufsize);
2743 io = BIO_new(BIO_f_buffer());
2744 ssl_bio = BIO_new(BIO_f_ssl());
2745 if ((io == NULL) || (ssl_bio == NULL))
2750 unsigned long sl = 1;
2753 BIO_printf(bio_err, "turning on non blocking io\n");
2754 if (BIO_socket_ioctl(s, FIONBIO, &sl) < 0)
2755 ERR_print_errors(bio_err);
2759 /* lets make the output buffer a reasonable size */
2760 if (!BIO_set_write_buffer_size(io, bufsize))
2763 if ((con = SSL_new(ctx)) == NULL)
2765 #ifndef OPENSSL_NO_TLSEXT
2766 if (s_tlsextdebug) {
2767 SSL_set_tlsext_debug_callback(con, tlsext_cb);
2768 SSL_set_tlsext_debug_arg(con, bio_s_out);
2771 #ifndef OPENSSL_NO_KRB5
2772 if ((kctx = kssl_ctx_new()) != NULL) {
2773 kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
2774 kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
2776 #endif /* OPENSSL_NO_KRB5 */
2778 SSL_set_session_id_context(con, context, strlen((char *)context));
2780 sbio = BIO_new_socket(s, BIO_NOCLOSE);
2784 test = BIO_new(BIO_f_nbio_test());
2785 sbio = BIO_push(test, sbio);
2787 SSL_set_bio(con, sbio, sbio);
2788 SSL_set_accept_state(con);
2790 /* SSL_set_fd(con,s); */
2791 BIO_set_ssl(ssl_bio, con, BIO_CLOSE);
2792 BIO_push(io, ssl_bio);
2793 #ifdef CHARSET_EBCDIC
2794 io = BIO_push(BIO_new(BIO_f_ebcdic_filter()), io);
2798 SSL_set_debug(con, 1);
2799 BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
2800 BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
2803 #ifndef OPENSSL_NO_SSL_TRACE
2805 SSL_set_msg_callback(con, SSL_trace);
2808 SSL_set_msg_callback(con, msg_cb);
2809 SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
2814 i = SSL_accept(con);
2815 #ifndef OPENSSL_NO_SRP
2817 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2818 BIO_printf(bio_s_out, "LOOKUP during accept %s\n",
2819 srp_callback_parm.login);
2820 srp_callback_parm.user =
2821 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2822 srp_callback_parm.login);
2823 if (srp_callback_parm.user)
2824 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2825 srp_callback_parm.user->info);
2827 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2828 i = SSL_accept(con);
2831 switch (SSL_get_error(con, i)) {
2832 case SSL_ERROR_NONE:
2834 case SSL_ERROR_WANT_WRITE:
2835 case SSL_ERROR_WANT_READ:
2836 case SSL_ERROR_WANT_X509_LOOKUP:
2838 case SSL_ERROR_SYSCALL:
2840 case SSL_ERROR_ZERO_RETURN:
2846 SSL_renegotiate(con);
2847 SSL_write(con, NULL, 0);
2850 i = BIO_gets(io, buf, bufsize - 1);
2851 if (i < 0) { /* error */
2852 if (!BIO_should_retry(io)) {
2854 ERR_print_errors(bio_err);
2857 BIO_printf(bio_s_out, "read R BLOCK\n");
2858 #if defined(OPENSSL_SYS_NETWARE)
2860 #elif !defined(OPENSSL_SYS_MSDOS) && !defined(__DJGPP__)
2865 } else if (i == 0) { /* end of input */
2870 /* else we have data */
2871 if (((www == 1) && (strncmp("GET ", buf, 4) == 0)) ||
2872 ((www == 2) && (strncmp("GET /stats ", buf, 10) == 0))) {
2875 STACK_OF(SSL_CIPHER) *sk;
2876 static const char *space = " ";
2879 "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
2880 BIO_puts(io, "<HTML><BODY BGCOLOR=\"#ffffff\">\n");
2881 BIO_puts(io, "<pre>\n");
2882 /* BIO_puts(io,SSLeay_version(SSLEAY_VERSION));*/
2884 for (i = 0; i < local_argc; i++) {
2885 BIO_puts(io, local_argv[i]);
2886 BIO_write(io, " ", 1);
2891 "Secure Renegotiation IS%s supported\n",
2892 SSL_get_secure_renegotiation_support(con) ?
2896 * The following is evil and should not really be done
2898 BIO_printf(io, "Ciphers supported in s_server binary\n");
2899 sk = SSL_get_ciphers(con);
2900 j = sk_SSL_CIPHER_num(sk);
2901 for (i = 0; i < j; i++) {
2902 c = sk_SSL_CIPHER_value(sk, i);
2903 BIO_printf(io, "%-11s:%-25s",
2904 SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2905 if ((((i + 1) % 2) == 0) && (i + 1 != j))
2909 p = SSL_get_shared_ciphers(con, buf, bufsize);
2912 "---\nCiphers common between both SSL end points:\n");
2916 BIO_write(io, space, 26 - j);
2919 BIO_write(io, ((i % 3) ? " " : "\n"), 1);
2921 BIO_write(io, p, 1);
2928 ssl_print_sigalgs(io, con);
2929 #ifndef OPENSSL_NO_EC
2930 ssl_print_curves(io, con, 0);
2932 BIO_printf(io, (SSL_cache_hit(con)
2933 ? "---\nReused, " : "---\nNew, "));
2934 c = SSL_get_current_cipher(con);
2935 BIO_printf(io, "%s, Cipher is %s\n",
2936 SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2937 SSL_SESSION_print(io, SSL_get_session(con));
2938 BIO_printf(io, "---\n");
2939 print_stats(io, SSL_get_SSL_CTX(con));
2940 BIO_printf(io, "---\n");
2941 peer = SSL_get_peer_certificate(con);
2943 BIO_printf(io, "Client certificate\n");
2944 X509_print(io, peer);
2945 PEM_write_bio_X509(io, peer);
2947 BIO_puts(io, "no client certificate available\n");
2948 BIO_puts(io, "</BODY></HTML>\r\n\r\n");
2950 } else if ((www == 2 || www == 3)
2951 && (strncmp("GET /", buf, 5) == 0)) {
2954 static const char *text =
2955 "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n";
2961 for (e = p; *e != '\0'; e++) {
2967 dot = (e[0] == '.') ? 2 : 0;
2970 dot = (e[0] == '.') ? 3 : 0;
2973 dot = (e[0] == '/') ? -1 : 0;
2977 dot = (e[0] == '/') ? 1 : 0;
2979 dot = (dot == 3) || (dot == -1); /* filename contains ".."
2984 BIO_printf(io, "'%s' is an invalid file name\r\n", p);
2991 BIO_printf(io, "'%s' contains '..' reference\r\n", p);
2997 BIO_printf(io, "'%s' is an invalid path\r\n", p);
3001 /* append if a directory lookup */
3003 strcat(p, "index.html");
3006 /* if a directory, do the index thang */
3007 if (app_isdir(p) > 0) {
3008 #if 0 /* must check buffer size */
3009 strcat(p, "/index.html");
3012 BIO_printf(io, "'%s' is a directory\r\n", p);
3017 if ((file = BIO_new_file(p, "r")) == NULL) {
3019 BIO_printf(io, "Error opening '%s'\r\n", p);
3020 ERR_print_errors(io);
3025 BIO_printf(bio_err, "FILE:%s\n", p);
3029 if (((i > 5) && (strcmp(&(p[i - 5]), ".html") == 0)) ||
3030 ((i > 4) && (strcmp(&(p[i - 4]), ".php") == 0)) ||
3031 ((i > 4) && (strcmp(&(p[i - 4]), ".htm") == 0)))
3033 "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
3036 "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n");
3040 i = BIO_read(file, buf, bufsize);
3046 fprintf(stderr, "%d\n", i);
3047 if (total_bytes > 3 * 1024) {
3049 fprintf(stderr, "RENEGOTIATE\n");
3050 SSL_renegotiate(con);
3054 for (j = 0; j < i;) {
3058 if (++count == 13) {
3059 SSL_renegotiate(con);
3063 k = BIO_write(io, &(buf[j]), i - j);
3065 if (!BIO_should_retry(io))
3068 BIO_printf(bio_s_out, "rwrite W BLOCK\n");
3082 i = (int)BIO_flush(io);
3084 if (!BIO_should_retry(io))
3091 /* make sure we re-use sessions */
3092 SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
3094 /* This kills performance */
3096 * SSL_shutdown(con); A shutdown gets sent in the BIO_free_all(io)
3104 BIO_printf(bio_s_out, "ACCEPT\n");
3110 /* if (ssl_bio != NULL) BIO_free(ssl_bio);*/
3114 static int rev_body(char *hostname, int s, int stype, unsigned char *context)
3120 BIO *io, *ssl_bio, *sbio;
3121 #ifndef OPENSSL_NO_KRB5
3125 buf = OPENSSL_malloc(bufsize);
3128 io = BIO_new(BIO_f_buffer());
3129 ssl_bio = BIO_new(BIO_f_ssl());
3130 if ((io == NULL) || (ssl_bio == NULL))
3133 /* lets make the output buffer a reasonable size */
3134 if (!BIO_set_write_buffer_size(io, bufsize))
3137 if ((con = SSL_new(ctx)) == NULL)
3139 #ifndef OPENSSL_NO_TLSEXT
3140 if (s_tlsextdebug) {
3141 SSL_set_tlsext_debug_callback(con, tlsext_cb);
3142 SSL_set_tlsext_debug_arg(con, bio_s_out);
3145 #ifndef OPENSSL_NO_KRB5
3146 if ((kctx = kssl_ctx_new()) != NULL) {
3147 kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
3148 kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
3150 #endif /* OPENSSL_NO_KRB5 */
3152 SSL_set_session_id_context(con, context, strlen((char *)context));
3154 sbio = BIO_new_socket(s, BIO_NOCLOSE);
3155 SSL_set_bio(con, sbio, sbio);
3156 SSL_set_accept_state(con);
3158 BIO_set_ssl(ssl_bio, con, BIO_CLOSE);
3159 BIO_push(io, ssl_bio);
3160 #ifdef CHARSET_EBCDIC
3161 io = BIO_push(BIO_new(BIO_f_ebcdic_filter()), io);
3165 SSL_set_debug(con, 1);
3166 BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
3167 BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
3170 #ifndef OPENSSL_NO_SSL_TRACE
3172 SSL_set_msg_callback(con, SSL_trace);
3175 SSL_set_msg_callback(con, msg_cb);
3176 SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
3180 i = BIO_do_handshake(io);
3183 if (!BIO_should_retry(io)) {
3184 BIO_puts(bio_err, "CONNECTION FAILURE\n");
3185 ERR_print_errors(bio_err);
3189 BIO_printf(bio_err, "CONNECTION ESTABLISHED\n");
3190 print_ssl_summary(bio_err, con);
3193 i = BIO_gets(io, buf, bufsize - 1);
3194 if (i < 0) { /* error */
3195 if (!BIO_should_retry(io)) {
3197 ERR_print_errors(bio_err);
3200 BIO_printf(bio_s_out, "read R BLOCK\n");
3201 #if defined(OPENSSL_SYS_NETWARE)
3203 #elif !defined(OPENSSL_SYS_MSDOS) && !defined(__DJGPP__)
3208 } else if (i == 0) { /* end of input */
3210 BIO_printf(bio_err, "CONNECTION CLOSED\n");
3213 char *p = buf + i - 1;
3214 while (i && (*p == '\n' || *p == '\r')) {
3218 if (!s_ign_eof && i == 5 && !strncmp(buf, "CLOSE", 5)) {
3220 BIO_printf(bio_err, "CONNECTION CLOSED\n");
3223 BUF_reverse((unsigned char *)buf, NULL, i);
3225 BIO_write(io, buf, i + 1);
3230 if (!BIO_should_retry(io))
3236 /* make sure we re-use sessions */
3237 SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
3248 #ifndef OPENSSL_NO_RSA
3249 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
3252 static RSA *rsa_tmp = NULL;
3254 if (!rsa_tmp && ((bn = BN_new()) == NULL))
3255 BIO_printf(bio_err, "Allocation error in generating RSA key\n");
3256 if (!rsa_tmp && bn) {
3258 BIO_printf(bio_err, "Generating temp (%d bit) RSA key...",
3260 (void)BIO_flush(bio_err);
3262 if (!BN_set_word(bn, RSA_F4) || ((rsa_tmp = RSA_new()) == NULL) ||
3263 !RSA_generate_key_ex(rsa_tmp, keylength, bn, NULL)) {
3269 BIO_printf(bio_err, "\n");
3270 (void)BIO_flush(bio_err);
3278 #define MAX_SESSION_ID_ATTEMPTS 10
3279 static int generate_session_id(const SSL *ssl, unsigned char *id,
3280 unsigned int *id_len)
3282 unsigned int count = 0;
3284 RAND_pseudo_bytes(id, *id_len);
3286 * Prefix the session_id with the required prefix. NB: If our prefix
3287 * is too long, clip it - but there will be worse effects anyway, eg.
3288 * the server could only possibly create 1 session ID (ie. the
3289 * prefix!) so all future session negotiations will fail due to
3292 memcpy(id, session_id_prefix,
3293 (strlen(session_id_prefix) < *id_len) ?
3294 strlen(session_id_prefix) : *id_len);
3296 while (SSL_has_matching_session_id(ssl, id, *id_len) &&
3297 (++count < MAX_SESSION_ID_ATTEMPTS));
3298 if (count >= MAX_SESSION_ID_ATTEMPTS)
3304 * By default s_server uses an in-memory cache which caches SSL_SESSION
3305 * structures without any serialisation. This hides some bugs which only
3306 * become apparent in deployed servers. By implementing a basic external
3307 * session cache some issues can be debugged using s_server.
3310 typedef struct simple_ssl_session_st {
3315 struct simple_ssl_session_st *next;
3316 } simple_ssl_session;
3318 static simple_ssl_session *first = NULL;
3320 static int add_session(SSL *ssl, SSL_SESSION *session)
3322 simple_ssl_session *sess;
3325 sess = OPENSSL_malloc(sizeof(simple_ssl_session));
3327 BIO_printf(bio_err, "Out of memory adding session to external cache\n");
3331 SSL_SESSION_get_id(session, &sess->idlen);
3332 sess->derlen = i2d_SSL_SESSION(session, NULL);
3334 sess->id = BUF_memdup(SSL_SESSION_get_id(session, NULL), sess->idlen);
3336 sess->der = OPENSSL_malloc(sess->derlen);
3337 if(!sess->id || !sess->der) {
3338 BIO_printf(bio_err, "Out of memory adding session to external cache\n");
3341 OPENSSL_free(sess->id);
3343 OPENSSL_free(sess->der);
3348 i2d_SSL_SESSION(session, &p);
3352 BIO_printf(bio_err, "New session added to external cache\n");
3356 static SSL_SESSION *get_session(SSL *ssl, unsigned char *id, int idlen,
3359 simple_ssl_session *sess;
3361 for (sess = first; sess; sess = sess->next) {
3362 if (idlen == (int)sess->idlen && !memcmp(sess->id, id, idlen)) {
3363 const unsigned char *p = sess->der;
3364 BIO_printf(bio_err, "Lookup session: cache hit\n");
3365 return d2i_SSL_SESSION(NULL, &p, sess->derlen);
3368 BIO_printf(bio_err, "Lookup session: cache miss\n");
3372 static void del_session(SSL_CTX *sctx, SSL_SESSION *session)
3374 simple_ssl_session *sess, *prev = NULL;
3375 const unsigned char *id;
3377 id = SSL_SESSION_get_id(session, &idlen);
3378 for (sess = first; sess; sess = sess->next) {
3379 if (idlen == sess->idlen && !memcmp(sess->id, id, idlen)) {
3381 prev->next = sess->next;
3384 OPENSSL_free(sess->id);
3385 OPENSSL_free(sess->der);
3393 static void init_session_cache_ctx(SSL_CTX *sctx)
3395 SSL_CTX_set_session_cache_mode(sctx,
3396 SSL_SESS_CACHE_NO_INTERNAL |
3397 SSL_SESS_CACHE_SERVER);
3398 SSL_CTX_sess_set_new_cb(sctx, add_session);
3399 SSL_CTX_sess_set_get_cb(sctx, get_session);
3400 SSL_CTX_sess_set_remove_cb(sctx, del_session);
3403 static void free_sessions(void)
3405 simple_ssl_session *sess, *tsess;
3406 for (sess = first; sess;) {
3407 OPENSSL_free(sess->id);
3408 OPENSSL_free(sess->der);
3411 OPENSSL_free(tsess);