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 (int)strlen(identity), 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 " -no_alt_chains - only ever use the first certificate chain found\n");
559 " -nocert - Don't use any certificates (Anon-DH)\n");
561 " -cipher arg - play with 'openssl ciphers' to see what goes here\n");
562 BIO_printf(bio_err, " -serverpref - Use server's cipher preferences\n");
563 BIO_printf(bio_err, " -quiet - No server output\n");
564 BIO_printf(bio_err, " -no_tmp_rsa - Do not generate a tmp RSA key\n");
565 #ifndef OPENSSL_NO_PSK
566 BIO_printf(bio_err, " -psk_hint arg - PSK identity hint to use\n");
567 BIO_printf(bio_err, " -psk arg - PSK in hex (without 0x)\n");
568 # ifndef OPENSSL_NO_JPAKE
569 BIO_printf(bio_err, " -jpake arg - JPAKE secret to use\n");
572 #ifndef OPENSSL_NO_SRP
573 BIO_printf(bio_err, " -srpvfile file - The verifier file for SRP\n");
575 " -srpuserseed string - A seed string for a default user salt.\n");
577 BIO_printf(bio_err, " -ssl2 - Just talk SSLv2\n");
578 #ifndef OPENSSL_NO_SSL3_METHOD
579 BIO_printf(bio_err, " -ssl3 - Just talk SSLv3\n");
581 BIO_printf(bio_err, " -tls1_2 - Just talk TLSv1.2\n");
582 BIO_printf(bio_err, " -tls1_1 - Just talk TLSv1.1\n");
583 BIO_printf(bio_err, " -tls1 - Just talk TLSv1\n");
584 BIO_printf(bio_err, " -dtls1 - Just talk DTLSv1\n");
585 BIO_printf(bio_err, " -dtls1_2 - Just talk DTLSv1.2\n");
586 BIO_printf(bio_err, " -timeout - Enable timeouts\n");
587 BIO_printf(bio_err, " -mtu - Set link layer MTU\n");
588 BIO_printf(bio_err, " -chain - Read a certificate chain\n");
589 BIO_printf(bio_err, " -no_ssl2 - Just disable SSLv2\n");
590 BIO_printf(bio_err, " -no_ssl3 - Just disable SSLv3\n");
591 BIO_printf(bio_err, " -no_tls1 - Just disable TLSv1\n");
592 BIO_printf(bio_err, " -no_tls1_1 - Just disable TLSv1.1\n");
593 BIO_printf(bio_err, " -no_tls1_2 - Just disable TLSv1.2\n");
594 #ifndef OPENSSL_NO_DH
595 BIO_printf(bio_err, " -no_dhe - Disable ephemeral DH\n");
597 #ifndef OPENSSL_NO_ECDH
598 BIO_printf(bio_err, " -no_ecdhe - Disable ephemeral ECDH\n");
600 BIO_printf(bio_err, " -bugs - Turn on SSL bug compatibility\n");
602 " -hack - workaround for early Netscape code\n");
604 " -www - Respond to a 'GET /' with a status page\n");
606 " -WWW - Respond to a 'GET /<path> HTTP/1.0' with file ./<path>\n");
608 " -HTTP - Respond to a 'GET /<path> HTTP/1.0' with file ./<path>\n");
610 " with the assumption it contains a complete HTTP response.\n");
611 #ifndef OPENSSL_NO_ENGINE
613 " -engine id - Initialise and use the specified engine\n");
616 " -id_prefix arg - Generate SSL/TLS session IDs prefixed by 'arg'\n");
617 BIO_printf(bio_err, " -rand file%cfile%c...\n", LIST_SEPARATOR_CHAR,
618 LIST_SEPARATOR_CHAR);
619 #ifndef OPENSSL_NO_TLSEXT
621 " -servername host - servername for HostName TLS extension\n");
623 " -servername_fatal - on mismatch send fatal alert (default warning alert)\n");
625 " -cert2 arg - certificate file to use for servername\n");
626 BIO_printf(bio_err, " (default is %s)\n", TEST_CERT2);
628 " -key2 arg - Private Key file to use for servername, in cert file if\n");
629 BIO_printf(bio_err, " not specified (default is %s)\n",
632 " -tlsextdebug - hex dump of all TLS extensions received\n");
634 " -no_ticket - disable use of RFC4507bis session tickets\n");
636 " -legacy_renegotiation - enable use of legacy renegotiation (dangerous)\n");
637 # ifndef OPENSSL_NO_NEXTPROTONEG
639 " -nextprotoneg arg - set the advertised protocols for the NPN extension (comma-separated list)\n");
641 # ifndef OPENSSL_NO_SRTP
643 " -use_srtp profiles - Offer SRTP key management with a colon-separated profile list\n");
646 " -alpn arg - set the advertised protocols for the ALPN extension (comma-separated list)\n");
649 " -keymatexport label - Export keying material using label\n");
651 " -keymatexportlen len - Export len bytes of keying material (default 20)\n");
653 " -status - respond to certificate status requests\n");
655 " -status_verbose - enable status request verbose printout\n");
657 " -status_timeout n - status request responder timeout\n");
658 BIO_printf(bio_err, " -status_url URL - status request fallback URL\n");
661 static int local_argc = 0;
662 static char **local_argv;
664 #ifdef CHARSET_EBCDIC
665 static int ebcdic_new(BIO *bi);
666 static int ebcdic_free(BIO *a);
667 static int ebcdic_read(BIO *b, char *out, int outl);
668 static int ebcdic_write(BIO *b, const char *in, int inl);
669 static long ebcdic_ctrl(BIO *b, int cmd, long num, void *ptr);
670 static int ebcdic_gets(BIO *bp, char *buf, int size);
671 static int ebcdic_puts(BIO *bp, const char *str);
673 # define BIO_TYPE_EBCDIC_FILTER (18|0x0200)
674 static BIO_METHOD methods_ebcdic = {
675 BIO_TYPE_EBCDIC_FILTER,
676 "EBCDIC/ASCII filter",
691 BIO_METHOD *BIO_f_ebcdic_filter()
693 return (&methods_ebcdic);
696 static int ebcdic_new(BIO *bi)
698 EBCDIC_OUTBUFF *wbuf;
700 wbuf = (EBCDIC_OUTBUFF *) OPENSSL_malloc(sizeof(EBCDIC_OUTBUFF) + 1024);
703 wbuf->alloced = 1024;
704 wbuf->buff[0] = '\0';
706 bi->ptr = (char *)wbuf;
712 static int ebcdic_free(BIO *a)
717 OPENSSL_free(a->ptr);
724 static int ebcdic_read(BIO *b, char *out, int outl)
728 if (out == NULL || outl == 0)
730 if (b->next_bio == NULL)
733 ret = BIO_read(b->next_bio, out, outl);
735 ascii2ebcdic(out, out, ret);
739 static int ebcdic_write(BIO *b, const char *in, int inl)
741 EBCDIC_OUTBUFF *wbuf;
746 if ((in == NULL) || (inl <= 0))
748 if (b->next_bio == NULL)
751 wbuf = (EBCDIC_OUTBUFF *) b->ptr;
753 if (inl > (num = wbuf->alloced)) {
754 num = num + num; /* double the size */
758 (EBCDIC_OUTBUFF *) OPENSSL_malloc(sizeof(EBCDIC_OUTBUFF) + num);
761 OPENSSL_free(b->ptr);
764 wbuf->buff[0] = '\0';
766 b->ptr = (char *)wbuf;
769 ebcdic2ascii(wbuf->buff, in, inl);
771 ret = BIO_write(b->next_bio, wbuf->buff, inl);
776 static long ebcdic_ctrl(BIO *b, int cmd, long num, void *ptr)
780 if (b->next_bio == NULL)
787 ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
793 static int ebcdic_gets(BIO *bp, char *buf, int size)
796 if (bp->next_bio == NULL)
798 /* return(BIO_gets(bp->next_bio,buf,size));*/
799 for (i = 0; i < size - 1; ++i) {
800 ret = ebcdic_read(bp, &buf[i], 1);
803 else if (buf[i] == '\n') {
810 return (ret < 0 && i == 0) ? ret : i;
813 static int ebcdic_puts(BIO *bp, const char *str)
815 if (bp->next_bio == NULL)
817 return ebcdic_write(bp, str, strlen(str));
821 #ifndef OPENSSL_NO_TLSEXT
823 /* This is a context that we pass to callbacks */
824 typedef struct tlsextctx_st {
830 static int MS_CALLBACK ssl_servername_cb(SSL *s, int *ad, void *arg)
832 tlsextctx *p = (tlsextctx *) arg;
833 const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
834 if (servername && p->biodebug)
835 BIO_printf(p->biodebug, "Hostname in TLS extension: \"%s\"\n",
839 return SSL_TLSEXT_ERR_NOACK;
842 if (strcasecmp(servername, p->servername))
843 return p->extension_error;
845 BIO_printf(p->biodebug, "Switching server context.\n");
846 SSL_set_SSL_CTX(s, ctx2);
849 return SSL_TLSEXT_ERR_OK;
852 /* Structure passed to cert status callback */
854 typedef struct tlsextstatusctx_st {
855 /* Default responder to use */
856 char *host, *path, *port;
863 static tlsextstatusctx tlscstatp = { NULL, NULL, NULL, 0, -1, NULL, 0 };
866 * Certificate Status callback. This is called when a client includes a
867 * certificate status request extension. This is a simplified version. It
868 * examines certificates each time and makes one OCSP responder query for
869 * each request. A full version would store details such as the OCSP
870 * certificate IDs and minimise the number of OCSP responses by caching them
871 * until they were considered "expired".
874 static int cert_status_cb(SSL *s, void *arg)
876 tlsextstatusctx *srctx = arg;
877 BIO *err = srctx->err;
878 char *host, *port, *path;
880 unsigned char *rspder = NULL;
882 STACK_OF(OPENSSL_STRING) *aia = NULL;
884 X509_STORE_CTX inctx;
886 OCSP_REQUEST *req = NULL;
887 OCSP_RESPONSE *resp = NULL;
888 OCSP_CERTID *id = NULL;
889 STACK_OF(X509_EXTENSION) *exts;
890 int ret = SSL_TLSEXT_ERR_NOACK;
893 STACK_OF(OCSP_RESPID) *ids;
894 SSL_get_tlsext_status_ids(s, &ids);
895 BIO_printf(err, "cert_status: received %d ids\n",
896 sk_OCSP_RESPID_num(ids));
899 BIO_puts(err, "cert_status: callback called\n");
900 /* Build up OCSP query from server certificate */
901 x = SSL_get_certificate(s);
902 aia = X509_get1_ocsp(x);
904 if (!OCSP_parse_url(sk_OPENSSL_STRING_value(aia, 0),
905 &host, &port, &path, &use_ssl)) {
906 BIO_puts(err, "cert_status: can't parse AIA URL\n");
910 BIO_printf(err, "cert_status: AIA URL: %s\n",
911 sk_OPENSSL_STRING_value(aia, 0));
915 "cert_status: no AIA and no default responder URL\n");
921 use_ssl = srctx->use_ssl;
924 if (!X509_STORE_CTX_init(&inctx,
925 SSL_CTX_get_cert_store(SSL_get_SSL_CTX(s)),
928 if (X509_STORE_get_by_subject(&inctx, X509_LU_X509,
929 X509_get_issuer_name(x), &obj) <= 0) {
930 BIO_puts(err, "cert_status: Can't retrieve issuer certificate.\n");
931 X509_STORE_CTX_cleanup(&inctx);
934 req = OCSP_REQUEST_new();
937 id = OCSP_cert_to_id(NULL, x, obj.data.x509);
938 X509_free(obj.data.x509);
939 X509_STORE_CTX_cleanup(&inctx);
942 if (!OCSP_request_add0_id(req, id))
945 /* Add any extensions to the request */
946 SSL_get_tlsext_status_exts(s, &exts);
947 for (i = 0; i < sk_X509_EXTENSION_num(exts); i++) {
948 X509_EXTENSION *ext = sk_X509_EXTENSION_value(exts, i);
949 if (!OCSP_REQUEST_add_ext(req, ext, -1))
952 resp = process_responder(err, req, host, path, port, use_ssl, NULL,
955 BIO_puts(err, "cert_status: error querying responder\n");
958 rspderlen = i2d_OCSP_RESPONSE(resp, &rspder);
961 SSL_set_tlsext_status_ocsp_resp(s, rspder, rspderlen);
962 if (srctx->verbose) {
963 BIO_puts(err, "cert_status: ocsp response sent:\n");
964 OCSP_RESPONSE_print(err, resp, 2);
966 ret = SSL_TLSEXT_ERR_OK;
968 if (ret != SSL_TLSEXT_ERR_OK)
969 ERR_print_errors(err);
974 X509_email_free(aia);
977 OCSP_CERTID_free(id);
979 OCSP_REQUEST_free(req);
981 OCSP_RESPONSE_free(resp);
984 ret = SSL_TLSEXT_ERR_ALERT_FATAL;
988 # ifndef OPENSSL_NO_NEXTPROTONEG
989 /* This is the context that we pass to next_proto_cb */
990 typedef struct tlsextnextprotoctx_st {
993 } tlsextnextprotoctx;
995 static int next_proto_cb(SSL *s, const unsigned char **data,
996 unsigned int *len, void *arg)
998 tlsextnextprotoctx *next_proto = arg;
1000 *data = next_proto->data;
1001 *len = next_proto->len;
1003 return SSL_TLSEXT_ERR_OK;
1005 # endif /* ndef OPENSSL_NO_NEXTPROTONEG */
1007 /* This the context that we pass to alpn_cb */
1008 typedef struct tlsextalpnctx_st {
1009 unsigned char *data;
1013 static int alpn_cb(SSL *s, const unsigned char **out, unsigned char *outlen,
1014 const unsigned char *in, unsigned int inlen, void *arg)
1016 tlsextalpnctx *alpn_ctx = arg;
1019 /* We can assume that |in| is syntactically valid. */
1021 BIO_printf(bio_s_out, "ALPN protocols advertised by the client: ");
1022 for (i = 0; i < inlen;) {
1024 BIO_write(bio_s_out, ", ", 2);
1025 BIO_write(bio_s_out, &in[i + 1], in[i]);
1028 BIO_write(bio_s_out, "\n", 1);
1031 if (SSL_select_next_proto
1032 ((unsigned char **)out, outlen, alpn_ctx->data, alpn_ctx->len, in,
1033 inlen) != OPENSSL_NPN_NEGOTIATED) {
1034 return SSL_TLSEXT_ERR_NOACK;
1038 BIO_printf(bio_s_out, "ALPN protocols selected: ");
1039 BIO_write(bio_s_out, *out, *outlen);
1040 BIO_write(bio_s_out, "\n", 1);
1043 return SSL_TLSEXT_ERR_OK;
1045 #endif /* ndef OPENSSL_NO_TLSEXT */
1047 int MAIN(int, char **);
1049 #ifndef OPENSSL_NO_JPAKE
1050 static char *jpake_secret = NULL;
1051 # define no_jpake !jpake_secret
1055 #ifndef OPENSSL_NO_SRP
1056 static srpsrvparm srp_callback_parm;
1058 #ifndef OPENSSL_NO_SRTP
1059 static char *srtp_profiles = NULL;
1062 int MAIN(int argc, char *argv[])
1064 X509_VERIFY_PARAM *vpm = NULL;
1067 char *CApath = NULL, *CAfile = NULL;
1068 char *chCApath = NULL, *chCAfile = NULL;
1069 char *vfyCApath = NULL, *vfyCAfile = NULL;
1070 unsigned char *context = NULL;
1071 char *dhfile = NULL;
1074 int build_chain = 0;
1075 int no_tmp_rsa = 0, no_dhe = 0, no_ecdhe = 0, nocert = 0;
1077 const SSL_METHOD *meth = NULL;
1078 int socket_type = SOCK_STREAM;
1080 char *inrand = NULL;
1081 int s_cert_format = FORMAT_PEM, s_key_format = FORMAT_PEM;
1082 char *passarg = NULL, *pass = NULL;
1083 char *dpassarg = NULL, *dpass = NULL;
1084 int s_dcert_format = FORMAT_PEM, s_dkey_format = FORMAT_PEM;
1085 X509 *s_cert = NULL, *s_dcert = NULL;
1086 STACK_OF(X509) *s_chain = NULL, *s_dchain = NULL;
1087 EVP_PKEY *s_key = NULL, *s_dkey = NULL;
1088 int no_cache = 0, ext_cache = 0;
1089 int rev = 0, naccept = -1;
1090 #ifndef OPENSSL_NO_TLSEXT
1091 EVP_PKEY *s_key2 = NULL;
1092 X509 *s_cert2 = NULL;
1093 tlsextctx tlsextcbp = { NULL, NULL, SSL_TLSEXT_ERR_ALERT_WARNING };
1094 # ifndef OPENSSL_NO_NEXTPROTONEG
1095 const char *next_proto_neg_in = NULL;
1096 tlsextnextprotoctx next_proto = { NULL, 0 };
1098 const char *alpn_in = NULL;
1099 tlsextalpnctx alpn_ctx = { NULL, 0 };
1101 #ifndef OPENSSL_NO_PSK
1102 /* by default do not send a PSK identity hint */
1103 static char *psk_identity_hint = NULL;
1105 #ifndef OPENSSL_NO_SRP
1106 char *srpuserseed = NULL;
1107 char *srp_verifier_file = NULL;
1109 SSL_EXCERT *exc = NULL;
1110 SSL_CONF_CTX *cctx = NULL;
1111 STACK_OF(OPENSSL_STRING) *ssl_args = NULL;
1113 char *crl_file = NULL;
1114 int crl_format = FORMAT_PEM;
1115 int crl_download = 0;
1116 STACK_OF(X509_CRL) *crls = NULL;
1118 meth = SSLv23_server_method();
1128 if (bio_err == NULL)
1129 bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);
1131 if (!load_config(bio_err, NULL))
1134 cctx = SSL_CONF_CTX_new();
1137 SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_SERVER);
1138 SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CMDLINE);
1150 if ((strcmp(*argv, "-port") == 0) || (strcmp(*argv, "-accept") == 0)) {
1153 if (!extract_port(*(++argv), &port))
1155 } else if (strcmp(*argv, "-naccept") == 0) {
1158 naccept = atol(*(++argv));
1160 BIO_printf(bio_err, "bad accept value %s\n", *argv);
1163 } else if (strcmp(*argv, "-verify") == 0) {
1164 s_server_verify = SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE;
1167 verify_depth = atoi(*(++argv));
1169 BIO_printf(bio_err, "verify depth is %d\n", verify_depth);
1170 } else if (strcmp(*argv, "-Verify") == 0) {
1172 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT |
1173 SSL_VERIFY_CLIENT_ONCE;
1176 verify_depth = atoi(*(++argv));
1179 "verify depth is %d, must return a certificate\n",
1181 } else if (strcmp(*argv, "-context") == 0) {
1184 context = (unsigned char *)*(++argv);
1185 } else if (strcmp(*argv, "-cert") == 0) {
1188 s_cert_file = *(++argv);
1189 } else if (strcmp(*argv, "-CRL") == 0) {
1192 crl_file = *(++argv);
1193 } else if (strcmp(*argv, "-crl_download") == 0)
1195 #ifndef OPENSSL_NO_TLSEXT
1196 else if (strcmp(*argv, "-serverinfo") == 0) {
1199 s_serverinfo_file = *(++argv);
1202 else if (strcmp(*argv, "-certform") == 0) {
1205 s_cert_format = str2fmt(*(++argv));
1206 } else if (strcmp(*argv, "-key") == 0) {
1209 s_key_file = *(++argv);
1210 } else if (strcmp(*argv, "-keyform") == 0) {
1213 s_key_format = str2fmt(*(++argv));
1214 } else if (strcmp(*argv, "-pass") == 0) {
1217 passarg = *(++argv);
1218 } else if (strcmp(*argv, "-cert_chain") == 0) {
1221 s_chain_file = *(++argv);
1222 } else if (strcmp(*argv, "-dhparam") == 0) {
1226 } else if (strcmp(*argv, "-dcertform") == 0) {
1229 s_dcert_format = str2fmt(*(++argv));
1230 } else if (strcmp(*argv, "-dcert") == 0) {
1233 s_dcert_file = *(++argv);
1234 } else if (strcmp(*argv, "-dkeyform") == 0) {
1237 s_dkey_format = str2fmt(*(++argv));
1238 } else if (strcmp(*argv, "-dpass") == 0) {
1241 dpassarg = *(++argv);
1242 } else if (strcmp(*argv, "-dkey") == 0) {
1245 s_dkey_file = *(++argv);
1246 } else if (strcmp(*argv, "-dcert_chain") == 0) {
1249 s_dchain_file = *(++argv);
1250 } else if (strcmp(*argv, "-nocert") == 0) {
1252 } else if (strcmp(*argv, "-CApath") == 0) {
1256 } else if (strcmp(*argv, "-chainCApath") == 0) {
1259 chCApath = *(++argv);
1260 } else if (strcmp(*argv, "-verifyCApath") == 0) {
1263 vfyCApath = *(++argv);
1264 } else if (strcmp(*argv, "-no_cache") == 0)
1266 else if (strcmp(*argv, "-ext_cache") == 0)
1268 else if (strcmp(*argv, "-CRLform") == 0) {
1271 crl_format = str2fmt(*(++argv));
1272 } else if (args_verify(&argv, &argc, &badarg, bio_err, &vpm)) {
1276 } else if (args_excert(&argv, &argc, &badarg, bio_err, &exc)) {
1280 } else if (args_ssl(&argv, &argc, cctx, &badarg, bio_err, &ssl_args)) {
1284 } else if (strcmp(*argv, "-verify_return_error") == 0)
1285 verify_return_error = 1;
1286 else if (strcmp(*argv, "-verify_quiet") == 0)
1288 else if (strcmp(*argv, "-build_chain") == 0)
1290 else if (strcmp(*argv, "-CAfile") == 0) {
1294 } else if (strcmp(*argv, "-chainCAfile") == 0) {
1297 chCAfile = *(++argv);
1298 } else if (strcmp(*argv, "-verifyCAfile") == 0) {
1301 vfyCAfile = *(++argv);
1304 else if (strcmp(*argv, "-nbio") == 0) {
1308 else if (strcmp(*argv, "-nbio_test") == 0) {
1313 } else if (strcmp(*argv, "-ign_eof") == 0)
1315 else if (strcmp(*argv, "-no_ign_eof") == 0)
1317 else if (strcmp(*argv, "-debug") == 0) {
1320 #ifndef OPENSSL_NO_TLSEXT
1321 else if (strcmp(*argv, "-tlsextdebug") == 0)
1323 else if (strcmp(*argv, "-status") == 0)
1325 else if (strcmp(*argv, "-status_verbose") == 0) {
1327 tlscstatp.verbose = 1;
1328 } else if (!strcmp(*argv, "-status_timeout")) {
1332 tlscstatp.timeout = atoi(*(++argv));
1333 } else if (!strcmp(*argv, "-status_url")) {
1337 if (!OCSP_parse_url(*(++argv),
1340 &tlscstatp.path, &tlscstatp.use_ssl)) {
1341 BIO_printf(bio_err, "Error parsing URL\n");
1346 else if (strcmp(*argv, "-msg") == 0) {
1348 } else if (strcmp(*argv, "-msgfile") == 0) {
1351 bio_s_msg = BIO_new_file(*(++argv), "w");
1353 #ifndef OPENSSL_NO_SSL_TRACE
1354 else if (strcmp(*argv, "-trace") == 0) {
1358 else if (strcmp(*argv, "-hack") == 0) {
1360 } else if (strcmp(*argv, "-state") == 0) {
1362 } else if (strcmp(*argv, "-crlf") == 0) {
1364 } else if (strcmp(*argv, "-quiet") == 0) {
1366 } else if (strcmp(*argv, "-brief") == 0) {
1370 } else if (strcmp(*argv, "-no_tmp_rsa") == 0) {
1372 } else if (strcmp(*argv, "-no_dhe") == 0) {
1374 } else if (strcmp(*argv, "-no_ecdhe") == 0) {
1376 } else if (strcmp(*argv, "-no_resume_ephemeral") == 0) {
1377 no_resume_ephemeral = 1;
1379 #ifndef OPENSSL_NO_PSK
1380 else if (strcmp(*argv, "-psk_hint") == 0) {
1383 psk_identity_hint = *(++argv);
1384 } else if (strcmp(*argv, "-psk") == 0) {
1389 psk_key = *(++argv);
1390 for (i = 0; i < strlen(psk_key); i++) {
1391 if (isxdigit((unsigned char)psk_key[i]))
1393 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
1398 #ifndef OPENSSL_NO_SRP
1399 else if (strcmp(*argv, "-srpvfile") == 0) {
1402 srp_verifier_file = *(++argv);
1403 meth = TLSv1_server_method();
1404 } else if (strcmp(*argv, "-srpuserseed") == 0) {
1407 srpuserseed = *(++argv);
1408 meth = TLSv1_server_method();
1411 else if (strcmp(*argv, "-rev") == 0) {
1413 } else if (strcmp(*argv, "-www") == 0) {
1415 } else if (strcmp(*argv, "-WWW") == 0) {
1417 } else if (strcmp(*argv, "-HTTP") == 0) {
1420 #ifndef OPENSSL_NO_SSL2
1421 else if (strcmp(*argv, "-ssl2") == 0) {
1423 meth = SSLv2_server_method();
1426 #ifndef OPENSSL_NO_SSL3_METHOD
1427 else if (strcmp(*argv, "-ssl3") == 0) {
1428 meth = SSLv3_server_method();
1431 #ifndef OPENSSL_NO_TLS1
1432 else if (strcmp(*argv, "-tls1") == 0) {
1433 meth = TLSv1_server_method();
1434 } else if (strcmp(*argv, "-tls1_1") == 0) {
1435 meth = TLSv1_1_server_method();
1436 } else if (strcmp(*argv, "-tls1_2") == 0) {
1437 meth = TLSv1_2_server_method();
1440 #ifndef OPENSSL_NO_DTLS1
1441 else if (strcmp(*argv, "-dtls") == 0) {
1442 meth = DTLS_server_method();
1443 socket_type = SOCK_DGRAM;
1444 } else if (strcmp(*argv, "-dtls1") == 0) {
1445 meth = DTLSv1_server_method();
1446 socket_type = SOCK_DGRAM;
1447 } else if (strcmp(*argv, "-dtls1_2") == 0) {
1448 meth = DTLSv1_2_server_method();
1449 socket_type = SOCK_DGRAM;
1450 } else if (strcmp(*argv, "-timeout") == 0)
1451 enable_timeouts = 1;
1452 else if (strcmp(*argv, "-mtu") == 0) {
1455 socket_mtu = atol(*(++argv));
1456 } else if (strcmp(*argv, "-chain") == 0)
1459 else if (strcmp(*argv, "-id_prefix") == 0) {
1462 session_id_prefix = *(++argv);
1464 #ifndef OPENSSL_NO_ENGINE
1465 else if (strcmp(*argv, "-engine") == 0) {
1468 engine_id = *(++argv);
1471 else if (strcmp(*argv, "-rand") == 0) {
1476 #ifndef OPENSSL_NO_TLSEXT
1477 else if (strcmp(*argv, "-servername") == 0) {
1480 tlsextcbp.servername = *(++argv);
1481 } else if (strcmp(*argv, "-servername_fatal") == 0) {
1482 tlsextcbp.extension_error = SSL_TLSEXT_ERR_ALERT_FATAL;
1483 } else if (strcmp(*argv, "-cert2") == 0) {
1486 s_cert_file2 = *(++argv);
1487 } else if (strcmp(*argv, "-key2") == 0) {
1490 s_key_file2 = *(++argv);
1492 # ifndef OPENSSL_NO_NEXTPROTONEG
1493 else if (strcmp(*argv, "-nextprotoneg") == 0) {
1496 next_proto_neg_in = *(++argv);
1499 else if (strcmp(*argv, "-alpn") == 0) {
1502 alpn_in = *(++argv);
1505 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
1506 else if (strcmp(*argv, "-jpake") == 0) {
1509 jpake_secret = *(++argv);
1512 #ifndef OPENSSL_NO_SRTP
1513 else if (strcmp(*argv, "-use_srtp") == 0) {
1516 srtp_profiles = *(++argv);
1519 else if (strcmp(*argv, "-keymatexport") == 0) {
1522 keymatexportlabel = *(++argv);
1523 } else if (strcmp(*argv, "-keymatexportlen") == 0) {
1526 keymatexportlen = atoi(*(++argv));
1527 if (keymatexportlen == 0)
1530 BIO_printf(bio_err, "unknown option %s\n", *argv);
1542 #ifndef OPENSSL_NO_DTLS1
1543 if (www && socket_type == SOCK_DGRAM) {
1544 BIO_printf(bio_err, "Can't use -HTTP, -www or -WWW with DTLS\n");
1549 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
1552 BIO_printf(bio_err, "Can't use JPAKE and PSK together\n");
1555 psk_identity = "JPAKE";
1559 SSL_load_error_strings();
1560 OpenSSL_add_ssl_algorithms();
1562 #ifndef OPENSSL_NO_ENGINE
1563 e = setup_engine(bio_err, engine_id, 1);
1566 if (!app_passwd(bio_err, passarg, dpassarg, &pass, &dpass)) {
1567 BIO_printf(bio_err, "Error getting password\n");
1571 if (s_key_file == NULL)
1572 s_key_file = s_cert_file;
1573 #ifndef OPENSSL_NO_TLSEXT
1574 if (s_key_file2 == NULL)
1575 s_key_file2 = s_cert_file2;
1578 if (!load_excert(&exc, bio_err))
1582 s_key = load_key(bio_err, s_key_file, s_key_format, 0, pass, e,
1583 "server certificate private key file");
1585 ERR_print_errors(bio_err);
1589 s_cert = load_cert(bio_err, s_cert_file, s_cert_format,
1590 NULL, e, "server certificate file");
1593 ERR_print_errors(bio_err);
1597 s_chain = load_certs(bio_err, s_chain_file, FORMAT_PEM,
1598 NULL, e, "server certificate chain");
1602 #ifndef OPENSSL_NO_TLSEXT
1603 if (tlsextcbp.servername) {
1604 s_key2 = load_key(bio_err, s_key_file2, s_key_format, 0, pass, e,
1605 "second server certificate private key file");
1607 ERR_print_errors(bio_err);
1611 s_cert2 = load_cert(bio_err, s_cert_file2, s_cert_format,
1612 NULL, e, "second server certificate file");
1615 ERR_print_errors(bio_err);
1619 #endif /* OPENSSL_NO_TLSEXT */
1621 #if !defined(OPENSSL_NO_TLSEXT)
1622 # if !defined(OPENSSL_NO_NEXTPROTONEG)
1623 if (next_proto_neg_in) {
1625 next_proto.data = next_protos_parse(&len, next_proto_neg_in);
1626 if (next_proto.data == NULL)
1628 next_proto.len = len;
1630 next_proto.data = NULL;
1633 alpn_ctx.data = NULL;
1636 alpn_ctx.data = next_protos_parse(&len, alpn_in);
1637 if (alpn_ctx.data == NULL)
1645 crl = load_crl(crl_file, crl_format);
1647 BIO_puts(bio_err, "Error loading CRL\n");
1648 ERR_print_errors(bio_err);
1651 crls = sk_X509_CRL_new_null();
1652 if (!crls || !sk_X509_CRL_push(crls, crl)) {
1653 BIO_puts(bio_err, "Error adding CRL\n");
1654 ERR_print_errors(bio_err);
1662 if (s_dkey_file == NULL)
1663 s_dkey_file = s_dcert_file;
1665 s_dkey = load_key(bio_err, s_dkey_file, s_dkey_format,
1666 0, dpass, e, "second certificate private key file");
1668 ERR_print_errors(bio_err);
1672 s_dcert = load_cert(bio_err, s_dcert_file, s_dcert_format,
1673 NULL, e, "second server certificate file");
1676 ERR_print_errors(bio_err);
1679 if (s_dchain_file) {
1680 s_dchain = load_certs(bio_err, s_dchain_file, FORMAT_PEM,
1681 NULL, e, "second server certificate chain");
1688 if (!app_RAND_load_file(NULL, bio_err, 1) && inrand == NULL
1689 && !RAND_status()) {
1691 "warning, not much extra random data, consider using the -rand option\n");
1694 BIO_printf(bio_err, "%ld semi-random bytes loaded\n",
1695 app_RAND_load_files(inrand));
1697 if (bio_s_out == NULL) {
1698 if (s_quiet && !s_debug) {
1699 bio_s_out = BIO_new(BIO_s_null());
1700 if (s_msg && !bio_s_msg)
1701 bio_s_msg = BIO_new_fp(stdout, BIO_NOCLOSE);
1703 if (bio_s_out == NULL)
1704 bio_s_out = BIO_new_fp(stdout, BIO_NOCLOSE);
1707 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_ECDSA)
1713 s_dcert_file = NULL;
1715 #ifndef OPENSSL_NO_TLSEXT
1716 s_cert_file2 = NULL;
1721 ctx = SSL_CTX_new(meth);
1723 ERR_print_errors(bio_err);
1726 if (session_id_prefix) {
1727 if (strlen(session_id_prefix) >= 32)
1729 "warning: id_prefix is too long, only one new session will be possible\n");
1730 else if (strlen(session_id_prefix) >= 16)
1732 "warning: id_prefix is too long if you use SSLv2\n");
1733 if (!SSL_CTX_set_generate_session_id(ctx, generate_session_id)) {
1734 BIO_printf(bio_err, "error setting 'id_prefix'\n");
1735 ERR_print_errors(bio_err);
1738 BIO_printf(bio_err, "id_prefix '%s' set.\n", session_id_prefix);
1740 SSL_CTX_set_quiet_shutdown(ctx, 1);
1742 SSL_CTX_set_options(ctx, SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG);
1744 ssl_ctx_set_excert(ctx, exc);
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);
1826 SSL_CTX_set_info_callback(ctx2, apps_ssl_info_callback);
1829 SSL_CTX_set_session_cache_mode(ctx2, SSL_SESS_CACHE_OFF);
1831 init_session_cache_ctx(ctx2);
1833 SSL_CTX_sess_set_cache_size(ctx2, 128);
1835 if ((!SSL_CTX_load_verify_locations(ctx2, CAfile, CApath)) ||
1836 (!SSL_CTX_set_default_verify_paths(ctx2))) {
1837 ERR_print_errors(bio_err);
1840 SSL_CTX_set1_param(ctx2, vpm);
1842 ssl_ctx_add_crls(ctx2, crls, 0);
1844 if (!args_ssl_call(ctx2, bio_err, cctx, ssl_args, no_ecdhe, no_jpake))
1848 # ifndef OPENSSL_NO_NEXTPROTONEG
1849 if (next_proto.data)
1850 SSL_CTX_set_next_protos_advertised_cb(ctx, next_proto_cb,
1854 SSL_CTX_set_alpn_select_cb(ctx, alpn_cb, &alpn_ctx);
1857 #ifndef OPENSSL_NO_DH
1862 dh = load_dh_param(dhfile);
1863 else if (s_cert_file)
1864 dh = load_dh_param(s_cert_file);
1867 BIO_printf(bio_s_out, "Setting temp DH parameters\n");
1869 BIO_printf(bio_s_out, "Using default temp DH parameters\n");
1872 (void)BIO_flush(bio_s_out);
1874 SSL_CTX_set_tmp_dh(ctx, dh);
1875 # ifndef OPENSSL_NO_TLSEXT
1878 DH *dh2 = load_dh_param(s_cert_file2);
1880 BIO_printf(bio_s_out, "Setting temp DH parameters\n");
1881 (void)BIO_flush(bio_s_out);
1887 SSL_CTX_set_tmp_dh(ctx2, dh);
1894 if (!set_cert_key_stuff(ctx, s_cert, s_key, s_chain, build_chain))
1896 #ifndef OPENSSL_NO_TLSEXT
1897 if (s_serverinfo_file != NULL
1898 && !SSL_CTX_use_serverinfo_file(ctx, s_serverinfo_file)) {
1899 ERR_print_errors(bio_err);
1903 #ifndef OPENSSL_NO_TLSEXT
1904 if (ctx2 && !set_cert_key_stuff(ctx2, s_cert2, s_key2, NULL, build_chain))
1907 if (s_dcert != NULL) {
1908 if (!set_cert_key_stuff(ctx, s_dcert, s_dkey, s_dchain, build_chain))
1911 #ifndef OPENSSL_NO_RSA
1914 SSL_CTX_set_tmp_rsa_callback(ctx, tmp_rsa_cb);
1915 # ifndef OPENSSL_NO_TLSEXT
1917 SSL_CTX_set_tmp_rsa_callback(ctx2, tmp_rsa_cb);
1921 if (!no_tmp_rsa && SSL_CTX_need_tmp_RSA(ctx)) {
1924 BIO_printf(bio_s_out, "Generating temp (512 bit) RSA key...");
1925 BIO_flush(bio_s_out);
1927 rsa = RSA_generate_key(512, RSA_F4, NULL);
1929 if (!SSL_CTX_set_tmp_rsa(ctx, rsa)) {
1930 ERR_print_errors(bio_err);
1933 # ifndef OPENSSL_NO_TLSEXT
1935 if (!SSL_CTX_set_tmp_rsa(ctx2, rsa)) {
1936 ERR_print_errors(bio_err);
1942 BIO_printf(bio_s_out, "\n");
1947 #ifndef OPENSSL_NO_PSK
1948 # ifdef OPENSSL_NO_JPAKE
1949 if (psk_key != NULL)
1951 if (psk_key != NULL || jpake_secret)
1955 BIO_printf(bio_s_out,
1956 "PSK key given or JPAKE in use, setting server callback\n");
1957 SSL_CTX_set_psk_server_callback(ctx, psk_server_cb);
1960 if (!SSL_CTX_use_psk_identity_hint(ctx, psk_identity_hint)) {
1961 BIO_printf(bio_err, "error setting PSK identity hint to context\n");
1962 ERR_print_errors(bio_err);
1967 SSL_CTX_set_verify(ctx, s_server_verify, verify_callback);
1968 SSL_CTX_set_session_id_context(ctx, (void *)&s_server_session_id_context,
1969 sizeof s_server_session_id_context);
1971 /* Set DTLS cookie generation and verification callbacks */
1972 SSL_CTX_set_cookie_generate_cb(ctx, generate_cookie_callback);
1973 SSL_CTX_set_cookie_verify_cb(ctx, verify_cookie_callback);
1975 #ifndef OPENSSL_NO_TLSEXT
1977 SSL_CTX_set_verify(ctx2, s_server_verify, verify_callback);
1978 SSL_CTX_set_session_id_context(ctx2,
1979 (void *)&s_server_session_id_context,
1980 sizeof s_server_session_id_context);
1982 tlsextcbp.biodebug = bio_s_out;
1983 SSL_CTX_set_tlsext_servername_callback(ctx2, ssl_servername_cb);
1984 SSL_CTX_set_tlsext_servername_arg(ctx2, &tlsextcbp);
1985 SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
1986 SSL_CTX_set_tlsext_servername_arg(ctx, &tlsextcbp);
1990 #ifndef OPENSSL_NO_SRP
1991 if (srp_verifier_file != NULL) {
1992 srp_callback_parm.vb = SRP_VBASE_new(srpuserseed);
1993 srp_callback_parm.user = NULL;
1994 srp_callback_parm.login = NULL;
1996 SRP_VBASE_init(srp_callback_parm.vb,
1997 srp_verifier_file)) != SRP_NO_ERROR) {
1999 "Cannot initialize SRP verifier file \"%s\":ret=%d\n",
2000 srp_verifier_file, ret);
2003 SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, verify_callback);
2004 SSL_CTX_set_srp_cb_arg(ctx, &srp_callback_parm);
2005 SSL_CTX_set_srp_username_callback(ctx, ssl_srp_server_param_cb);
2008 if (CAfile != NULL) {
2009 SSL_CTX_set_client_CA_list(ctx, SSL_load_client_CA_file(CAfile));
2010 #ifndef OPENSSL_NO_TLSEXT
2012 SSL_CTX_set_client_CA_list(ctx2, SSL_load_client_CA_file(CAfile));
2016 BIO_printf(bio_s_out, "ACCEPT\n");
2017 (void)BIO_flush(bio_s_out);
2019 do_server(port, socket_type, &accept_socket, rev_body, context,
2022 do_server(port, socket_type, &accept_socket, www_body, context,
2025 do_server(port, socket_type, &accept_socket, sv_body, context,
2027 print_stats(bio_s_out, ctx);
2035 sk_X509_CRL_pop_free(crls, X509_CRL_free);
2039 EVP_PKEY_free(s_key);
2041 EVP_PKEY_free(s_dkey);
2043 sk_X509_pop_free(s_chain, X509_free);
2045 sk_X509_pop_free(s_dchain, X509_free);
2049 OPENSSL_free(dpass);
2051 X509_VERIFY_PARAM_free(vpm);
2053 #ifndef OPENSSL_NO_TLSEXT
2055 OPENSSL_free(tlscstatp.host);
2057 OPENSSL_free(tlscstatp.port);
2059 OPENSSL_free(tlscstatp.path);
2065 EVP_PKEY_free(s_key2);
2066 if (serverinfo_in != NULL)
2067 BIO_free(serverinfo_in);
2068 # ifndef OPENSSL_NO_NEXTPROTONEG
2069 if (next_proto.data)
2070 OPENSSL_free(next_proto.data);
2073 OPENSSL_free(alpn_ctx.data);
2075 ssl_excert_free(exc);
2077 sk_OPENSSL_STRING_free(ssl_args);
2079 SSL_CONF_CTX_free(cctx);
2080 #ifndef OPENSSL_NO_JPAKE
2081 if (jpake_secret && psk_key)
2082 OPENSSL_free(psk_key);
2084 if (bio_s_out != NULL) {
2085 BIO_free(bio_s_out);
2088 if (bio_s_msg != NULL) {
2089 BIO_free(bio_s_msg);
2096 static void print_stats(BIO *bio, SSL_CTX *ssl_ctx)
2098 BIO_printf(bio, "%4ld items in the session cache\n",
2099 SSL_CTX_sess_number(ssl_ctx));
2100 BIO_printf(bio, "%4ld client connects (SSL_connect())\n",
2101 SSL_CTX_sess_connect(ssl_ctx));
2102 BIO_printf(bio, "%4ld client renegotiates (SSL_connect())\n",
2103 SSL_CTX_sess_connect_renegotiate(ssl_ctx));
2104 BIO_printf(bio, "%4ld client connects that finished\n",
2105 SSL_CTX_sess_connect_good(ssl_ctx));
2106 BIO_printf(bio, "%4ld server accepts (SSL_accept())\n",
2107 SSL_CTX_sess_accept(ssl_ctx));
2108 BIO_printf(bio, "%4ld server renegotiates (SSL_accept())\n",
2109 SSL_CTX_sess_accept_renegotiate(ssl_ctx));
2110 BIO_printf(bio, "%4ld server accepts that finished\n",
2111 SSL_CTX_sess_accept_good(ssl_ctx));
2112 BIO_printf(bio, "%4ld session cache hits\n", SSL_CTX_sess_hits(ssl_ctx));
2113 BIO_printf(bio, "%4ld session cache misses\n",
2114 SSL_CTX_sess_misses(ssl_ctx));
2115 BIO_printf(bio, "%4ld session cache timeouts\n",
2116 SSL_CTX_sess_timeouts(ssl_ctx));
2117 BIO_printf(bio, "%4ld callback cache hits\n",
2118 SSL_CTX_sess_cb_hits(ssl_ctx));
2119 BIO_printf(bio, "%4ld cache full overflows (%ld allowed)\n",
2120 SSL_CTX_sess_cache_full(ssl_ctx),
2121 SSL_CTX_sess_get_cache_size(ssl_ctx));
2124 static int sv_body(char *hostname, int s, int stype, unsigned char *context)
2133 #ifndef OPENSSL_NO_KRB5
2136 struct timeval timeout;
2137 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE) || defined(OPENSSL_SYS_BEOS_R5)
2140 struct timeval *timeoutp;
2143 if ((buf = OPENSSL_malloc(bufsize)) == NULL) {
2144 BIO_printf(bio_err, "out of memory\n");
2149 unsigned long sl = 1;
2152 BIO_printf(bio_err, "turning on non blocking io\n");
2153 if (BIO_socket_ioctl(s, FIONBIO, &sl) < 0)
2154 ERR_print_errors(bio_err);
2160 #ifndef OPENSSL_NO_TLSEXT
2161 if (s_tlsextdebug) {
2162 SSL_set_tlsext_debug_callback(con, tlsext_cb);
2163 SSL_set_tlsext_debug_arg(con, bio_s_out);
2165 if (s_tlsextstatus) {
2166 SSL_CTX_set_tlsext_status_cb(ctx, cert_status_cb);
2167 tlscstatp.err = bio_err;
2168 SSL_CTX_set_tlsext_status_arg(ctx, &tlscstatp);
2171 #ifndef OPENSSL_NO_KRB5
2172 if ((kctx = kssl_ctx_new()) != NULL) {
2173 SSL_set0_kssl_ctx(con, kctx);
2174 kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
2175 kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
2177 #endif /* OPENSSL_NO_KRB5 */
2179 SSL_set_session_id_context(con, context, strlen((char *)context));
2183 # ifdef TLSEXT_TYPE_opaque_prf_input
2184 SSL_set_tlsext_opaque_prf_input(con, "Test server", 11);
2188 if (stype == SOCK_DGRAM) {
2190 sbio = BIO_new_dgram(s, BIO_NOCLOSE);
2192 if (enable_timeouts) {
2194 timeout.tv_usec = DGRAM_RCV_TIMEOUT;
2195 BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout);
2198 timeout.tv_usec = DGRAM_SND_TIMEOUT;
2199 BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_SEND_TIMEOUT, 0, &timeout);
2203 if (socket_mtu < DTLS_get_link_min_mtu(con)) {
2204 BIO_printf(bio_err, "MTU too small. Must be at least %ld\n",
2205 DTLS_get_link_min_mtu(con));
2210 SSL_set_options(con, SSL_OP_NO_QUERY_MTU);
2211 if (!DTLS_set_link_mtu(con, socket_mtu)) {
2212 BIO_printf(bio_err, "Failed to set MTU\n");
2218 /* want to do MTU discovery */
2219 BIO_ctrl(sbio, BIO_CTRL_DGRAM_MTU_DISCOVER, 0, NULL);
2221 /* turn on cookie exchange */
2222 SSL_set_options(con, SSL_OP_COOKIE_EXCHANGE);
2224 sbio = BIO_new_socket(s, BIO_NOCLOSE);
2229 test = BIO_new(BIO_f_nbio_test());
2230 sbio = BIO_push(test, sbio);
2232 #ifndef OPENSSL_NO_JPAKE
2234 jpake_server_auth(bio_s_out, sbio, jpake_secret);
2237 SSL_set_bio(con, sbio, sbio);
2238 SSL_set_accept_state(con);
2239 /* SSL_set_fd(con,s); */
2242 SSL_set_debug(con, 1);
2243 BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
2244 BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
2247 #ifndef OPENSSL_NO_SSL_TRACE
2249 SSL_set_msg_callback(con, SSL_trace);
2252 SSL_set_msg_callback(con, msg_cb);
2253 SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
2255 #ifndef OPENSSL_NO_TLSEXT
2256 if (s_tlsextdebug) {
2257 SSL_set_tlsext_debug_callback(con, tlsext_cb);
2258 SSL_set_tlsext_debug_arg(con, bio_s_out);
2264 int read_from_terminal;
2265 int read_from_sslcon;
2267 read_from_terminal = 0;
2268 read_from_sslcon = SSL_pending(con);
2270 if (!read_from_sslcon) {
2272 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_NETWARE) && !defined(OPENSSL_SYS_BEOS_R5)
2273 openssl_fdset(fileno(stdin), &readfds);
2275 openssl_fdset(s, &readfds);
2277 * Note: under VMS with SOCKETSHR the second parameter is
2278 * currently of type (int *) whereas under other systems it is
2279 * (void *) if you don't have a cast it will choke the compiler:
2280 * if you do have a cast then you can either go for (int *) or
2283 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE)
2285 * Under DOS (non-djgpp) and Windows we can't select on stdin:
2286 * only on sockets. As a workaround we timeout the select every
2287 * second and check for any keypress. In a proper Windows
2288 * application we wouldn't do this because it is inefficient.
2292 i = select(width, (void *)&readfds, NULL, NULL, &tv);
2293 if ((i < 0) || (!i && !_kbhit()))
2296 read_from_terminal = 1;
2297 #elif defined(OPENSSL_SYS_BEOS_R5)
2298 /* Under BeOS-R5 the situation is similar to DOS */
2301 (void)fcntl(fileno(stdin), F_SETFL, O_NONBLOCK);
2302 i = select(width, (void *)&readfds, NULL, NULL, &tv);
2303 if ((i < 0) || (!i && read(fileno(stdin), buf, 0) < 0))
2305 if (read(fileno(stdin), buf, 0) >= 0)
2306 read_from_terminal = 1;
2307 (void)fcntl(fileno(stdin), F_SETFL, 0);
2309 if ((SSL_version(con) == DTLS1_VERSION) &&
2310 DTLSv1_get_timeout(con, &timeout))
2311 timeoutp = &timeout;
2315 i = select(width, (void *)&readfds, NULL, NULL, timeoutp);
2317 if ((SSL_version(con) == DTLS1_VERSION)
2318 && DTLSv1_handle_timeout(con) > 0) {
2319 BIO_printf(bio_err, "TIMEOUT occured\n");
2324 if (FD_ISSET(fileno(stdin), &readfds))
2325 read_from_terminal = 1;
2327 if (FD_ISSET(s, &readfds))
2328 read_from_sslcon = 1;
2330 if (read_from_terminal) {
2334 i = raw_read_stdin(buf, bufsize / 2);
2336 /* both loops are skipped when i <= 0 */
2337 for (j = 0; j < i; j++)
2340 for (j = i - 1; j >= 0; j--) {
2341 buf[j + lf_num] = buf[j];
2342 if (buf[j] == '\n') {
2345 buf[j + lf_num] = '\r';
2348 assert(lf_num == 0);
2350 i = raw_read_stdin(buf, bufsize);
2351 if (!s_quiet && !s_brief) {
2352 if ((i <= 0) || (buf[0] == 'Q')) {
2353 BIO_printf(bio_s_out, "DONE\n");
2355 close_accept_socket();
2359 if ((i <= 0) || (buf[0] == 'q')) {
2360 BIO_printf(bio_s_out, "DONE\n");
2361 if (SSL_version(con) != DTLS1_VERSION)
2364 * close_accept_socket(); ret= -11;
2368 #ifndef OPENSSL_NO_HEARTBEATS
2369 if ((buf[0] == 'B') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2370 BIO_printf(bio_err, "HEARTBEATING\n");
2376 if ((buf[0] == 'r') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2377 SSL_renegotiate(con);
2378 i = SSL_do_handshake(con);
2379 printf("SSL_do_handshake -> %d\n", i);
2383 * strcpy(buf,"server side RE-NEGOTIATE\n");
2386 if ((buf[0] == 'R') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2388 SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE,
2390 SSL_renegotiate(con);
2391 i = SSL_do_handshake(con);
2392 printf("SSL_do_handshake -> %d\n", i);
2396 * strcpy(buf,"server side RE-NEGOTIATE asking for client
2400 if (buf[0] == 'P') {
2401 static const char *str = "Lets print some clear text\n";
2402 BIO_write(SSL_get_wbio(con), str, strlen(str));
2404 if (buf[0] == 'S') {
2405 print_stats(bio_s_out, SSL_get_SSL_CTX(con));
2408 #ifdef CHARSET_EBCDIC
2409 ebcdic2ascii(buf, buf, i);
2413 /* should do a select for the write */
2417 if (++count == 100) {
2419 SSL_renegotiate(con);
2423 k = SSL_write(con, &(buf[l]), (unsigned int)i);
2424 #ifndef OPENSSL_NO_SRP
2425 while (SSL_get_error(con, k) == SSL_ERROR_WANT_X509_LOOKUP) {
2426 BIO_printf(bio_s_out, "LOOKUP renego during write\n");
2427 srp_callback_parm.user =
2428 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2429 srp_callback_parm.login);
2430 if (srp_callback_parm.user)
2431 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2432 srp_callback_parm.user->info);
2434 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2435 k = SSL_write(con, &(buf[l]), (unsigned int)i);
2438 switch (SSL_get_error(con, k)) {
2439 case SSL_ERROR_NONE:
2441 case SSL_ERROR_WANT_WRITE:
2442 case SSL_ERROR_WANT_READ:
2443 case SSL_ERROR_WANT_X509_LOOKUP:
2444 BIO_printf(bio_s_out, "Write BLOCK\n");
2446 case SSL_ERROR_SYSCALL:
2448 BIO_printf(bio_s_out, "ERROR\n");
2449 ERR_print_errors(bio_err);
2453 case SSL_ERROR_ZERO_RETURN:
2454 BIO_printf(bio_s_out, "DONE\n");
2466 if (read_from_sslcon) {
2467 if (!SSL_is_init_finished(con)) {
2468 i = init_ssl_connection(con);
2473 } else if (i == 0) {
2479 i = SSL_read(con, (char *)buf, bufsize);
2480 #ifndef OPENSSL_NO_SRP
2481 while (SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2482 BIO_printf(bio_s_out, "LOOKUP renego during read\n");
2483 srp_callback_parm.user =
2484 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2485 srp_callback_parm.login);
2486 if (srp_callback_parm.user)
2487 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2488 srp_callback_parm.user->info);
2490 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2491 i = SSL_read(con, (char *)buf, bufsize);
2494 switch (SSL_get_error(con, i)) {
2495 case SSL_ERROR_NONE:
2496 #ifdef CHARSET_EBCDIC
2497 ascii2ebcdic(buf, buf, i);
2499 raw_write_stdout(buf, (unsigned int)i);
2500 if (SSL_pending(con))
2503 case SSL_ERROR_WANT_WRITE:
2504 case SSL_ERROR_WANT_READ:
2505 BIO_printf(bio_s_out, "Read BLOCK\n");
2507 case SSL_ERROR_SYSCALL:
2509 BIO_printf(bio_s_out, "ERROR\n");
2510 ERR_print_errors(bio_err);
2513 case SSL_ERROR_ZERO_RETURN:
2514 BIO_printf(bio_s_out, "DONE\n");
2523 BIO_printf(bio_s_out, "shutting down SSL\n");
2525 SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
2531 BIO_printf(bio_s_out, "CONNECTION CLOSED\n");
2533 OPENSSL_cleanse(buf, bufsize);
2537 BIO_printf(bio_s_out, "ACCEPT\n");
2541 static void close_accept_socket(void)
2543 BIO_printf(bio_err, "shutdown accept socket\n");
2544 if (accept_socket >= 0) {
2545 SHUTDOWN2(accept_socket);
2549 static int init_ssl_connection(SSL *con)
2555 MS_STATIC char buf[BUFSIZ];
2556 #ifndef OPENSSL_NO_KRB5
2559 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2560 const unsigned char *next_proto_neg;
2561 unsigned next_proto_neg_len;
2563 unsigned char *exportedkeymat;
2565 i = SSL_accept(con);
2566 #ifdef CERT_CB_TEST_RETRY
2568 while (i <= 0 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP
2569 && SSL_state(con) == SSL3_ST_SR_CLNT_HELLO_C) {
2571 "LOOKUP from certificate callback during accept\n");
2572 i = SSL_accept(con);
2576 #ifndef OPENSSL_NO_SRP
2577 while (i <= 0 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2578 BIO_printf(bio_s_out, "LOOKUP during accept %s\n",
2579 srp_callback_parm.login);
2580 srp_callback_parm.user =
2581 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2582 srp_callback_parm.login);
2583 if (srp_callback_parm.user)
2584 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2585 srp_callback_parm.user->info);
2587 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2588 i = SSL_accept(con);
2593 if (BIO_sock_should_retry(i)) {
2594 BIO_printf(bio_s_out, "DELAY\n");
2598 BIO_printf(bio_err, "ERROR\n");
2599 verify_error = SSL_get_verify_result(con);
2600 if (verify_error != X509_V_OK) {
2601 BIO_printf(bio_err, "verify error:%s\n",
2602 X509_verify_cert_error_string(verify_error));
2604 /* Always print any error messages */
2605 ERR_print_errors(bio_err);
2610 print_ssl_summary(bio_err, con);
2612 PEM_write_bio_SSL_SESSION(bio_s_out, SSL_get_session(con));
2614 peer = SSL_get_peer_certificate(con);
2616 BIO_printf(bio_s_out, "Client certificate\n");
2617 PEM_write_bio_X509(bio_s_out, peer);
2618 X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof buf);
2619 BIO_printf(bio_s_out, "subject=%s\n", buf);
2620 X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof buf);
2621 BIO_printf(bio_s_out, "issuer=%s\n", buf);
2625 if (SSL_get_shared_ciphers(con, buf, sizeof buf) != NULL)
2626 BIO_printf(bio_s_out, "Shared ciphers:%s\n", buf);
2627 str = SSL_CIPHER_get_name(SSL_get_current_cipher(con));
2628 ssl_print_sigalgs(bio_s_out, con);
2629 #ifndef OPENSSL_NO_EC
2630 ssl_print_point_formats(bio_s_out, con);
2631 ssl_print_curves(bio_s_out, con, 0);
2633 BIO_printf(bio_s_out, "CIPHER is %s\n", (str != NULL) ? str : "(NONE)");
2635 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2636 SSL_get0_next_proto_negotiated(con, &next_proto_neg, &next_proto_neg_len);
2637 if (next_proto_neg) {
2638 BIO_printf(bio_s_out, "NEXTPROTO is ");
2639 BIO_write(bio_s_out, next_proto_neg, next_proto_neg_len);
2640 BIO_printf(bio_s_out, "\n");
2643 #ifndef OPENSSL_NO_SRTP
2645 SRTP_PROTECTION_PROFILE *srtp_profile
2646 = SSL_get_selected_srtp_profile(con);
2649 BIO_printf(bio_s_out, "SRTP Extension negotiated, profile=%s\n",
2650 srtp_profile->name);
2653 if (SSL_cache_hit(con))
2654 BIO_printf(bio_s_out, "Reused session-id\n");
2655 if (SSL_ctrl(con, SSL_CTRL_GET_FLAGS, 0, NULL) &
2656 TLS1_FLAGS_TLS_PADDING_BUG)
2657 BIO_printf(bio_s_out, "Peer has incorrect TLSv1 block padding\n");
2658 #ifndef OPENSSL_NO_KRB5
2659 client_princ = kssl_ctx_get0_client_princ(SSL_get0_kssl_ctx(con));
2660 if (client_princ != NULL) {
2661 BIO_printf(bio_s_out, "Kerberos peer principal is %s\n",
2664 #endif /* OPENSSL_NO_KRB5 */
2665 BIO_printf(bio_s_out, "Secure Renegotiation IS%s supported\n",
2666 SSL_get_secure_renegotiation_support(con) ? "" : " NOT");
2667 if (keymatexportlabel != NULL) {
2668 BIO_printf(bio_s_out, "Keying material exporter:\n");
2669 BIO_printf(bio_s_out, " Label: '%s'\n", keymatexportlabel);
2670 BIO_printf(bio_s_out, " Length: %i bytes\n", keymatexportlen);
2671 exportedkeymat = OPENSSL_malloc(keymatexportlen);
2672 if (exportedkeymat != NULL) {
2673 if (!SSL_export_keying_material(con, exportedkeymat,
2676 strlen(keymatexportlabel),
2678 BIO_printf(bio_s_out, " Error\n");
2680 BIO_printf(bio_s_out, " Keying material: ");
2681 for (i = 0; i < keymatexportlen; i++)
2682 BIO_printf(bio_s_out, "%02X", exportedkeymat[i]);
2683 BIO_printf(bio_s_out, "\n");
2685 OPENSSL_free(exportedkeymat);
2692 #ifndef OPENSSL_NO_DH
2693 static DH *load_dh_param(const char *dhfile)
2698 if ((bio = BIO_new_file(dhfile, "r")) == NULL)
2700 ret = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
2707 #ifndef OPENSSL_NO_KRB5
2712 static int load_CA(SSL_CTX *ctx, char *file)
2717 if ((in = fopen(file, "r")) == NULL)
2721 if (PEM_read_X509(in, &x, NULL) == NULL)
2723 SSL_CTX_add_client_CA(ctx, x);
2732 static int www_body(char *hostname, int s, int stype, unsigned char *context)
2738 const SSL_CIPHER *c;
2739 BIO *io, *ssl_bio, *sbio;
2740 #ifndef OPENSSL_NO_KRB5
2744 buf = OPENSSL_malloc(bufsize);
2747 io = BIO_new(BIO_f_buffer());
2748 ssl_bio = BIO_new(BIO_f_ssl());
2749 if ((io == NULL) || (ssl_bio == NULL))
2754 unsigned long sl = 1;
2757 BIO_printf(bio_err, "turning on non blocking io\n");
2758 if (BIO_socket_ioctl(s, FIONBIO, &sl) < 0)
2759 ERR_print_errors(bio_err);
2763 /* lets make the output buffer a reasonable size */
2764 if (!BIO_set_write_buffer_size(io, bufsize))
2767 if ((con = SSL_new(ctx)) == NULL)
2769 #ifndef OPENSSL_NO_TLSEXT
2770 if (s_tlsextdebug) {
2771 SSL_set_tlsext_debug_callback(con, tlsext_cb);
2772 SSL_set_tlsext_debug_arg(con, bio_s_out);
2775 #ifndef OPENSSL_NO_KRB5
2776 if ((kctx = kssl_ctx_new()) != NULL) {
2777 kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
2778 kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
2780 #endif /* OPENSSL_NO_KRB5 */
2782 SSL_set_session_id_context(con, context, strlen((char *)context));
2784 sbio = BIO_new_socket(s, BIO_NOCLOSE);
2788 test = BIO_new(BIO_f_nbio_test());
2789 sbio = BIO_push(test, sbio);
2791 SSL_set_bio(con, sbio, sbio);
2792 SSL_set_accept_state(con);
2794 /* SSL_set_fd(con,s); */
2795 BIO_set_ssl(ssl_bio, con, BIO_CLOSE);
2796 BIO_push(io, ssl_bio);
2797 #ifdef CHARSET_EBCDIC
2798 io = BIO_push(BIO_new(BIO_f_ebcdic_filter()), io);
2802 SSL_set_debug(con, 1);
2803 BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
2804 BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
2807 #ifndef OPENSSL_NO_SSL_TRACE
2809 SSL_set_msg_callback(con, SSL_trace);
2812 SSL_set_msg_callback(con, msg_cb);
2813 SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
2818 i = SSL_accept(con);
2819 #ifndef OPENSSL_NO_SRP
2821 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2822 BIO_printf(bio_s_out, "LOOKUP during accept %s\n",
2823 srp_callback_parm.login);
2824 srp_callback_parm.user =
2825 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2826 srp_callback_parm.login);
2827 if (srp_callback_parm.user)
2828 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2829 srp_callback_parm.user->info);
2831 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2832 i = SSL_accept(con);
2835 switch (SSL_get_error(con, i)) {
2836 case SSL_ERROR_NONE:
2838 case SSL_ERROR_WANT_WRITE:
2839 case SSL_ERROR_WANT_READ:
2840 case SSL_ERROR_WANT_X509_LOOKUP:
2842 case SSL_ERROR_SYSCALL:
2844 case SSL_ERROR_ZERO_RETURN:
2850 SSL_renegotiate(con);
2851 SSL_write(con, NULL, 0);
2854 i = BIO_gets(io, buf, bufsize - 1);
2855 if (i < 0) { /* error */
2856 if (!BIO_should_retry(io)) {
2858 ERR_print_errors(bio_err);
2861 BIO_printf(bio_s_out, "read R BLOCK\n");
2862 #if defined(OPENSSL_SYS_NETWARE)
2864 #elif !defined(OPENSSL_SYS_MSDOS) && !defined(__DJGPP__)
2869 } else if (i == 0) { /* end of input */
2874 /* else we have data */
2875 if (((www == 1) && (strncmp("GET ", buf, 4) == 0)) ||
2876 ((www == 2) && (strncmp("GET /stats ", buf, 11) == 0))) {
2879 STACK_OF(SSL_CIPHER) *sk;
2880 static const char *space = " ";
2883 "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
2884 BIO_puts(io, "<HTML><BODY BGCOLOR=\"#ffffff\">\n");
2885 BIO_puts(io, "<pre>\n");
2886 /* BIO_puts(io,SSLeay_version(SSLEAY_VERSION));*/
2888 for (i = 0; i < local_argc; i++) {
2889 BIO_puts(io, local_argv[i]);
2890 BIO_write(io, " ", 1);
2895 "Secure Renegotiation IS%s supported\n",
2896 SSL_get_secure_renegotiation_support(con) ?
2900 * The following is evil and should not really be done
2902 BIO_printf(io, "Ciphers supported in s_server binary\n");
2903 sk = SSL_get_ciphers(con);
2904 j = sk_SSL_CIPHER_num(sk);
2905 for (i = 0; i < j; i++) {
2906 c = sk_SSL_CIPHER_value(sk, i);
2907 BIO_printf(io, "%-11s:%-25s",
2908 SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2909 if ((((i + 1) % 2) == 0) && (i + 1 != j))
2913 p = SSL_get_shared_ciphers(con, buf, bufsize);
2916 "---\nCiphers common between both SSL end points:\n");
2920 BIO_write(io, space, 26 - j);
2923 BIO_write(io, ((i % 3) ? " " : "\n"), 1);
2925 BIO_write(io, p, 1);
2932 ssl_print_sigalgs(io, con);
2933 #ifndef OPENSSL_NO_EC
2934 ssl_print_curves(io, con, 0);
2936 BIO_printf(io, (SSL_cache_hit(con)
2937 ? "---\nReused, " : "---\nNew, "));
2938 c = SSL_get_current_cipher(con);
2939 BIO_printf(io, "%s, Cipher is %s\n",
2940 SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2941 SSL_SESSION_print(io, SSL_get_session(con));
2942 BIO_printf(io, "---\n");
2943 print_stats(io, SSL_get_SSL_CTX(con));
2944 BIO_printf(io, "---\n");
2945 peer = SSL_get_peer_certificate(con);
2947 BIO_printf(io, "Client certificate\n");
2948 X509_print(io, peer);
2949 PEM_write_bio_X509(io, peer);
2951 BIO_puts(io, "no client certificate available\n");
2952 BIO_puts(io, "</BODY></HTML>\r\n\r\n");
2954 } else if ((www == 2 || www == 3)
2955 && (strncmp("GET /", buf, 5) == 0)) {
2958 static const char *text =
2959 "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n";
2965 for (e = p; *e != '\0'; e++) {
2971 dot = (e[0] == '.') ? 2 : 0;
2974 dot = (e[0] == '.') ? 3 : 0;
2977 dot = (e[0] == '/') ? -1 : 0;
2981 dot = (e[0] == '/') ? 1 : 0;
2983 dot = (dot == 3) || (dot == -1); /* filename contains ".."
2988 BIO_printf(io, "'%s' is an invalid file name\r\n", p);
2995 BIO_printf(io, "'%s' contains '..' reference\r\n", p);
3001 BIO_printf(io, "'%s' is an invalid path\r\n", p);
3005 /* append if a directory lookup */
3007 strcat(p, "index.html");
3010 /* if a directory, do the index thang */
3011 if (app_isdir(p) > 0) {
3012 #if 0 /* must check buffer size */
3013 strcat(p, "/index.html");
3016 BIO_printf(io, "'%s' is a directory\r\n", p);
3021 if ((file = BIO_new_file(p, "r")) == NULL) {
3023 BIO_printf(io, "Error opening '%s'\r\n", p);
3024 ERR_print_errors(io);
3029 BIO_printf(bio_err, "FILE:%s\n", p);
3033 if (((i > 5) && (strcmp(&(p[i - 5]), ".html") == 0)) ||
3034 ((i > 4) && (strcmp(&(p[i - 4]), ".php") == 0)) ||
3035 ((i > 4) && (strcmp(&(p[i - 4]), ".htm") == 0)))
3037 "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
3040 "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n");
3044 i = BIO_read(file, buf, bufsize);
3050 fprintf(stderr, "%d\n", i);
3051 if (total_bytes > 3 * 1024) {
3053 fprintf(stderr, "RENEGOTIATE\n");
3054 SSL_renegotiate(con);
3058 for (j = 0; j < i;) {
3062 if (++count == 13) {
3063 SSL_renegotiate(con);
3067 k = BIO_write(io, &(buf[j]), i - j);
3069 if (!BIO_should_retry(io))
3072 BIO_printf(bio_s_out, "rwrite W BLOCK\n");
3086 i = (int)BIO_flush(io);
3088 if (!BIO_should_retry(io))
3095 /* make sure we re-use sessions */
3096 SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
3098 /* This kills performance */
3100 * SSL_shutdown(con); A shutdown gets sent in the BIO_free_all(io)
3108 BIO_printf(bio_s_out, "ACCEPT\n");
3114 /* if (ssl_bio != NULL) BIO_free(ssl_bio);*/
3118 static int rev_body(char *hostname, int s, int stype, unsigned char *context)
3124 BIO *io, *ssl_bio, *sbio;
3125 #ifndef OPENSSL_NO_KRB5
3129 buf = OPENSSL_malloc(bufsize);
3132 io = BIO_new(BIO_f_buffer());
3133 ssl_bio = BIO_new(BIO_f_ssl());
3134 if ((io == NULL) || (ssl_bio == NULL))
3137 /* lets make the output buffer a reasonable size */
3138 if (!BIO_set_write_buffer_size(io, bufsize))
3141 if ((con = SSL_new(ctx)) == NULL)
3143 #ifndef OPENSSL_NO_TLSEXT
3144 if (s_tlsextdebug) {
3145 SSL_set_tlsext_debug_callback(con, tlsext_cb);
3146 SSL_set_tlsext_debug_arg(con, bio_s_out);
3149 #ifndef OPENSSL_NO_KRB5
3150 if ((kctx = kssl_ctx_new()) != NULL) {
3151 kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
3152 kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
3154 #endif /* OPENSSL_NO_KRB5 */
3156 SSL_set_session_id_context(con, context, strlen((char *)context));
3158 sbio = BIO_new_socket(s, BIO_NOCLOSE);
3159 SSL_set_bio(con, sbio, sbio);
3160 SSL_set_accept_state(con);
3162 BIO_set_ssl(ssl_bio, con, BIO_CLOSE);
3163 BIO_push(io, ssl_bio);
3164 #ifdef CHARSET_EBCDIC
3165 io = BIO_push(BIO_new(BIO_f_ebcdic_filter()), io);
3169 SSL_set_debug(con, 1);
3170 BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
3171 BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
3174 #ifndef OPENSSL_NO_SSL_TRACE
3176 SSL_set_msg_callback(con, SSL_trace);
3179 SSL_set_msg_callback(con, msg_cb);
3180 SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
3184 i = BIO_do_handshake(io);
3187 if (!BIO_should_retry(io)) {
3188 BIO_puts(bio_err, "CONNECTION FAILURE\n");
3189 ERR_print_errors(bio_err);
3193 BIO_printf(bio_err, "CONNECTION ESTABLISHED\n");
3194 print_ssl_summary(bio_err, con);
3197 i = BIO_gets(io, buf, bufsize - 1);
3198 if (i < 0) { /* error */
3199 if (!BIO_should_retry(io)) {
3201 ERR_print_errors(bio_err);
3204 BIO_printf(bio_s_out, "read R BLOCK\n");
3205 #if defined(OPENSSL_SYS_NETWARE)
3207 #elif !defined(OPENSSL_SYS_MSDOS) && !defined(__DJGPP__)
3212 } else if (i == 0) { /* end of input */
3214 BIO_printf(bio_err, "CONNECTION CLOSED\n");
3217 char *p = buf + i - 1;
3218 while (i && (*p == '\n' || *p == '\r')) {
3222 if (!s_ign_eof && i == 5 && !strncmp(buf, "CLOSE", 5)) {
3224 BIO_printf(bio_err, "CONNECTION CLOSED\n");
3227 BUF_reverse((unsigned char *)buf, NULL, i);
3229 BIO_write(io, buf, i + 1);
3234 if (!BIO_should_retry(io))
3240 /* make sure we re-use sessions */
3241 SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
3252 #ifndef OPENSSL_NO_RSA
3253 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
3256 static RSA *rsa_tmp = NULL;
3258 if (!rsa_tmp && ((bn = BN_new()) == NULL))
3259 BIO_printf(bio_err, "Allocation error in generating RSA key\n");
3260 if (!rsa_tmp && bn) {
3262 BIO_printf(bio_err, "Generating temp (%d bit) RSA key...",
3264 (void)BIO_flush(bio_err);
3266 if (!BN_set_word(bn, RSA_F4) || ((rsa_tmp = RSA_new()) == NULL) ||
3267 !RSA_generate_key_ex(rsa_tmp, keylength, bn, NULL)) {
3273 BIO_printf(bio_err, "\n");
3274 (void)BIO_flush(bio_err);
3282 #define MAX_SESSION_ID_ATTEMPTS 10
3283 static int generate_session_id(const SSL *ssl, unsigned char *id,
3284 unsigned int *id_len)
3286 unsigned int count = 0;
3288 if (RAND_pseudo_bytes(id, *id_len) < 0)
3291 * Prefix the session_id with the required prefix. NB: If our prefix
3292 * is too long, clip it - but there will be worse effects anyway, eg.
3293 * the server could only possibly create 1 session ID (ie. the
3294 * prefix!) so all future session negotiations will fail due to
3297 memcpy(id, session_id_prefix,
3298 (strlen(session_id_prefix) < *id_len) ?
3299 strlen(session_id_prefix) : *id_len);
3301 while (SSL_has_matching_session_id(ssl, id, *id_len) &&
3302 (++count < MAX_SESSION_ID_ATTEMPTS));
3303 if (count >= MAX_SESSION_ID_ATTEMPTS)
3309 * By default s_server uses an in-memory cache which caches SSL_SESSION
3310 * structures without any serialisation. This hides some bugs which only
3311 * become apparent in deployed servers. By implementing a basic external
3312 * session cache some issues can be debugged using s_server.
3315 typedef struct simple_ssl_session_st {
3320 struct simple_ssl_session_st *next;
3321 } simple_ssl_session;
3323 static simple_ssl_session *first = NULL;
3325 static int add_session(SSL *ssl, SSL_SESSION *session)
3327 simple_ssl_session *sess;
3330 sess = OPENSSL_malloc(sizeof(simple_ssl_session));
3332 BIO_printf(bio_err, "Out of memory adding session to external cache\n");
3336 SSL_SESSION_get_id(session, &sess->idlen);
3337 sess->derlen = i2d_SSL_SESSION(session, NULL);
3339 sess->id = BUF_memdup(SSL_SESSION_get_id(session, NULL), sess->idlen);
3341 sess->der = OPENSSL_malloc(sess->derlen);
3342 if (!sess->id || !sess->der) {
3343 BIO_printf(bio_err, "Out of memory adding session to external cache\n");
3346 OPENSSL_free(sess->id);
3348 OPENSSL_free(sess->der);
3353 i2d_SSL_SESSION(session, &p);
3357 BIO_printf(bio_err, "New session added to external cache\n");
3361 static SSL_SESSION *get_session(SSL *ssl, unsigned char *id, int idlen,
3364 simple_ssl_session *sess;
3366 for (sess = first; sess; sess = sess->next) {
3367 if (idlen == (int)sess->idlen && !memcmp(sess->id, id, idlen)) {
3368 const unsigned char *p = sess->der;
3369 BIO_printf(bio_err, "Lookup session: cache hit\n");
3370 return d2i_SSL_SESSION(NULL, &p, sess->derlen);
3373 BIO_printf(bio_err, "Lookup session: cache miss\n");
3377 static void del_session(SSL_CTX *sctx, SSL_SESSION *session)
3379 simple_ssl_session *sess, *prev = NULL;
3380 const unsigned char *id;
3382 id = SSL_SESSION_get_id(session, &idlen);
3383 for (sess = first; sess; sess = sess->next) {
3384 if (idlen == sess->idlen && !memcmp(sess->id, id, idlen)) {
3386 prev->next = sess->next;
3389 OPENSSL_free(sess->id);
3390 OPENSSL_free(sess->der);
3398 static void init_session_cache_ctx(SSL_CTX *sctx)
3400 SSL_CTX_set_session_cache_mode(sctx,
3401 SSL_SESS_CACHE_NO_INTERNAL |
3402 SSL_SESS_CACHE_SERVER);
3403 SSL_CTX_sess_set_new_cb(sctx, add_session);
3404 SSL_CTX_sess_set_get_cb(sctx, get_session);
3405 SSL_CTX_sess_set_remove_cb(sctx, del_session);
3408 static void free_sessions(void)
3410 simple_ssl_session *sess, *tsess;
3411 for (sess = first; sess;) {
3412 OPENSSL_free(sess->id);
3413 OPENSSL_free(sess->der);
3416 OPENSSL_free(tsess);