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");
2464 if (read_from_sslcon) {
2465 if (!SSL_is_init_finished(con)) {
2466 i = init_ssl_connection(con);
2471 } else if (i == 0) {
2477 i = SSL_read(con, (char *)buf, bufsize);
2478 #ifndef OPENSSL_NO_SRP
2479 while (SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2480 BIO_printf(bio_s_out, "LOOKUP renego during read\n");
2481 srp_callback_parm.user =
2482 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2483 srp_callback_parm.login);
2484 if (srp_callback_parm.user)
2485 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2486 srp_callback_parm.user->info);
2488 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2489 i = SSL_read(con, (char *)buf, bufsize);
2492 switch (SSL_get_error(con, i)) {
2493 case SSL_ERROR_NONE:
2494 #ifdef CHARSET_EBCDIC
2495 ascii2ebcdic(buf, buf, i);
2497 raw_write_stdout(buf, (unsigned int)i);
2498 if (SSL_pending(con))
2501 case SSL_ERROR_WANT_WRITE:
2502 case SSL_ERROR_WANT_READ:
2503 BIO_printf(bio_s_out, "Read BLOCK\n");
2505 case SSL_ERROR_SYSCALL:
2507 BIO_printf(bio_s_out, "ERROR\n");
2508 ERR_print_errors(bio_err);
2511 case SSL_ERROR_ZERO_RETURN:
2512 BIO_printf(bio_s_out, "DONE\n");
2521 BIO_printf(bio_s_out, "shutting down SSL\n");
2523 SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
2529 BIO_printf(bio_s_out, "CONNECTION CLOSED\n");
2531 OPENSSL_cleanse(buf, bufsize);
2535 BIO_printf(bio_s_out, "ACCEPT\n");
2539 static void close_accept_socket(void)
2541 BIO_printf(bio_err, "shutdown accept socket\n");
2542 if (accept_socket >= 0) {
2543 SHUTDOWN2(accept_socket);
2547 static int init_ssl_connection(SSL *con)
2553 MS_STATIC char buf[BUFSIZ];
2554 #ifndef OPENSSL_NO_KRB5
2557 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2558 const unsigned char *next_proto_neg;
2559 unsigned next_proto_neg_len;
2561 unsigned char *exportedkeymat;
2563 i = SSL_accept(con);
2564 #ifdef CERT_CB_TEST_RETRY
2566 while (i <= 0 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP
2567 && SSL_state(con) == SSL3_ST_SR_CLNT_HELLO_C) {
2569 "LOOKUP from certificate callback during accept\n");
2570 i = SSL_accept(con);
2574 #ifndef OPENSSL_NO_SRP
2575 while (i <= 0 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2576 BIO_printf(bio_s_out, "LOOKUP during accept %s\n",
2577 srp_callback_parm.login);
2578 srp_callback_parm.user =
2579 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2580 srp_callback_parm.login);
2581 if (srp_callback_parm.user)
2582 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2583 srp_callback_parm.user->info);
2585 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2586 i = SSL_accept(con);
2591 if (BIO_sock_should_retry(i)) {
2592 BIO_printf(bio_s_out, "DELAY\n");
2596 BIO_printf(bio_err, "ERROR\n");
2597 verify_error = SSL_get_verify_result(con);
2598 if (verify_error != X509_V_OK) {
2599 BIO_printf(bio_err, "verify error:%s\n",
2600 X509_verify_cert_error_string(verify_error));
2602 /* Always print any error messages */
2603 ERR_print_errors(bio_err);
2608 print_ssl_summary(bio_err, con);
2610 PEM_write_bio_SSL_SESSION(bio_s_out, SSL_get_session(con));
2612 peer = SSL_get_peer_certificate(con);
2614 BIO_printf(bio_s_out, "Client certificate\n");
2615 PEM_write_bio_X509(bio_s_out, peer);
2616 X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof buf);
2617 BIO_printf(bio_s_out, "subject=%s\n", buf);
2618 X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof buf);
2619 BIO_printf(bio_s_out, "issuer=%s\n", buf);
2623 if (SSL_get_shared_ciphers(con, buf, sizeof buf) != NULL)
2624 BIO_printf(bio_s_out, "Shared ciphers:%s\n", buf);
2625 str = SSL_CIPHER_get_name(SSL_get_current_cipher(con));
2626 ssl_print_sigalgs(bio_s_out, con);
2627 #ifndef OPENSSL_NO_EC
2628 ssl_print_point_formats(bio_s_out, con);
2629 ssl_print_curves(bio_s_out, con, 0);
2631 BIO_printf(bio_s_out, "CIPHER is %s\n", (str != NULL) ? str : "(NONE)");
2633 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2634 SSL_get0_next_proto_negotiated(con, &next_proto_neg, &next_proto_neg_len);
2635 if (next_proto_neg) {
2636 BIO_printf(bio_s_out, "NEXTPROTO is ");
2637 BIO_write(bio_s_out, next_proto_neg, next_proto_neg_len);
2638 BIO_printf(bio_s_out, "\n");
2641 #ifndef OPENSSL_NO_SRTP
2643 SRTP_PROTECTION_PROFILE *srtp_profile
2644 = SSL_get_selected_srtp_profile(con);
2647 BIO_printf(bio_s_out, "SRTP Extension negotiated, profile=%s\n",
2648 srtp_profile->name);
2651 if (SSL_cache_hit(con))
2652 BIO_printf(bio_s_out, "Reused session-id\n");
2653 if (SSL_ctrl(con, SSL_CTRL_GET_FLAGS, 0, NULL) &
2654 TLS1_FLAGS_TLS_PADDING_BUG)
2655 BIO_printf(bio_s_out, "Peer has incorrect TLSv1 block padding\n");
2656 #ifndef OPENSSL_NO_KRB5
2657 client_princ = kssl_ctx_get0_client_princ(SSL_get0_kssl_ctx(con));
2658 if (client_princ != NULL) {
2659 BIO_printf(bio_s_out, "Kerberos peer principal is %s\n",
2662 #endif /* OPENSSL_NO_KRB5 */
2663 BIO_printf(bio_s_out, "Secure Renegotiation IS%s supported\n",
2664 SSL_get_secure_renegotiation_support(con) ? "" : " NOT");
2665 if (keymatexportlabel != NULL) {
2666 BIO_printf(bio_s_out, "Keying material exporter:\n");
2667 BIO_printf(bio_s_out, " Label: '%s'\n", keymatexportlabel);
2668 BIO_printf(bio_s_out, " Length: %i bytes\n", keymatexportlen);
2669 exportedkeymat = OPENSSL_malloc(keymatexportlen);
2670 if (exportedkeymat != NULL) {
2671 if (!SSL_export_keying_material(con, exportedkeymat,
2674 strlen(keymatexportlabel),
2676 BIO_printf(bio_s_out, " Error\n");
2678 BIO_printf(bio_s_out, " Keying material: ");
2679 for (i = 0; i < keymatexportlen; i++)
2680 BIO_printf(bio_s_out, "%02X", exportedkeymat[i]);
2681 BIO_printf(bio_s_out, "\n");
2683 OPENSSL_free(exportedkeymat);
2690 #ifndef OPENSSL_NO_DH
2691 static DH *load_dh_param(const char *dhfile)
2696 if ((bio = BIO_new_file(dhfile, "r")) == NULL)
2698 ret = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
2705 #ifndef OPENSSL_NO_KRB5
2710 static int load_CA(SSL_CTX *ctx, char *file)
2715 if ((in = fopen(file, "r")) == NULL)
2719 if (PEM_read_X509(in, &x, NULL) == NULL)
2721 SSL_CTX_add_client_CA(ctx, x);
2730 static int www_body(char *hostname, int s, int stype, unsigned char *context)
2736 const SSL_CIPHER *c;
2737 BIO *io, *ssl_bio, *sbio;
2738 #ifndef OPENSSL_NO_KRB5
2742 buf = OPENSSL_malloc(bufsize);
2745 io = BIO_new(BIO_f_buffer());
2746 ssl_bio = BIO_new(BIO_f_ssl());
2747 if ((io == NULL) || (ssl_bio == NULL))
2752 unsigned long sl = 1;
2755 BIO_printf(bio_err, "turning on non blocking io\n");
2756 if (BIO_socket_ioctl(s, FIONBIO, &sl) < 0)
2757 ERR_print_errors(bio_err);
2761 /* lets make the output buffer a reasonable size */
2762 if (!BIO_set_write_buffer_size(io, bufsize))
2765 if ((con = SSL_new(ctx)) == NULL)
2767 #ifndef OPENSSL_NO_TLSEXT
2768 if (s_tlsextdebug) {
2769 SSL_set_tlsext_debug_callback(con, tlsext_cb);
2770 SSL_set_tlsext_debug_arg(con, bio_s_out);
2773 #ifndef OPENSSL_NO_KRB5
2774 if ((kctx = kssl_ctx_new()) != NULL) {
2775 kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
2776 kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
2778 #endif /* OPENSSL_NO_KRB5 */
2780 SSL_set_session_id_context(con, context, strlen((char *)context));
2782 sbio = BIO_new_socket(s, BIO_NOCLOSE);
2786 test = BIO_new(BIO_f_nbio_test());
2787 sbio = BIO_push(test, sbio);
2789 SSL_set_bio(con, sbio, sbio);
2790 SSL_set_accept_state(con);
2792 /* SSL_set_fd(con,s); */
2793 BIO_set_ssl(ssl_bio, con, BIO_CLOSE);
2794 BIO_push(io, ssl_bio);
2795 #ifdef CHARSET_EBCDIC
2796 io = BIO_push(BIO_new(BIO_f_ebcdic_filter()), io);
2800 SSL_set_debug(con, 1);
2801 BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
2802 BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
2805 #ifndef OPENSSL_NO_SSL_TRACE
2807 SSL_set_msg_callback(con, SSL_trace);
2810 SSL_set_msg_callback(con, msg_cb);
2811 SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
2816 i = SSL_accept(con);
2817 #ifndef OPENSSL_NO_SRP
2819 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2820 BIO_printf(bio_s_out, "LOOKUP during accept %s\n",
2821 srp_callback_parm.login);
2822 srp_callback_parm.user =
2823 SRP_VBASE_get_by_user(srp_callback_parm.vb,
2824 srp_callback_parm.login);
2825 if (srp_callback_parm.user)
2826 BIO_printf(bio_s_out, "LOOKUP done %s\n",
2827 srp_callback_parm.user->info);
2829 BIO_printf(bio_s_out, "LOOKUP not successful\n");
2830 i = SSL_accept(con);
2833 switch (SSL_get_error(con, i)) {
2834 case SSL_ERROR_NONE:
2836 case SSL_ERROR_WANT_WRITE:
2837 case SSL_ERROR_WANT_READ:
2838 case SSL_ERROR_WANT_X509_LOOKUP:
2840 case SSL_ERROR_SYSCALL:
2842 case SSL_ERROR_ZERO_RETURN:
2848 SSL_renegotiate(con);
2849 SSL_write(con, NULL, 0);
2852 i = BIO_gets(io, buf, bufsize - 1);
2853 if (i < 0) { /* error */
2854 if (!BIO_should_retry(io)) {
2856 ERR_print_errors(bio_err);
2859 BIO_printf(bio_s_out, "read R BLOCK\n");
2860 #if defined(OPENSSL_SYS_NETWARE)
2862 #elif !defined(OPENSSL_SYS_MSDOS) && !defined(__DJGPP__)
2867 } else if (i == 0) { /* end of input */
2872 /* else we have data */
2873 if (((www == 1) && (strncmp("GET ", buf, 4) == 0)) ||
2874 ((www == 2) && (strncmp("GET /stats ", buf, 11) == 0))) {
2877 STACK_OF(SSL_CIPHER) *sk;
2878 static const char *space = " ";
2881 "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
2882 BIO_puts(io, "<HTML><BODY BGCOLOR=\"#ffffff\">\n");
2883 BIO_puts(io, "<pre>\n");
2884 /* BIO_puts(io,SSLeay_version(SSLEAY_VERSION));*/
2886 for (i = 0; i < local_argc; i++) {
2887 BIO_puts(io, local_argv[i]);
2888 BIO_write(io, " ", 1);
2893 "Secure Renegotiation IS%s supported\n",
2894 SSL_get_secure_renegotiation_support(con) ?
2898 * The following is evil and should not really be done
2900 BIO_printf(io, "Ciphers supported in s_server binary\n");
2901 sk = SSL_get_ciphers(con);
2902 j = sk_SSL_CIPHER_num(sk);
2903 for (i = 0; i < j; i++) {
2904 c = sk_SSL_CIPHER_value(sk, i);
2905 BIO_printf(io, "%-11s:%-25s",
2906 SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2907 if ((((i + 1) % 2) == 0) && (i + 1 != j))
2911 p = SSL_get_shared_ciphers(con, buf, bufsize);
2914 "---\nCiphers common between both SSL end points:\n");
2918 BIO_write(io, space, 26 - j);
2921 BIO_write(io, ((i % 3) ? " " : "\n"), 1);
2923 BIO_write(io, p, 1);
2930 ssl_print_sigalgs(io, con);
2931 #ifndef OPENSSL_NO_EC
2932 ssl_print_curves(io, con, 0);
2934 BIO_printf(io, (SSL_cache_hit(con)
2935 ? "---\nReused, " : "---\nNew, "));
2936 c = SSL_get_current_cipher(con);
2937 BIO_printf(io, "%s, Cipher is %s\n",
2938 SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2939 SSL_SESSION_print(io, SSL_get_session(con));
2940 BIO_printf(io, "---\n");
2941 print_stats(io, SSL_get_SSL_CTX(con));
2942 BIO_printf(io, "---\n");
2943 peer = SSL_get_peer_certificate(con);
2945 BIO_printf(io, "Client certificate\n");
2946 X509_print(io, peer);
2947 PEM_write_bio_X509(io, peer);
2949 BIO_puts(io, "no client certificate available\n");
2950 BIO_puts(io, "</BODY></HTML>\r\n\r\n");
2952 } else if ((www == 2 || www == 3)
2953 && (strncmp("GET /", buf, 5) == 0)) {
2956 static const char *text =
2957 "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n";
2963 for (e = p; *e != '\0'; e++) {
2969 dot = (e[0] == '.') ? 2 : 0;
2972 dot = (e[0] == '.') ? 3 : 0;
2975 dot = (e[0] == '/') ? -1 : 0;
2979 dot = (e[0] == '/') ? 1 : 0;
2981 dot = (dot == 3) || (dot == -1); /* filename contains ".."
2986 BIO_printf(io, "'%s' is an invalid file name\r\n", p);
2993 BIO_printf(io, "'%s' contains '..' reference\r\n", p);
2999 BIO_printf(io, "'%s' is an invalid path\r\n", p);
3003 /* append if a directory lookup */
3005 strcat(p, "index.html");
3008 /* if a directory, do the index thang */
3009 if (app_isdir(p) > 0) {
3010 #if 0 /* must check buffer size */
3011 strcat(p, "/index.html");
3014 BIO_printf(io, "'%s' is a directory\r\n", p);
3019 if ((file = BIO_new_file(p, "r")) == NULL) {
3021 BIO_printf(io, "Error opening '%s'\r\n", p);
3022 ERR_print_errors(io);
3027 BIO_printf(bio_err, "FILE:%s\n", p);
3031 if (((i > 5) && (strcmp(&(p[i - 5]), ".html") == 0)) ||
3032 ((i > 4) && (strcmp(&(p[i - 4]), ".php") == 0)) ||
3033 ((i > 4) && (strcmp(&(p[i - 4]), ".htm") == 0)))
3035 "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
3038 "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n");
3042 i = BIO_read(file, buf, bufsize);
3048 fprintf(stderr, "%d\n", i);
3049 if (total_bytes > 3 * 1024) {
3051 fprintf(stderr, "RENEGOTIATE\n");
3052 SSL_renegotiate(con);
3056 for (j = 0; j < i;) {
3060 if (++count == 13) {
3061 SSL_renegotiate(con);
3065 k = BIO_write(io, &(buf[j]), i - j);
3067 if (!BIO_should_retry(io))
3070 BIO_printf(bio_s_out, "rwrite W BLOCK\n");
3084 i = (int)BIO_flush(io);
3086 if (!BIO_should_retry(io))
3093 /* make sure we re-use sessions */
3094 SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
3096 /* This kills performance */
3098 * SSL_shutdown(con); A shutdown gets sent in the BIO_free_all(io)
3106 BIO_printf(bio_s_out, "ACCEPT\n");
3112 /* if (ssl_bio != NULL) BIO_free(ssl_bio);*/
3116 static int rev_body(char *hostname, int s, int stype, unsigned char *context)
3122 BIO *io, *ssl_bio, *sbio;
3123 #ifndef OPENSSL_NO_KRB5
3127 buf = OPENSSL_malloc(bufsize);
3130 io = BIO_new(BIO_f_buffer());
3131 ssl_bio = BIO_new(BIO_f_ssl());
3132 if ((io == NULL) || (ssl_bio == NULL))
3135 /* lets make the output buffer a reasonable size */
3136 if (!BIO_set_write_buffer_size(io, bufsize))
3139 if ((con = SSL_new(ctx)) == NULL)
3141 #ifndef OPENSSL_NO_TLSEXT
3142 if (s_tlsextdebug) {
3143 SSL_set_tlsext_debug_callback(con, tlsext_cb);
3144 SSL_set_tlsext_debug_arg(con, bio_s_out);
3147 #ifndef OPENSSL_NO_KRB5
3148 if ((kctx = kssl_ctx_new()) != NULL) {
3149 kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
3150 kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
3152 #endif /* OPENSSL_NO_KRB5 */
3154 SSL_set_session_id_context(con, context, strlen((char *)context));
3156 sbio = BIO_new_socket(s, BIO_NOCLOSE);
3157 SSL_set_bio(con, sbio, sbio);
3158 SSL_set_accept_state(con);
3160 BIO_set_ssl(ssl_bio, con, BIO_CLOSE);
3161 BIO_push(io, ssl_bio);
3162 #ifdef CHARSET_EBCDIC
3163 io = BIO_push(BIO_new(BIO_f_ebcdic_filter()), io);
3167 SSL_set_debug(con, 1);
3168 BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
3169 BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
3172 #ifndef OPENSSL_NO_SSL_TRACE
3174 SSL_set_msg_callback(con, SSL_trace);
3177 SSL_set_msg_callback(con, msg_cb);
3178 SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
3182 i = BIO_do_handshake(io);
3185 if (!BIO_should_retry(io)) {
3186 BIO_puts(bio_err, "CONNECTION FAILURE\n");
3187 ERR_print_errors(bio_err);
3191 BIO_printf(bio_err, "CONNECTION ESTABLISHED\n");
3192 print_ssl_summary(bio_err, con);
3195 i = BIO_gets(io, buf, bufsize - 1);
3196 if (i < 0) { /* error */
3197 if (!BIO_should_retry(io)) {
3199 ERR_print_errors(bio_err);
3202 BIO_printf(bio_s_out, "read R BLOCK\n");
3203 #if defined(OPENSSL_SYS_NETWARE)
3205 #elif !defined(OPENSSL_SYS_MSDOS) && !defined(__DJGPP__)
3210 } else if (i == 0) { /* end of input */
3212 BIO_printf(bio_err, "CONNECTION CLOSED\n");
3215 char *p = buf + i - 1;
3216 while (i && (*p == '\n' || *p == '\r')) {
3220 if (!s_ign_eof && i == 5 && !strncmp(buf, "CLOSE", 5)) {
3222 BIO_printf(bio_err, "CONNECTION CLOSED\n");
3225 BUF_reverse((unsigned char *)buf, NULL, i);
3227 BIO_write(io, buf, i + 1);
3232 if (!BIO_should_retry(io))
3238 /* make sure we re-use sessions */
3239 SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
3250 #ifndef OPENSSL_NO_RSA
3251 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
3254 static RSA *rsa_tmp = NULL;
3256 if (!rsa_tmp && ((bn = BN_new()) == NULL))
3257 BIO_printf(bio_err, "Allocation error in generating RSA key\n");
3258 if (!rsa_tmp && bn) {
3260 BIO_printf(bio_err, "Generating temp (%d bit) RSA key...",
3262 (void)BIO_flush(bio_err);
3264 if (!BN_set_word(bn, RSA_F4) || ((rsa_tmp = RSA_new()) == NULL) ||
3265 !RSA_generate_key_ex(rsa_tmp, keylength, bn, NULL)) {
3271 BIO_printf(bio_err, "\n");
3272 (void)BIO_flush(bio_err);
3280 #define MAX_SESSION_ID_ATTEMPTS 10
3281 static int generate_session_id(const SSL *ssl, unsigned char *id,
3282 unsigned int *id_len)
3284 unsigned int count = 0;
3286 if (RAND_pseudo_bytes(id, *id_len) < 0)
3289 * Prefix the session_id with the required prefix. NB: If our prefix
3290 * is too long, clip it - but there will be worse effects anyway, eg.
3291 * the server could only possibly create 1 session ID (ie. the
3292 * prefix!) so all future session negotiations will fail due to
3295 memcpy(id, session_id_prefix,
3296 (strlen(session_id_prefix) < *id_len) ?
3297 strlen(session_id_prefix) : *id_len);
3299 while (SSL_has_matching_session_id(ssl, id, *id_len) &&
3300 (++count < MAX_SESSION_ID_ATTEMPTS));
3301 if (count >= MAX_SESSION_ID_ATTEMPTS)
3307 * By default s_server uses an in-memory cache which caches SSL_SESSION
3308 * structures without any serialisation. This hides some bugs which only
3309 * become apparent in deployed servers. By implementing a basic external
3310 * session cache some issues can be debugged using s_server.
3313 typedef struct simple_ssl_session_st {
3318 struct simple_ssl_session_st *next;
3319 } simple_ssl_session;
3321 static simple_ssl_session *first = NULL;
3323 static int add_session(SSL *ssl, SSL_SESSION *session)
3325 simple_ssl_session *sess;
3328 sess = OPENSSL_malloc(sizeof(simple_ssl_session));
3330 BIO_printf(bio_err, "Out of memory adding session to external cache\n");
3334 SSL_SESSION_get_id(session, &sess->idlen);
3335 sess->derlen = i2d_SSL_SESSION(session, NULL);
3337 sess->id = BUF_memdup(SSL_SESSION_get_id(session, NULL), sess->idlen);
3339 sess->der = OPENSSL_malloc(sess->derlen);
3340 if (!sess->id || !sess->der) {
3341 BIO_printf(bio_err, "Out of memory adding session to external cache\n");
3344 OPENSSL_free(sess->id);
3346 OPENSSL_free(sess->der);
3351 i2d_SSL_SESSION(session, &p);
3355 BIO_printf(bio_err, "New session added to external cache\n");
3359 static SSL_SESSION *get_session(SSL *ssl, unsigned char *id, int idlen,
3362 simple_ssl_session *sess;
3364 for (sess = first; sess; sess = sess->next) {
3365 if (idlen == (int)sess->idlen && !memcmp(sess->id, id, idlen)) {
3366 const unsigned char *p = sess->der;
3367 BIO_printf(bio_err, "Lookup session: cache hit\n");
3368 return d2i_SSL_SESSION(NULL, &p, sess->derlen);
3371 BIO_printf(bio_err, "Lookup session: cache miss\n");
3375 static void del_session(SSL_CTX *sctx, SSL_SESSION *session)
3377 simple_ssl_session *sess, *prev = NULL;
3378 const unsigned char *id;
3380 id = SSL_SESSION_get_id(session, &idlen);
3381 for (sess = first; sess; sess = sess->next) {
3382 if (idlen == sess->idlen && !memcmp(sess->id, id, idlen)) {
3384 prev->next = sess->next;
3387 OPENSSL_free(sess->id);
3388 OPENSSL_free(sess->der);
3396 static void init_session_cache_ctx(SSL_CTX *sctx)
3398 SSL_CTX_set_session_cache_mode(sctx,
3399 SSL_SESS_CACHE_NO_INTERNAL |
3400 SSL_SESS_CACHE_SERVER);
3401 SSL_CTX_sess_set_new_cb(sctx, add_session);
3402 SSL_CTX_sess_set_get_cb(sctx, get_session);
3403 SSL_CTX_sess_set_remove_cb(sctx, del_session);
3406 static void free_sessions(void)
3408 simple_ssl_session *sess, *tsess;
3409 for (sess = first; sess;) {
3410 OPENSSL_free(sess->id);
3411 OPENSSL_free(sess->der);
3414 OPENSSL_free(tsess);