apps/s_server.c

   1 /* apps/s_server.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   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.
   8  *
   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).
  15  *
  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.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  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)"
  40  *
  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
  51  * SUCH DAMAGE.
  52  *
  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.]
  57  */
  58 /* ====================================================================
  59  * Copyright (c) 1998-2006 The OpenSSL Project.  All rights reserved.
  60  *
  61  * Redistribution and use in source and binary forms, with or without
  62  * modification, are permitted provided that the following conditions
  63  * are met:
  64  *
  65  * 1. Redistributions of source code must retain the above copyright
  66  *    notice, this list of conditions and the following disclaimer.
  67  *
  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
  71  *    distribution.
  72  *
  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/)"
  77  *
  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.
  82  *
  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.
  86  *
  87  * 6. Redistributions of any form whatsoever must retain the following
  88  *    acknowledgment:
  89  *    "This product includes software developed by the OpenSSL Project
  90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  91  *
  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  * ====================================================================
 105  *
 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).
 109  *
 110  */
 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.
 115  */
 116 /* ====================================================================
 117  * Copyright 2005 Nokia. All rights reserved.
 118  *
 119  * The portions of the attached software ("Contribution") is developed by
 120  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
 121  * license.
 122  *
 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.
 126  *
 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.
 130  *
 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.
 135  *
 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
 140  * OTHERWISE.
 141  */
 142
 143 /*
 144  * Until the key-gen callbacks are modified to use newer prototypes, we allow
 145  * deprecated functions for openssl-internal code
 146  */
 147 #ifdef OPENSSL_NO_DEPRECATED
 148 # undef OPENSSL_NO_DEPRECATED
 149 #endif
 150
 151 #include <assert.h>
 152 #include <ctype.h>
 153 #include <stdio.h>
 154 #include <stdlib.h>
 155 #include <string.h>
 156
 157 #include <openssl/e_os2.h>
 158 #ifdef OPENSSL_NO_STDIO
 159 # define APPS_WIN16
 160 #endif
 161
 162 /* conflicts with winsock2 stuff on netware */
 163 #if !defined(OPENSSL_SYS_NETWARE)
 164 # include <sys/types.h>
 165 #endif
 166
 167 /*
 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
 172  */
 173 #if defined(OPENSSL_SYS_VMS_DECC) && !defined(__U_INT)
 174 # define __U_INT
 175 typedef unsigned int u_int;
 176 #endif
 177
 178 #include <openssl/lhash.h>
 179 #include <openssl/bn.h>
 180 #define USE_SOCKETS
 181 #include "apps.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>
 190 #endif
 191 #ifndef OPENSSL_NO_RSA
 192 # include <openssl/rsa.h>
 193 #endif
 194 #ifndef OPENSSL_NO_SRP
 195 # include <openssl/srp.h>
 196 #endif
 197 #include "s_apps.h"
 198 #include "timeouts.h"
 199
 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 */
 202 # undef FIONBIO
 203 #endif
 204
 205 #if defined(OPENSSL_SYS_BEOS_R5)
 206 # include <fcntl.h>
 207 #endif
 208
 209 #ifndef OPENSSL_NO_RSA
 210 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength);
 211 #endif
 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);
 226 #endif
 227
 228 #ifdef MONOLITH
 229 static void s_server_init(void);
 230 #endif
 231
 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,
 240 };
 241
 242 static unsigned char dh512_g[] = {
 243     0x02,
 244 };
 245
 246 static DH *get_dh512(void)
 247 {
 248     DH *dh = NULL;
 249
 250     if ((dh = DH_new()) == NULL)
 251         return (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))
 255         return (NULL);
 256     return (dh);
 257 }
 258 #endif
 259
 260 /* static int load_CA(SSL_CTX *ctx, char *file);*/
 261
 262 #undef BUFSIZZ
 263 #define BUFSIZZ 16*1024
 264 static int bufsize = BUFSIZZ;
 265 static int accept_socket = -1;
 266
 267 #define TEST_CERT       "server.pem"
 268 #ifndef OPENSSL_NO_TLSEXT
 269 # define TEST_CERT2      "server2.pem"
 270 #endif
 271 #undef PROG
 272 #define PROG            s_server_main
 273
 274 extern int verify_depth, verify_return_error, verify_quiet;
 275
 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;
 282 #endif
 283 static char *s_dcert_file = NULL, *s_dkey_file = NULL, *s_dchain_file = NULL;
 284 #ifdef FIONBIO
 285 static int s_nbio = 0;
 286 #endif
 287 static int s_nbio_test = 0;
 288 int s_crlf = 0;
 289 static SSL_CTX *ctx = NULL;
 290 #ifndef OPENSSL_NO_TLSEXT
 291 static SSL_CTX *ctx2 = NULL;
 292 #endif
 293 static int www = 0;
 294
 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);
 302 #endif
 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;
 308
 309 static char *keymatexportlabel = NULL;
 310 static int keymatexportlen = 20;
 311
 312 static int hack = 0;
 313 #ifndef OPENSSL_NO_ENGINE
 314 static char *engine_id = NULL;
 315 #endif
 316 static const char *session_id_prefix = NULL;
 317
 318 static int enable_timeouts = 0;
 319 static long socket_mtu;
 320 #ifndef OPENSSL_NO_DTLS1
 321 static int cert_chain = 0;
 322 #endif
 323
 324 #ifndef OPENSSL_NO_TLSEXT
 325 static BIO *serverinfo_in = NULL;
 326 static const char *s_serverinfo_file = NULL;
 327
 328 #endif
 329
 330 #ifndef OPENSSL_NO_PSK
 331 static char *psk_identity = "Client_identity";
 332 char *psk_key = NULL;           /* by default PSK is not used */
 333
 334 static unsigned int psk_server_cb(SSL *ssl, const char *identity,
 335                                   unsigned char *psk,
 336                                   unsigned int max_psk_len)
 337 {
 338     unsigned int psk_len = 0;
 339     int ret;
 340     BIGNUM *bn = NULL;
 341
 342     if (s_debug)
 343         BIO_printf(bio_s_out, "psk_server_cb\n");
 344     if (!identity) {
 345         BIO_printf(bio_err, "Error: client did not send PSK identity\n");
 346         goto out_err;
 347     }
 348     if (s_debug)
 349         BIO_printf(bio_s_out, "identity_len=%d identity=%s\n",
 350                    identity ? (int)strlen(identity) : 0, identity);
 351
 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);
 356         goto out_err;
 357     }
 358     if (s_debug)
 359         BIO_printf(bio_s_out, "PSK client identity found\n");
 360
 361     /* convert the PSK key to binary */
 362     ret = BN_hex2bn(&bn, psk_key);
 363     if (!ret) {
 364         BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
 365                    psk_key);
 366         if (bn)
 367             BN_free(bn);
 368         return 0;
 369     }
 370     if (BN_num_bytes(bn) > (int)max_psk_len) {
 371         BIO_printf(bio_err,
 372                    "psk buffer of callback is too small (%d) for key (%d)\n",
 373                    max_psk_len, BN_num_bytes(bn));
 374         BN_free(bn);
 375         return 0;
 376     }
 377
 378     ret = BN_bn2bin(bn, psk);
 379     BN_free(bn);
 380
 381     if (ret < 0)
 382         goto out_err;
 383     psk_len = (unsigned int)ret;
 384
 385     if (s_debug)
 386         BIO_printf(bio_s_out, "fetched PSK len=%d\n", psk_len);
 387     return psk_len;
 388  out_err:
 389     if (s_debug)
 390         BIO_printf(bio_err, "Error in PSK server callback\n");
 391     return 0;
 392 }
 393 #endif
 394
 395 #ifndef OPENSSL_NO_SRP
 396 /* This is a context that we pass to callbacks */
 397 typedef struct srpsrvparm_st {
 398     char *login;
 399     SRP_VBASE *vb;
 400     SRP_user_pwd *user;
 401 } srpsrvparm;
 402
 403 /*
 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
 409  * user parameters.
 410  */
 411 static int MS_CALLBACK ssl_srp_server_param_cb(SSL *s, int *ad, void *arg)
 412 {
 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);
 417         return (-1);
 418     }
 419
 420     if (p->user == NULL) {
 421         BIO_printf(bio_err, "User %s doesn't exist\n", p->login);
 422         return SSL3_AL_FATAL;
 423     }
 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;
 429     }
 430     BIO_printf(bio_err,
 431                "SRP parameters set: username = \"%s\" info=\"%s\" \n",
 432                p->login, p->user->info);
 433     /* need to check whether there are memory leaks */
 434     p->user = NULL;
 435     p->login = NULL;
 436     return SSL_ERROR_NONE;
 437 }
 438
 439 #endif
 440
 441 #ifdef MONOLITH
 442 static void s_server_init(void)
 443 {
 444     accept_socket = -1;
 445     s_server_verify = SSL_VERIFY_NONE;
 446     s_dcert_file = NULL;
 447     s_dkey_file = NULL;
 448     s_dchain_file = NULL;
 449     s_cert_file = TEST_CERT;
 450     s_key_file = NULL;
 451     s_chain_file = NULL;
 452 # ifndef OPENSSL_NO_TLSEXT
 453     s_cert_file2 = TEST_CERT2;
 454     s_key_file2 = NULL;
 455     ctx2 = NULL;
 456 # endif
 457 # ifdef FIONBIO
 458     s_nbio = 0;
 459 # endif
 460     s_nbio_test = 0;
 461     ctx = NULL;
 462     www = 0;
 463
 464     bio_s_out = NULL;
 465     s_debug = 0;
 466     s_msg = 0;
 467     s_quiet = 0;
 468     s_brief = 0;
 469     hack = 0;
 470 # ifndef OPENSSL_NO_ENGINE
 471     engine_id = NULL;
 472 # endif
 473 }
 474 #endif
 475
 476 static void sv_usage(void)
 477 {
 478     BIO_printf(bio_err, "usage: s_server [args ...]\n");
 479     BIO_printf(bio_err, "\n");
 480     BIO_printf(bio_err,
 481                " -accept arg   - port to accept on (default is %d)\n", PORT);
 482     BIO_printf(bio_err,
 483                " -verify_host host - check peer certificate matches \"host\"\n");
 484     BIO_printf(bio_err,
 485                " -verify_email email - check peer certificate matches \"email\"\n");
 486     BIO_printf(bio_err,
 487                " -verify_ip ipaddr - check peer certificate matches \"ipaddr\"\n");
 488     BIO_printf(bio_err, " -context arg  - set session ID context\n");
 489     BIO_printf(bio_err,
 490                " -verify arg   - turn on peer certificate verification\n");
 491     BIO_printf(bio_err,
 492                " -Verify arg   - turn on peer certificate verification, must have a cert.\n");
 493     BIO_printf(bio_err,
 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
 498     BIO_printf(bio_err,
 499                " -serverinfo arg - PEM serverinfo file for certificate\n");
 500     BIO_printf(bio_err,
 501                " -auth               - send and receive RFC 5878 TLS auth extensions and supplemental data\n");
 502     BIO_printf(bio_err,
 503                " -auth_require_reneg - Do not send TLS auth extensions until renegotiation\n");
 504 #endif
 505     BIO_printf(bio_err,
 506                " -no_resumption_on_reneg - set SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION flag\n");
 507     BIO_printf(bio_err,
 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");
 510     BIO_printf(bio_err,
 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");
 514     BIO_printf(bio_err,
 515                " -certform arg - certificate format (PEM or DER) PEM default\n");
 516     BIO_printf(bio_err,
 517                " -key arg      - Private Key file to use, in cert file if\n");
 518     BIO_printf(bio_err, "                 not specified (default is %s)\n",
 519                TEST_CERT);
 520     BIO_printf(bio_err,
 521                " -keyform arg  - key format (PEM, DER or ENGINE) PEM default\n");
 522     BIO_printf(bio_err,
 523                " -pass arg     - private key file pass phrase source\n");
 524     BIO_printf(bio_err,
 525                " -dcert arg    - second certificate file to use (usually for DSA)\n");
 526     BIO_printf(bio_err,
 527                " -dcertform x  - second certificate format (PEM or DER) PEM default\n");
 528     BIO_printf(bio_err,
 529                " -dkey arg     - second private key file to use (usually for DSA)\n");
 530     BIO_printf(bio_err,
 531                " -dkeyform arg - second key format (PEM, DER or ENGINE) PEM default\n");
 532     BIO_printf(bio_err,
 533                " -dpass arg    - second private key file pass phrase source\n");
 534     BIO_printf(bio_err,
 535                " -dhparam arg  - DH parameter file to use, in cert file if not specified\n");
 536     BIO_printf(bio_err,
 537                "                 or a default set of parameters is used\n");
 538 #ifndef OPENSSL_NO_ECDH
 539     BIO_printf(bio_err,
 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");
 543 #endif
 544 #ifdef FIONBIO
 545     BIO_printf(bio_err, " -nbio         - Run with non-blocking IO\n");
 546 #endif
 547     BIO_printf(bio_err,
 548                " -nbio_test    - test with the non-blocking test bio\n");
 549     BIO_printf(bio_err,
 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");
 556     BIO_printf(bio_err,
 557                " -nocert       - Don't use any certificates (Anon-DH)\n");
 558     BIO_printf(bio_err,
 559                " -cipher arg   - play with 'openssl ciphers' to see what goes here\n");
 560     BIO_printf(bio_err, " -serverpref   - Use server's cipher preferences\n");
 561     BIO_printf(bio_err, " -quiet        - No server output\n");
 562     BIO_printf(bio_err, " -no_tmp_rsa   - Do not generate a tmp RSA key\n");
 563 #ifndef OPENSSL_NO_PSK
 564     BIO_printf(bio_err, " -psk_hint arg - PSK identity hint to use\n");
 565     BIO_printf(bio_err, " -psk arg      - PSK in hex (without 0x)\n");
 566 # ifndef OPENSSL_NO_JPAKE
 567     BIO_printf(bio_err, " -jpake arg    - JPAKE secret to use\n");
 568 # endif
 569 #endif
 570 #ifndef OPENSSL_NO_SRP
 571     BIO_printf(bio_err, " -srpvfile file      - The verifier file for SRP\n");
 572     BIO_printf(bio_err,
 573                " -srpuserseed string - A seed string for a default user salt.\n");
 574 #endif
 575     BIO_printf(bio_err, " -ssl2         - Just talk SSLv2\n");
 576 #ifndef OPENSSL_NO_SSL3_METHOD
 577     BIO_printf(bio_err, " -ssl3         - Just talk SSLv3\n");
 578 #endif
 579     BIO_printf(bio_err, " -tls1_2       - Just talk TLSv1.2\n");
 580     BIO_printf(bio_err, " -tls1_1       - Just talk TLSv1.1\n");
 581     BIO_printf(bio_err, " -tls1         - Just talk TLSv1\n");
 582     BIO_printf(bio_err, " -dtls1        - Just talk DTLSv1\n");
 583     BIO_printf(bio_err, " -dtls1_2      - Just talk DTLSv1.2\n");
 584     BIO_printf(bio_err, " -timeout      - Enable timeouts\n");
 585     BIO_printf(bio_err, " -mtu          - Set link layer MTU\n");
 586     BIO_printf(bio_err, " -chain        - Read a certificate chain\n");
 587     BIO_printf(bio_err, " -no_ssl2      - Just disable SSLv2\n");
 588     BIO_printf(bio_err, " -no_ssl3      - Just disable SSLv3\n");
 589     BIO_printf(bio_err, " -no_tls1      - Just disable TLSv1\n");
 590     BIO_printf(bio_err, " -no_tls1_1    - Just disable TLSv1.1\n");
 591     BIO_printf(bio_err, " -no_tls1_2    - Just disable TLSv1.2\n");
 592 #ifndef OPENSSL_NO_DH
 593     BIO_printf(bio_err, " -no_dhe       - Disable ephemeral DH\n");
 594 #endif
 595 #ifndef OPENSSL_NO_ECDH
 596     BIO_printf(bio_err, " -no_ecdhe     - Disable ephemeral ECDH\n");
 597 #endif
 598     BIO_printf(bio_err, " -bugs         - Turn on SSL bug compatibility\n");
 599     BIO_printf(bio_err,
 600                " -hack         - workaround for early Netscape code\n");
 601     BIO_printf(bio_err,
 602                " -www          - Respond to a 'GET /' with a status page\n");
 603     BIO_printf(bio_err,
 604                " -WWW          - Respond to a 'GET /<path> HTTP/1.0' with file ./<path>\n");
 605     BIO_printf(bio_err,
 606                " -HTTP         - Respond to a 'GET /<path> HTTP/1.0' with file ./<path>\n");
 607     BIO_printf(bio_err,
 608                "                 with the assumption it contains a complete HTTP response.\n");
 609 #ifndef OPENSSL_NO_ENGINE
 610     BIO_printf(bio_err,
 611                " -engine id    - Initialise and use the specified engine\n");
 612 #endif
 613     BIO_printf(bio_err,
 614                " -id_prefix arg - Generate SSL/TLS session IDs prefixed by 'arg'\n");
 615     BIO_printf(bio_err, " -rand file%cfile%c...\n", LIST_SEPARATOR_CHAR,
 616                LIST_SEPARATOR_CHAR);
 617 #ifndef OPENSSL_NO_TLSEXT
 618     BIO_printf(bio_err,
 619                " -servername host - servername for HostName TLS extension\n");
 620     BIO_printf(bio_err,
 621                " -servername_fatal - on mismatch send fatal alert (default warning alert)\n");
 622     BIO_printf(bio_err,
 623                " -cert2 arg    - certificate file to use for servername\n");
 624     BIO_printf(bio_err, "                 (default is %s)\n", TEST_CERT2);
 625     BIO_printf(bio_err,
 626                " -key2 arg     - Private Key file to use for servername, in cert file if\n");
 627     BIO_printf(bio_err, "                 not specified (default is %s)\n",
 628                TEST_CERT2);
 629     BIO_printf(bio_err,
 630                " -tlsextdebug  - hex dump of all TLS extensions received\n");
 631     BIO_printf(bio_err,
 632                " -no_ticket    - disable use of RFC4507bis session tickets\n");
 633     BIO_printf(bio_err,
 634                " -legacy_renegotiation - enable use of legacy renegotiation (dangerous)\n");
 635 # ifndef OPENSSL_NO_NEXTPROTONEG
 636     BIO_printf(bio_err,
 637                " -nextprotoneg arg - set the advertised protocols for the NPN extension (comma-separated list)\n");
 638 # endif
 639 # ifndef OPENSSL_NO_SRTP
 640     BIO_printf(bio_err,
 641                " -use_srtp profiles - Offer SRTP key management with a colon-separated profile list\n");
 642 # endif
 643     BIO_printf(bio_err,
 644                " -alpn arg  - set the advertised protocols for the ALPN extension (comma-separated list)\n");
 645 #endif
 646     BIO_printf(bio_err,
 647                " -keymatexport label   - Export keying material using label\n");
 648     BIO_printf(bio_err,
 649                " -keymatexportlen len  - Export len bytes of keying material (default 20)\n");
 650     BIO_printf(bio_err,
 651                " -status           - respond to certificate status requests\n");
 652     BIO_printf(bio_err,
 653                " -status_verbose   - enable status request verbose printout\n");
 654     BIO_printf(bio_err,
 655                " -status_timeout n - status request responder timeout\n");
 656     BIO_printf(bio_err, " -status_url URL   - status request fallback URL\n");
 657 }
 658
 659 static int local_argc = 0;
 660 static char **local_argv;
 661
 662 #ifdef CHARSET_EBCDIC
 663 static int ebcdic_new(BIO *bi);
 664 static int ebcdic_free(BIO *a);
 665 static int ebcdic_read(BIO *b, char *out, int outl);
 666 static int ebcdic_write(BIO *b, const char *in, int inl);
 667 static long ebcdic_ctrl(BIO *b, int cmd, long num, void *ptr);
 668 static int ebcdic_gets(BIO *bp, char *buf, int size);
 669 static int ebcdic_puts(BIO *bp, const char *str);
 670
 671 # define BIO_TYPE_EBCDIC_FILTER  (18|0x0200)
 672 static BIO_METHOD methods_ebcdic = {
 673     BIO_TYPE_EBCDIC_FILTER,
 674     "EBCDIC/ASCII filter",
 675     ebcdic_write,
 676     ebcdic_read,
 677     ebcdic_puts,
 678     ebcdic_gets,
 679     ebcdic_ctrl,
 680     ebcdic_new,
 681     ebcdic_free,
 682 };
 683
 684 typedef struct {
 685     size_t alloced;
 686     char buff[1];
 687 } EBCDIC_OUTBUFF;
 688
 689 BIO_METHOD *BIO_f_ebcdic_filter()
 690 {
 691     return (&methods_ebcdic);
 692 }
 693
 694 static int ebcdic_new(BIO *bi)
 695 {
 696     EBCDIC_OUTBUFF *wbuf;
 697
 698     wbuf = (EBCDIC_OUTBUFF *) OPENSSL_malloc(sizeof(EBCDIC_OUTBUFF) + 1024);
 699     wbuf->alloced = 1024;
 700     wbuf->buff[0] = '\0';
 701
 702     bi->ptr = (char *)wbuf;
 703     bi->init = 1;
 704     bi->flags = 0;
 705     return (1);
 706 }
 707
 708 static int ebcdic_free(BIO *a)
 709 {
 710     if (a == NULL)
 711         return (0);
 712     if (a->ptr != NULL)
 713         OPENSSL_free(a->ptr);
 714     a->ptr = NULL;
 715     a->init = 0;
 716     a->flags = 0;
 717     return (1);
 718 }
 719
 720 static int ebcdic_read(BIO *b, char *out, int outl)
 721 {
 722     int ret = 0;
 723
 724     if (out == NULL || outl == 0)
 725         return (0);
 726     if (b->next_bio == NULL)
 727         return (0);
 728
 729     ret = BIO_read(b->next_bio, out, outl);
 730     if (ret > 0)
 731         ascii2ebcdic(out, out, ret);
 732     return (ret);
 733 }
 734
 735 static int ebcdic_write(BIO *b, const char *in, int inl)
 736 {
 737     EBCDIC_OUTBUFF *wbuf;
 738     int ret = 0;
 739     int num;
 740     unsigned char n;
 741
 742     if ((in == NULL) || (inl <= 0))
 743         return (0);
 744     if (b->next_bio == NULL)
 745         return (0);
 746
 747     wbuf = (EBCDIC_OUTBUFF *) b->ptr;
 748
 749     if (inl > (num = wbuf->alloced)) {
 750         num = num + num;        /* double the size */
 751         if (num < inl)
 752             num = inl;
 753         OPENSSL_free(wbuf);
 754         wbuf =
 755             (EBCDIC_OUTBUFF *) OPENSSL_malloc(sizeof(EBCDIC_OUTBUFF) + num);
 756
 757         wbuf->alloced = num;
 758         wbuf->buff[0] = '\0';
 759
 760         b->ptr = (char *)wbuf;
 761     }
 762
 763     ebcdic2ascii(wbuf->buff, in, inl);
 764
 765     ret = BIO_write(b->next_bio, wbuf->buff, inl);
 766
 767     return (ret);
 768 }
 769
 770 static long ebcdic_ctrl(BIO *b, int cmd, long num, void *ptr)
 771 {
 772     long ret;
 773
 774     if (b->next_bio == NULL)
 775         return (0);
 776     switch (cmd) {
 777     case BIO_CTRL_DUP:
 778         ret = 0L;
 779         break;
 780     default:
 781         ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
 782         break;
 783     }
 784     return (ret);
 785 }
 786
 787 static int ebcdic_gets(BIO *bp, char *buf, int size)
 788 {
 789     int i, ret = 0;
 790     if (bp->next_bio == NULL)
 791         return (0);
 792 /*      return(BIO_gets(bp->next_bio,buf,size));*/
 793     for (i = 0; i < size - 1; ++i) {
 794         ret = ebcdic_read(bp, &buf[i], 1);
 795         if (ret <= 0)
 796             break;
 797         else if (buf[i] == '\n') {
 798             ++i;
 799             break;
 800         }
 801     }
 802     if (i < size)
 803         buf[i] = '\0';
 804     return (ret < 0 && i == 0) ? ret : i;
 805 }
 806
 807 static int ebcdic_puts(BIO *bp, const char *str)
 808 {
 809     if (bp->next_bio == NULL)
 810         return (0);
 811     return ebcdic_write(bp, str, strlen(str));
 812 }
 813 #endif
 814
 815 #ifndef OPENSSL_NO_TLSEXT
 816
 817 /* This is a context that we pass to callbacks */
 818 typedef struct tlsextctx_st {
 819     char *servername;
 820     BIO *biodebug;
 821     int extension_error;
 822 } tlsextctx;
 823
 824 static int MS_CALLBACK ssl_servername_cb(SSL *s, int *ad, void *arg)
 825 {
 826     tlsextctx *p = (tlsextctx *) arg;
 827     const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
 828     if (servername && p->biodebug)
 829         BIO_printf(p->biodebug, "Hostname in TLS extension: \"%s\"\n",
 830                    servername);
 831
 832     if (!p->servername)
 833         return SSL_TLSEXT_ERR_NOACK;
 834
 835     if (servername) {
 836         if (strcasecmp(servername, p->servername))
 837             return p->extension_error;
 838         if (ctx2) {
 839             BIO_printf(p->biodebug, "Switching server context.\n");
 840             SSL_set_SSL_CTX(s, ctx2);
 841         }
 842     }
 843     return SSL_TLSEXT_ERR_OK;
 844 }
 845
 846 /* Structure passed to cert status callback */
 847
 848 typedef struct tlsextstatusctx_st {
 849     /* Default responder to use */
 850     char *host, *path, *port;
 851     int use_ssl;
 852     int timeout;
 853     BIO *err;
 854     int verbose;
 855 } tlsextstatusctx;
 856
 857 static tlsextstatusctx tlscstatp = { NULL, NULL, NULL, 0, -1, NULL, 0 };
 858
 859 /*
 860  * Certificate Status callback. This is called when a client includes a
 861  * certificate status request extension. This is a simplified version. It
 862  * examines certificates each time and makes one OCSP responder query for
 863  * each request. A full version would store details such as the OCSP
 864  * certificate IDs and minimise the number of OCSP responses by caching them
 865  * until they were considered "expired".
 866  */
 867
 868 static int cert_status_cb(SSL *s, void *arg)
 869 {
 870     tlsextstatusctx *srctx = arg;
 871     BIO *err = srctx->err;
 872     char *host, *port, *path;
 873     int use_ssl;
 874     unsigned char *rspder = NULL;
 875     int rspderlen;
 876     STACK_OF(OPENSSL_STRING) *aia = NULL;
 877     X509 *x = NULL;
 878     X509_STORE_CTX inctx;
 879     X509_OBJECT obj;
 880     OCSP_REQUEST *req = NULL;
 881     OCSP_RESPONSE *resp = NULL;
 882     OCSP_CERTID *id = NULL;
 883     STACK_OF(X509_EXTENSION) *exts;
 884     int ret = SSL_TLSEXT_ERR_NOACK;
 885     int i;
 886 # if 0
 887     STACK_OF(OCSP_RESPID) *ids;
 888     SSL_get_tlsext_status_ids(s, &ids);
 889     BIO_printf(err, "cert_status: received %d ids\n",
 890                sk_OCSP_RESPID_num(ids));
 891 # endif
 892     if (srctx->verbose)
 893         BIO_puts(err, "cert_status: callback called\n");
 894     /* Build up OCSP query from server certificate */
 895     x = SSL_get_certificate(s);
 896     aia = X509_get1_ocsp(x);
 897     if (aia) {
 898         if (!OCSP_parse_url(sk_OPENSSL_STRING_value(aia, 0),
 899                             &host, &port, &path, &use_ssl)) {
 900             BIO_puts(err, "cert_status: can't parse AIA URL\n");
 901             goto err;
 902         }
 903         if (srctx->verbose)
 904             BIO_printf(err, "cert_status: AIA URL: %s\n",
 905                        sk_OPENSSL_STRING_value(aia, 0));
 906     } else {
 907         if (!srctx->host) {
 908             BIO_puts(srctx->err,
 909                      "cert_status: no AIA and no default responder URL\n");
 910             goto done;
 911         }
 912         host = srctx->host;
 913         path = srctx->path;
 914         port = srctx->port;
 915         use_ssl = srctx->use_ssl;
 916     }
 917
 918     if (!X509_STORE_CTX_init(&inctx,
 919                              SSL_CTX_get_cert_store(SSL_get_SSL_CTX(s)),
 920                              NULL, NULL))
 921         goto err;
 922     if (X509_STORE_get_by_subject(&inctx, X509_LU_X509,
 923                                   X509_get_issuer_name(x), &obj) <= 0) {
 924         BIO_puts(err, "cert_status: Can't retrieve issuer certificate.\n");
 925         X509_STORE_CTX_cleanup(&inctx);
 926         goto done;
 927     }
 928     req = OCSP_REQUEST_new();
 929     if (!req)
 930         goto err;
 931     id = OCSP_cert_to_id(NULL, x, obj.data.x509);
 932     X509_free(obj.data.x509);
 933     X509_STORE_CTX_cleanup(&inctx);
 934     if (!id)
 935         goto err;
 936     if (!OCSP_request_add0_id(req, id))
 937         goto err;
 938     id = NULL;
 939     /* Add any extensions to the request */
 940     SSL_get_tlsext_status_exts(s, &exts);
 941     for (i = 0; i < sk_X509_EXTENSION_num(exts); i++) {
 942         X509_EXTENSION *ext = sk_X509_EXTENSION_value(exts, i);
 943         if (!OCSP_REQUEST_add_ext(req, ext, -1))
 944             goto err;
 945     }
 946     resp = process_responder(err, req, host, path, port, use_ssl, NULL,
 947                              srctx->timeout);
 948     if (!resp) {
 949         BIO_puts(err, "cert_status: error querying responder\n");
 950         goto done;
 951     }
 952     rspderlen = i2d_OCSP_RESPONSE(resp, &rspder);
 953     if (rspderlen <= 0)
 954         goto err;
 955     SSL_set_tlsext_status_ocsp_resp(s, rspder, rspderlen);
 956     if (srctx->verbose) {
 957         BIO_puts(err, "cert_status: ocsp response sent:\n");
 958         OCSP_RESPONSE_print(err, resp, 2);
 959     }
 960     ret = SSL_TLSEXT_ERR_OK;
 961  done:
 962     if (ret != SSL_TLSEXT_ERR_OK)
 963         ERR_print_errors(err);
 964     if (aia) {
 965         OPENSSL_free(host);
 966         OPENSSL_free(path);
 967         OPENSSL_free(port);
 968         X509_email_free(aia);
 969     }
 970     if (id)
 971         OCSP_CERTID_free(id);
 972     if (req)
 973         OCSP_REQUEST_free(req);
 974     if (resp)
 975         OCSP_RESPONSE_free(resp);
 976     return ret;
 977  err:
 978     ret = SSL_TLSEXT_ERR_ALERT_FATAL;
 979     goto done;
 980 }
 981
 982 # ifndef OPENSSL_NO_NEXTPROTONEG
 983 /* This is the context that we pass to next_proto_cb */
 984 typedef struct tlsextnextprotoctx_st {
 985     unsigned char *data;
 986     unsigned int len;
 987 } tlsextnextprotoctx;
 988
 989 static int next_proto_cb(SSL *s, const unsigned char **data,
 990                          unsigned int *len, void *arg)
 991 {
 992     tlsextnextprotoctx *next_proto = arg;
 993
 994     *data = next_proto->data;
 995     *len = next_proto->len;
 996
 997     return SSL_TLSEXT_ERR_OK;
 998 }
 999 # endif                         /* ndef OPENSSL_NO_NEXTPROTONEG */
1000
1001 /* This the context that we pass to alpn_cb */
1002 typedef struct tlsextalpnctx_st {
1003     unsigned char *data;
1004     unsigned short len;
1005 } tlsextalpnctx;
1006
1007 static int alpn_cb(SSL *s, const unsigned char **out, unsigned char *outlen,
1008                    const unsigned char *in, unsigned int inlen, void *arg)
1009 {
1010     tlsextalpnctx *alpn_ctx = arg;
1011
1012     if (!s_quiet) {
1013         /* We can assume that |in| is syntactically valid. */
1014         unsigned i;
1015         BIO_printf(bio_s_out, "ALPN protocols advertised by the client: ");
1016         for (i = 0; i < inlen;) {
1017             if (i)
1018                 BIO_write(bio_s_out, ", ", 2);
1019             BIO_write(bio_s_out, &in[i + 1], in[i]);
1020             i += in[i] + 1;
1021         }
1022         BIO_write(bio_s_out, "\n", 1);
1023     }
1024
1025     if (SSL_select_next_proto
1026         ((unsigned char **)out, outlen, alpn_ctx->data, alpn_ctx->len, in,
1027          inlen) != OPENSSL_NPN_NEGOTIATED) {
1028         return SSL_TLSEXT_ERR_NOACK;
1029     }
1030
1031     if (!s_quiet) {
1032         BIO_printf(bio_s_out, "ALPN protocols selected: ");
1033         BIO_write(bio_s_out, *out, *outlen);
1034         BIO_write(bio_s_out, "\n", 1);
1035     }
1036
1037     return SSL_TLSEXT_ERR_OK;
1038 }
1039 #endif                          /* ndef OPENSSL_NO_TLSEXT */
1040
1041 int MAIN(int, char **);
1042
1043 #ifndef OPENSSL_NO_JPAKE
1044 static char *jpake_secret = NULL;
1045 # define no_jpake !jpake_secret
1046 #else
1047 # define no_jpake 1
1048 #endif
1049 #ifndef OPENSSL_NO_SRP
1050 static srpsrvparm srp_callback_parm;
1051 #endif
1052 #ifndef OPENSSL_NO_SRTP
1053 static char *srtp_profiles = NULL;
1054 #endif
1055
1056 int MAIN(int argc, char *argv[])
1057 {
1058     X509_VERIFY_PARAM *vpm = NULL;
1059     int badarg = 0;
1060     short port = PORT;
1061     char *CApath = NULL, *CAfile = NULL;
1062     char *chCApath = NULL, *chCAfile = NULL;
1063     char *vfyCApath = NULL, *vfyCAfile = NULL;
1064     unsigned char *context = NULL;
1065     char *dhfile = NULL;
1066     int badop = 0;
1067     int ret = 1;
1068     int build_chain = 0;
1069     int no_tmp_rsa = 0, no_dhe = 0, no_ecdhe = 0, nocert = 0;
1070     int state = 0;
1071     const SSL_METHOD *meth = NULL;
1072     int socket_type = SOCK_STREAM;
1073     ENGINE *e = NULL;
1074     char *inrand = NULL;
1075     int s_cert_format = FORMAT_PEM, s_key_format = FORMAT_PEM;
1076     char *passarg = NULL, *pass = NULL;
1077     char *dpassarg = NULL, *dpass = NULL;
1078     int s_dcert_format = FORMAT_PEM, s_dkey_format = FORMAT_PEM;
1079     X509 *s_cert = NULL, *s_dcert = NULL;
1080     STACK_OF(X509) *s_chain = NULL, *s_dchain = NULL;
1081     EVP_PKEY *s_key = NULL, *s_dkey = NULL;
1082     int no_cache = 0, ext_cache = 0;
1083     int rev = 0, naccept = -1;
1084 #ifndef OPENSSL_NO_TLSEXT
1085     EVP_PKEY *s_key2 = NULL;
1086     X509 *s_cert2 = NULL;
1087     tlsextctx tlsextcbp = { NULL, NULL, SSL_TLSEXT_ERR_ALERT_WARNING };
1088 # ifndef OPENSSL_NO_NEXTPROTONEG
1089     const char *next_proto_neg_in = NULL;
1090     tlsextnextprotoctx next_proto = { NULL, 0 };
1091 # endif
1092     const char *alpn_in = NULL;
1093     tlsextalpnctx alpn_ctx = { NULL, 0 };
1094 #endif
1095 #ifndef OPENSSL_NO_PSK
1096     /* by default do not send a PSK identity hint */
1097     static char *psk_identity_hint = NULL;
1098 #endif
1099 #ifndef OPENSSL_NO_SRP
1100     char *srpuserseed = NULL;
1101     char *srp_verifier_file = NULL;
1102 #endif
1103     SSL_EXCERT *exc = NULL;
1104     SSL_CONF_CTX *cctx = NULL;
1105     STACK_OF(OPENSSL_STRING) *ssl_args = NULL;
1106
1107     char *crl_file = NULL;
1108     int crl_format = FORMAT_PEM;
1109     int crl_download = 0;
1110     STACK_OF(X509_CRL) *crls = NULL;
1111
1112     meth = SSLv23_server_method();
1113
1114     local_argc = argc;
1115     local_argv = argv;
1116
1117     apps_startup();
1118 #ifdef MONOLITH
1119     s_server_init();
1120 #endif
1121
1122     if (bio_err == NULL)
1123         bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);
1124
1125     if (!load_config(bio_err, NULL))
1126         goto end;
1127
1128     cctx = SSL_CONF_CTX_new();
1129     if (!cctx)
1130         goto end;
1131     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_SERVER);
1132     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CMDLINE);
1133
1134     verify_depth = 0;
1135 #ifdef FIONBIO
1136     s_nbio = 0;
1137 #endif
1138     s_nbio_test = 0;
1139
1140     argc--;
1141     argv++;
1142
1143     while (argc >= 1) {
1144         if ((strcmp(*argv, "-port") == 0) || (strcmp(*argv, "-accept") == 0)) {
1145             if (--argc < 1)
1146                 goto bad;
1147             if (!extract_port(*(++argv), &port))
1148                 goto bad;
1149         } else if (strcmp(*argv, "-naccept") == 0) {
1150             if (--argc < 1)
1151                 goto bad;
1152             naccept = atol(*(++argv));
1153             if (naccept <= 0) {
1154                 BIO_printf(bio_err, "bad accept value %s\n", *argv);
1155                 goto bad;
1156             }
1157         } else if (strcmp(*argv, "-verify") == 0) {
1158             s_server_verify = SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE;
1159             if (--argc < 1)
1160                 goto bad;
1161             verify_depth = atoi(*(++argv));
1162             if (!s_quiet)
1163                 BIO_printf(bio_err, "verify depth is %d\n", verify_depth);
1164         } else if (strcmp(*argv, "-Verify") == 0) {
1165             s_server_verify =
1166                 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT |
1167                 SSL_VERIFY_CLIENT_ONCE;
1168             if (--argc < 1)
1169                 goto bad;
1170             verify_depth = atoi(*(++argv));
1171             if (!s_quiet)
1172                 BIO_printf(bio_err,
1173                            "verify depth is %d, must return a certificate\n",
1174                            verify_depth);
1175         } else if (strcmp(*argv, "-context") == 0) {
1176             if (--argc < 1)
1177                 goto bad;
1178             context = (unsigned char *)*(++argv);
1179         } else if (strcmp(*argv, "-cert") == 0) {
1180             if (--argc < 1)
1181                 goto bad;
1182             s_cert_file = *(++argv);
1183         } else if (strcmp(*argv, "-CRL") == 0) {
1184             if (--argc < 1)
1185                 goto bad;
1186             crl_file = *(++argv);
1187         } else if (strcmp(*argv, "-crl_download") == 0)
1188             crl_download = 1;
1189 #ifndef OPENSSL_NO_TLSEXT
1190         else if (strcmp(*argv, "-serverinfo") == 0) {
1191             if (--argc < 1)
1192                 goto bad;
1193             s_serverinfo_file = *(++argv);
1194         }
1195 #endif
1196         else if (strcmp(*argv, "-certform") == 0) {
1197             if (--argc < 1)
1198                 goto bad;
1199             s_cert_format = str2fmt(*(++argv));
1200         } else if (strcmp(*argv, "-key") == 0) {
1201             if (--argc < 1)
1202                 goto bad;
1203             s_key_file = *(++argv);
1204         } else if (strcmp(*argv, "-keyform") == 0) {
1205             if (--argc < 1)
1206                 goto bad;
1207             s_key_format = str2fmt(*(++argv));
1208         } else if (strcmp(*argv, "-pass") == 0) {
1209             if (--argc < 1)
1210                 goto bad;
1211             passarg = *(++argv);
1212         } else if (strcmp(*argv, "-cert_chain") == 0) {
1213             if (--argc < 1)
1214                 goto bad;
1215             s_chain_file = *(++argv);
1216         } else if (strcmp(*argv, "-dhparam") == 0) {
1217             if (--argc < 1)
1218                 goto bad;
1219             dhfile = *(++argv);
1220         } else if (strcmp(*argv, "-dcertform") == 0) {
1221             if (--argc < 1)
1222                 goto bad;
1223             s_dcert_format = str2fmt(*(++argv));
1224         } else if (strcmp(*argv, "-dcert") == 0) {
1225             if (--argc < 1)
1226                 goto bad;
1227             s_dcert_file = *(++argv);
1228         } else if (strcmp(*argv, "-dkeyform") == 0) {
1229             if (--argc < 1)
1230                 goto bad;
1231             s_dkey_format = str2fmt(*(++argv));
1232         } else if (strcmp(*argv, "-dpass") == 0) {
1233             if (--argc < 1)
1234                 goto bad;
1235             dpassarg = *(++argv);
1236         } else if (strcmp(*argv, "-dkey") == 0) {
1237             if (--argc < 1)
1238                 goto bad;
1239             s_dkey_file = *(++argv);
1240         } else if (strcmp(*argv, "-dcert_chain") == 0) {
1241             if (--argc < 1)
1242                 goto bad;
1243             s_dchain_file = *(++argv);
1244         } else if (strcmp(*argv, "-nocert") == 0) {
1245             nocert = 1;
1246         } else if (strcmp(*argv, "-CApath") == 0) {
1247             if (--argc < 1)
1248                 goto bad;
1249             CApath = *(++argv);
1250         } else if (strcmp(*argv, "-chainCApath") == 0) {
1251             if (--argc < 1)
1252                 goto bad;
1253             chCApath = *(++argv);
1254         } else if (strcmp(*argv, "-verifyCApath") == 0) {
1255             if (--argc < 1)
1256                 goto bad;
1257             vfyCApath = *(++argv);
1258         } else if (strcmp(*argv, "-no_cache") == 0)
1259             no_cache = 1;
1260         else if (strcmp(*argv, "-ext_cache") == 0)
1261             ext_cache = 1;
1262         else if (strcmp(*argv, "-CRLform") == 0) {
1263             if (--argc < 1)
1264                 goto bad;
1265             crl_format = str2fmt(*(++argv));
1266         } else if (args_verify(&argv, &argc, &badarg, bio_err, &vpm)) {
1267             if (badarg)
1268                 goto bad;
1269             continue;
1270         } else if (args_excert(&argv, &argc, &badarg, bio_err, &exc)) {
1271             if (badarg)
1272                 goto bad;
1273             continue;
1274         } else if (args_ssl(&argv, &argc, cctx, &badarg, bio_err, &ssl_args)) {
1275             if (badarg)
1276                 goto bad;
1277             continue;
1278         } else if (strcmp(*argv, "-verify_return_error") == 0)
1279             verify_return_error = 1;
1280         else if (strcmp(*argv, "-verify_quiet") == 0)
1281             verify_quiet = 1;
1282         else if (strcmp(*argv, "-build_chain") == 0)
1283             build_chain = 1;
1284         else if (strcmp(*argv, "-CAfile") == 0) {
1285             if (--argc < 1)
1286                 goto bad;
1287             CAfile = *(++argv);
1288         } else if (strcmp(*argv, "-chainCAfile") == 0) {
1289             if (--argc < 1)
1290                 goto bad;
1291             chCAfile = *(++argv);
1292         } else if (strcmp(*argv, "-verifyCAfile") == 0) {
1293             if (--argc < 1)
1294                 goto bad;
1295             vfyCAfile = *(++argv);
1296         }
1297 #ifdef FIONBIO
1298         else if (strcmp(*argv, "-nbio") == 0) {
1299             s_nbio = 1;
1300         }
1301 #endif
1302         else if (strcmp(*argv, "-nbio_test") == 0) {
1303 #ifdef FIONBIO
1304             s_nbio = 1;
1305 #endif
1306             s_nbio_test = 1;
1307         } else if (strcmp(*argv, "-ign_eof") == 0)
1308             s_ign_eof = 1;
1309         else if (strcmp(*argv, "-no_ign_eof") == 0)
1310             s_ign_eof = 0;
1311         else if (strcmp(*argv, "-debug") == 0) {
1312             s_debug = 1;
1313         }
1314 #ifndef OPENSSL_NO_TLSEXT
1315         else if (strcmp(*argv, "-tlsextdebug") == 0)
1316             s_tlsextdebug = 1;
1317         else if (strcmp(*argv, "-status") == 0)
1318             s_tlsextstatus = 1;
1319         else if (strcmp(*argv, "-status_verbose") == 0) {
1320             s_tlsextstatus = 1;
1321             tlscstatp.verbose = 1;
1322         } else if (!strcmp(*argv, "-status_timeout")) {
1323             s_tlsextstatus = 1;
1324             if (--argc < 1)
1325                 goto bad;
1326             tlscstatp.timeout = atoi(*(++argv));
1327         } else if (!strcmp(*argv, "-status_url")) {
1328             s_tlsextstatus = 1;
1329             if (--argc < 1)
1330                 goto bad;
1331             if (!OCSP_parse_url(*(++argv),
1332                                 &tlscstatp.host,
1333                                 &tlscstatp.port,
1334                                 &tlscstatp.path, &tlscstatp.use_ssl)) {
1335                 BIO_printf(bio_err, "Error parsing URL\n");
1336                 goto bad;
1337             }
1338         }
1339 #endif
1340         else if (strcmp(*argv, "-msg") == 0) {
1341             s_msg = 1;
1342         } else if (strcmp(*argv, "-msgfile") == 0) {
1343             if (--argc < 1)
1344                 goto bad;
1345             bio_s_msg = BIO_new_file(*(++argv), "w");
1346         }
1347 #ifndef OPENSSL_NO_SSL_TRACE
1348         else if (strcmp(*argv, "-trace") == 0) {
1349             s_msg = 2;
1350         }
1351 #endif
1352         else if (strcmp(*argv, "-hack") == 0) {
1353             hack = 1;
1354         } else if (strcmp(*argv, "-state") == 0) {
1355             state = 1;
1356         } else if (strcmp(*argv, "-crlf") == 0) {
1357             s_crlf = 1;
1358         } else if (strcmp(*argv, "-quiet") == 0) {
1359             s_quiet = 1;
1360         } else if (strcmp(*argv, "-brief") == 0) {
1361             s_quiet = 1;
1362             s_brief = 1;
1363             verify_quiet = 1;
1364         } else if (strcmp(*argv, "-no_tmp_rsa") == 0) {
1365             no_tmp_rsa = 1;
1366         } else if (strcmp(*argv, "-no_dhe") == 0) {
1367             no_dhe = 1;
1368         } else if (strcmp(*argv, "-no_ecdhe") == 0) {
1369             no_ecdhe = 1;
1370         } else if (strcmp(*argv, "-no_resume_ephemeral") == 0) {
1371             no_resume_ephemeral = 1;
1372         }
1373 #ifndef OPENSSL_NO_PSK
1374         else if (strcmp(*argv, "-psk_hint") == 0) {
1375             if (--argc < 1)
1376                 goto bad;
1377             psk_identity_hint = *(++argv);
1378         } else if (strcmp(*argv, "-psk") == 0) {
1379             size_t i;
1380
1381             if (--argc < 1)
1382                 goto bad;
1383             psk_key = *(++argv);
1384             for (i = 0; i < strlen(psk_key); i++) {
1385                 if (isxdigit((unsigned char)psk_key[i]))
1386                     continue;
1387                 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
1388                 goto bad;
1389             }
1390         }
1391 #endif
1392 #ifndef OPENSSL_NO_SRP
1393         else if (strcmp(*argv, "-srpvfile") == 0) {
1394             if (--argc < 1)
1395                 goto bad;
1396             srp_verifier_file = *(++argv);
1397             meth = TLSv1_server_method();
1398         } else if (strcmp(*argv, "-srpuserseed") == 0) {
1399             if (--argc < 1)
1400                 goto bad;
1401             srpuserseed = *(++argv);
1402             meth = TLSv1_server_method();
1403         }
1404 #endif
1405         else if (strcmp(*argv, "-rev") == 0) {
1406             rev = 1;
1407         } else if (strcmp(*argv, "-www") == 0) {
1408             www = 1;
1409         } else if (strcmp(*argv, "-WWW") == 0) {
1410             www = 2;
1411         } else if (strcmp(*argv, "-HTTP") == 0) {
1412             www = 3;
1413         }
1414 #ifndef OPENSSL_NO_SSL2
1415         else if (strcmp(*argv, "-ssl2") == 0) {
1416             no_ecdhe = 1;
1417             meth = SSLv2_server_method();
1418         }
1419 #endif
1420 #ifndef OPENSSL_NO_SSL3_METHOD
1421         else if (strcmp(*argv, "-ssl3") == 0) {
1422             meth = SSLv3_server_method();
1423         }
1424 #endif
1425 #ifndef OPENSSL_NO_TLS1
1426         else if (strcmp(*argv, "-tls1") == 0) {
1427             meth = TLSv1_server_method();
1428         } else if (strcmp(*argv, "-tls1_1") == 0) {
1429             meth = TLSv1_1_server_method();
1430         } else if (strcmp(*argv, "-tls1_2") == 0) {
1431             meth = TLSv1_2_server_method();
1432         }
1433 #endif
1434 #ifndef OPENSSL_NO_DTLS1
1435         else if (strcmp(*argv, "-dtls") == 0) {
1436             meth = DTLS_server_method();
1437             socket_type = SOCK_DGRAM;
1438         } else if (strcmp(*argv, "-dtls1") == 0) {
1439             meth = DTLSv1_server_method();
1440             socket_type = SOCK_DGRAM;
1441         } else if (strcmp(*argv, "-dtls1_2") == 0) {
1442             meth = DTLSv1_2_server_method();
1443             socket_type = SOCK_DGRAM;
1444         } else if (strcmp(*argv, "-timeout") == 0)
1445             enable_timeouts = 1;
1446         else if (strcmp(*argv, "-mtu") == 0) {
1447             if (--argc < 1)
1448                 goto bad;
1449             socket_mtu = atol(*(++argv));
1450         } else if (strcmp(*argv, "-chain") == 0)
1451             cert_chain = 1;
1452 #endif
1453         else if (strcmp(*argv, "-id_prefix") == 0) {
1454             if (--argc < 1)
1455                 goto bad;
1456             session_id_prefix = *(++argv);
1457         }
1458 #ifndef OPENSSL_NO_ENGINE
1459         else if (strcmp(*argv, "-engine") == 0) {
1460             if (--argc < 1)
1461                 goto bad;
1462             engine_id = *(++argv);
1463         }
1464 #endif
1465         else if (strcmp(*argv, "-rand") == 0) {
1466             if (--argc < 1)
1467                 goto bad;
1468             inrand = *(++argv);
1469         }
1470 #ifndef OPENSSL_NO_TLSEXT
1471         else if (strcmp(*argv, "-servername") == 0) {
1472             if (--argc < 1)
1473                 goto bad;
1474             tlsextcbp.servername = *(++argv);
1475         } else if (strcmp(*argv, "-servername_fatal") == 0) {
1476             tlsextcbp.extension_error = SSL_TLSEXT_ERR_ALERT_FATAL;
1477         } else if (strcmp(*argv, "-cert2") == 0) {
1478             if (--argc < 1)
1479                 goto bad;
1480             s_cert_file2 = *(++argv);
1481         } else if (strcmp(*argv, "-key2") == 0) {
1482             if (--argc < 1)
1483                 goto bad;
1484             s_key_file2 = *(++argv);
1485         }
1486 # ifndef OPENSSL_NO_NEXTPROTONEG
1487         else if (strcmp(*argv, "-nextprotoneg") == 0) {
1488             if (--argc < 1)
1489                 goto bad;
1490             next_proto_neg_in = *(++argv);
1491         }
1492 # endif
1493         else if (strcmp(*argv, "-alpn") == 0) {
1494             if (--argc < 1)
1495                 goto bad;
1496             alpn_in = *(++argv);
1497         }
1498 #endif
1499 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
1500         else if (strcmp(*argv, "-jpake") == 0) {
1501             if (--argc < 1)
1502                 goto bad;
1503             jpake_secret = *(++argv);
1504         }
1505 #endif
1506 #ifndef OPENSSL_NO_SRTP
1507         else if (strcmp(*argv, "-use_srtp") == 0) {
1508             if (--argc < 1)
1509                 goto bad;
1510             srtp_profiles = *(++argv);
1511         }
1512 #endif
1513         else if (strcmp(*argv, "-keymatexport") == 0) {
1514             if (--argc < 1)
1515                 goto bad;
1516             keymatexportlabel = *(++argv);
1517         } else if (strcmp(*argv, "-keymatexportlen") == 0) {
1518             if (--argc < 1)
1519                 goto bad;
1520             keymatexportlen = atoi(*(++argv));
1521             if (keymatexportlen == 0)
1522                 goto bad;
1523         } else {
1524             BIO_printf(bio_err, "unknown option %s\n", *argv);
1525             badop = 1;
1526             break;
1527         }
1528         argc--;
1529         argv++;
1530     }
1531     if (badop) {
1532  bad:
1533         sv_usage();
1534         goto end;
1535     }
1536 #ifndef OPENSSL_NO_DTLS1
1537     if (www && socket_type == SOCK_DGRAM) {
1538         BIO_printf(bio_err, "Can't use -HTTP, -www or -WWW with DTLS\n");
1539         goto end;
1540     }
1541 #endif
1542
1543 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
1544     if (jpake_secret) {
1545         if (psk_key) {
1546             BIO_printf(bio_err, "Can't use JPAKE and PSK together\n");
1547             goto end;
1548         }
1549         psk_identity = "JPAKE";
1550     }
1551 #endif
1552
1553     SSL_load_error_strings();
1554     OpenSSL_add_ssl_algorithms();
1555
1556 #ifndef OPENSSL_NO_ENGINE
1557     e = setup_engine(bio_err, engine_id, 1);
1558 #endif
1559
1560     if (!app_passwd(bio_err, passarg, dpassarg, &pass, &dpass)) {
1561         BIO_printf(bio_err, "Error getting password\n");
1562         goto end;
1563     }
1564
1565     if (s_key_file == NULL)
1566         s_key_file = s_cert_file;
1567 #ifndef OPENSSL_NO_TLSEXT
1568     if (s_key_file2 == NULL)
1569         s_key_file2 = s_cert_file2;
1570 #endif
1571
1572     if (!load_excert(&exc, bio_err))
1573         goto end;
1574
1575     if (nocert == 0) {
1576         s_key = load_key(bio_err, s_key_file, s_key_format, 0, pass, e,
1577                          "server certificate private key file");
1578         if (!s_key) {
1579             ERR_print_errors(bio_err);
1580             goto end;
1581         }
1582
1583         s_cert = load_cert(bio_err, s_cert_file, s_cert_format,
1584                            NULL, e, "server certificate file");
1585
1586         if (!s_cert) {
1587             ERR_print_errors(bio_err);
1588             goto end;
1589         }
1590         if (s_chain_file) {
1591             s_chain = load_certs(bio_err, s_chain_file, FORMAT_PEM,
1592                                  NULL, e, "server certificate chain");
1593             if (!s_chain)
1594                 goto end;
1595         }
1596 #ifndef OPENSSL_NO_TLSEXT
1597         if (tlsextcbp.servername) {
1598             s_key2 = load_key(bio_err, s_key_file2, s_key_format, 0, pass, e,
1599                               "second server certificate private key file");
1600             if (!s_key2) {
1601                 ERR_print_errors(bio_err);
1602                 goto end;
1603             }
1604
1605             s_cert2 = load_cert(bio_err, s_cert_file2, s_cert_format,
1606                                 NULL, e, "second server certificate file");
1607
1608             if (!s_cert2) {
1609                 ERR_print_errors(bio_err);
1610                 goto end;
1611             }
1612         }
1613 #endif                          /* OPENSSL_NO_TLSEXT */
1614     }
1615 #if !defined(OPENSSL_NO_TLSEXT)
1616 # if !defined(OPENSSL_NO_NEXTPROTONEG)
1617     if (next_proto_neg_in) {
1618         unsigned short len;
1619         next_proto.data = next_protos_parse(&len, next_proto_neg_in);
1620         if (next_proto.data == NULL)
1621             goto end;
1622         next_proto.len = len;
1623     } else {
1624         next_proto.data = NULL;
1625     }
1626 # endif
1627     alpn_ctx.data = NULL;
1628     if (alpn_in) {
1629         unsigned short len;
1630         alpn_ctx.data = next_protos_parse(&len, alpn_in);
1631         if (alpn_ctx.data == NULL)
1632             goto end;
1633         alpn_ctx.len = len;
1634     }
1635 #endif
1636
1637     if (crl_file) {
1638         X509_CRL *crl;
1639         crl = load_crl(crl_file, crl_format);
1640         if (!crl) {
1641             BIO_puts(bio_err, "Error loading CRL\n");
1642             ERR_print_errors(bio_err);
1643             goto end;
1644         }
1645         crls = sk_X509_CRL_new_null();
1646         if (!crls || !sk_X509_CRL_push(crls, crl)) {
1647             BIO_puts(bio_err, "Error adding CRL\n");
1648             ERR_print_errors(bio_err);
1649             X509_CRL_free(crl);
1650             goto end;
1651         }
1652     }
1653
1654     if (s_dcert_file) {
1655
1656         if (s_dkey_file == NULL)
1657             s_dkey_file = s_dcert_file;
1658
1659         s_dkey = load_key(bio_err, s_dkey_file, s_dkey_format,
1660                           0, dpass, e, "second certificate private key file");
1661         if (!s_dkey) {
1662             ERR_print_errors(bio_err);
1663             goto end;
1664         }
1665
1666         s_dcert = load_cert(bio_err, s_dcert_file, s_dcert_format,
1667                             NULL, e, "second server certificate file");
1668
1669         if (!s_dcert) {
1670             ERR_print_errors(bio_err);
1671             goto end;
1672         }
1673         if (s_dchain_file) {
1674             s_dchain = load_certs(bio_err, s_dchain_file, FORMAT_PEM,
1675                                   NULL, e, "second server certificate chain");
1676             if (!s_dchain)
1677                 goto end;
1678         }
1679
1680     }
1681
1682     if (!app_RAND_load_file(NULL, bio_err, 1) && inrand == NULL
1683         && !RAND_status()) {
1684         BIO_printf(bio_err,
1685                    "warning, not much extra random data, consider using the -rand option\n");
1686     }
1687     if (inrand != NULL)
1688         BIO_printf(bio_err, "%ld semi-random bytes loaded\n",
1689                    app_RAND_load_files(inrand));
1690
1691     if (bio_s_out == NULL) {
1692         if (s_quiet && !s_debug) {
1693             bio_s_out = BIO_new(BIO_s_null());
1694             if (s_msg && !bio_s_msg)
1695                 bio_s_msg = BIO_new_fp(stdout, BIO_NOCLOSE);
1696         } else {
1697             if (bio_s_out == NULL)
1698                 bio_s_out = BIO_new_fp(stdout, BIO_NOCLOSE);
1699         }
1700     }
1701 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_ECDSA)
1702     if (nocert)
1703 #endif
1704     {
1705         s_cert_file = NULL;
1706         s_key_file = NULL;
1707         s_dcert_file = NULL;
1708         s_dkey_file = NULL;
1709 #ifndef OPENSSL_NO_TLSEXT
1710         s_cert_file2 = NULL;
1711         s_key_file2 = NULL;
1712 #endif
1713     }
1714
1715     ctx = SSL_CTX_new(meth);
1716     if (ctx == NULL) {
1717         ERR_print_errors(bio_err);
1718         goto end;
1719     }
1720     if (session_id_prefix) {
1721         if (strlen(session_id_prefix) >= 32)
1722             BIO_printf(bio_err,
1723                        "warning: id_prefix is too long, only one new session will be possible\n");
1724         else if (strlen(session_id_prefix) >= 16)
1725             BIO_printf(bio_err,
1726                        "warning: id_prefix is too long if you use SSLv2\n");
1727         if (!SSL_CTX_set_generate_session_id(ctx, generate_session_id)) {
1728             BIO_printf(bio_err, "error setting 'id_prefix'\n");
1729             ERR_print_errors(bio_err);
1730             goto end;
1731         }
1732         BIO_printf(bio_err, "id_prefix '%s' set.\n", session_id_prefix);
1733     }
1734     SSL_CTX_set_quiet_shutdown(ctx, 1);
1735     if (hack)
1736         SSL_CTX_set_options(ctx, SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG);
1737     if (exc)
1738         ssl_ctx_set_excert(ctx, exc);
1739     /*
1740      * DTLS: partial reads end up discarding unread UDP bytes :-( Setting
1741      * read ahead solves this problem.
1742      */
1743     if (socket_type == SOCK_DGRAM)
1744         SSL_CTX_set_read_ahead(ctx, 1);
1745
1746     if (state)
1747         SSL_CTX_set_info_callback(ctx, apps_ssl_info_callback);
1748     if (no_cache)
1749         SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
1750     else if (ext_cache)
1751         init_session_cache_ctx(ctx);
1752     else
1753         SSL_CTX_sess_set_cache_size(ctx, 128);
1754
1755 #ifndef OPENSSL_NO_SRTP
1756     if (srtp_profiles != NULL)
1757         SSL_CTX_set_tlsext_use_srtp(ctx, srtp_profiles);
1758 #endif
1759
1760 #if 0
1761     if (cipher == NULL)
1762         cipher = getenv("SSL_CIPHER");
1763 #endif
1764
1765 #if 0
1766     if (s_cert_file == NULL) {
1767         BIO_printf(bio_err,
1768                    "You must specify a certificate file for the server to use\n");
1769         goto end;
1770     }
1771 #endif
1772
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);
1777         /* goto end; */
1778     }
1779     if (vpm)
1780         SSL_CTX_set1_param(ctx, vpm);
1781
1782     ssl_ctx_add_crls(ctx, crls, 0);
1783
1784     if (!args_ssl_call(ctx, bio_err, cctx, ssl_args, no_ecdhe, no_jpake))
1785         goto end;
1786
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);
1791         goto end;
1792     }
1793 #ifndef OPENSSL_NO_TLSEXT
1794     if (s_cert2) {
1795         ctx2 = SSL_CTX_new(meth);
1796         if (ctx2 == NULL) {
1797             ERR_print_errors(bio_err);
1798             goto end;
1799         }
1800     }
1801
1802     if (ctx2) {
1803         BIO_printf(bio_s_out, "Setting secondary ctx parameters\n");
1804
1805         if (session_id_prefix) {
1806             if (strlen(session_id_prefix) >= 32)
1807                 BIO_printf(bio_err,
1808                            "warning: id_prefix is too long, only one new session will be possible\n");
1809             else if (strlen(session_id_prefix) >= 16)
1810                 BIO_printf(bio_err,
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);
1815                 goto end;
1816             }
1817             BIO_printf(bio_err, "id_prefix '%s' set.\n", session_id_prefix);
1818         }
1819         SSL_CTX_set_quiet_shutdown(ctx2, 1);
1820         if (hack)
1821             SSL_CTX_set_options(ctx2, SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG);
1822         if (exc)
1823             ssl_ctx_set_excert(ctx2, exc);
1824         /*
1825          * DTLS: partial reads end up discarding unread UDP bytes :-(
1826          * Setting read ahead solves this problem.
1827          */
1828         if (socket_type == SOCK_DGRAM)
1829             SSL_CTX_set_read_ahead(ctx2, 1);
1830
1831         if (state)
1832             SSL_CTX_set_info_callback(ctx2, apps_ssl_info_callback);
1833
1834         if (no_cache)
1835             SSL_CTX_set_session_cache_mode(ctx2, SSL_SESS_CACHE_OFF);
1836         else if (ext_cache)
1837             init_session_cache_ctx(ctx2);
1838         else
1839             SSL_CTX_sess_set_cache_size(ctx2, 128);
1840
1841         if ((!SSL_CTX_load_verify_locations(ctx2, CAfile, CApath)) ||
1842             (!SSL_CTX_set_default_verify_paths(ctx2))) {
1843             ERR_print_errors(bio_err);
1844         }
1845         if (vpm)
1846             SSL_CTX_set1_param(ctx2, vpm);
1847
1848         ssl_ctx_add_crls(ctx2, crls, 0);
1849
1850         if (!args_ssl_call(ctx2, bio_err, cctx, ssl_args, no_ecdhe, no_jpake))
1851             goto end;
1852
1853     }
1854 # ifndef OPENSSL_NO_NEXTPROTONEG
1855     if (next_proto.data)
1856         SSL_CTX_set_next_protos_advertised_cb(ctx, next_proto_cb,
1857                                               &next_proto);
1858 # endif
1859     if (alpn_ctx.data)
1860         SSL_CTX_set_alpn_select_cb(ctx, alpn_cb, &alpn_ctx);
1861 #endif
1862
1863 #ifndef OPENSSL_NO_DH
1864     if (!no_dhe) {
1865         DH *dh = NULL;
1866
1867         if (dhfile)
1868             dh = load_dh_param(dhfile);
1869         else if (s_cert_file)
1870             dh = load_dh_param(s_cert_file);
1871
1872         if (dh != NULL) {
1873             BIO_printf(bio_s_out, "Setting temp DH parameters\n");
1874         } else {
1875             BIO_printf(bio_s_out, "Using default temp DH parameters\n");
1876             dh = get_dh512();
1877         }
1878         (void)BIO_flush(bio_s_out);
1879
1880         SSL_CTX_set_tmp_dh(ctx, dh);
1881 # ifndef OPENSSL_NO_TLSEXT
1882         if (ctx2) {
1883             if (!dhfile) {
1884                 DH *dh2 = load_dh_param(s_cert_file2);
1885                 if (dh2 != NULL) {
1886                     BIO_printf(bio_s_out, "Setting temp DH parameters\n");
1887                     (void)BIO_flush(bio_s_out);
1888
1889                     DH_free(dh);
1890                     dh = dh2;
1891                 }
1892             }
1893             SSL_CTX_set_tmp_dh(ctx2, dh);
1894         }
1895 # endif
1896         DH_free(dh);
1897     }
1898 #endif
1899
1900     if (!set_cert_key_stuff(ctx, s_cert, s_key, s_chain, build_chain))
1901         goto end;
1902 #ifndef OPENSSL_NO_TLSEXT
1903     if (s_serverinfo_file != NULL
1904         && !SSL_CTX_use_serverinfo_file(ctx, s_serverinfo_file)) {
1905         ERR_print_errors(bio_err);
1906         goto end;
1907     }
1908 #endif
1909 #ifndef OPENSSL_NO_TLSEXT
1910     if (ctx2 && !set_cert_key_stuff(ctx2, s_cert2, s_key2, NULL, build_chain))
1911         goto end;
1912 #endif
1913     if (s_dcert != NULL) {
1914         if (!set_cert_key_stuff(ctx, s_dcert, s_dkey, s_dchain, build_chain))
1915             goto end;
1916     }
1917 #ifndef OPENSSL_NO_RSA
1918 # if 1
1919     if (!no_tmp_rsa) {
1920         SSL_CTX_set_tmp_rsa_callback(ctx, tmp_rsa_cb);
1921 #  ifndef OPENSSL_NO_TLSEXT
1922         if (ctx2)
1923             SSL_CTX_set_tmp_rsa_callback(ctx2, tmp_rsa_cb);
1924 #  endif
1925     }
1926 # else
1927     if (!no_tmp_rsa && SSL_CTX_need_tmp_RSA(ctx)) {
1928         RSA *rsa;
1929
1930         BIO_printf(bio_s_out, "Generating temp (512 bit) RSA key...");
1931         BIO_flush(bio_s_out);
1932
1933         rsa = RSA_generate_key(512, RSA_F4, NULL);
1934
1935         if (!SSL_CTX_set_tmp_rsa(ctx, rsa)) {
1936             ERR_print_errors(bio_err);
1937             goto end;
1938         }
1939 #  ifndef OPENSSL_NO_TLSEXT
1940         if (ctx2) {
1941             if (!SSL_CTX_set_tmp_rsa(ctx2, rsa)) {
1942                 ERR_print_errors(bio_err);
1943                 goto end;
1944             }
1945         }
1946 #  endif
1947         RSA_free(rsa);
1948         BIO_printf(bio_s_out, "\n");
1949     }
1950 # endif
1951 #endif
1952
1953 #ifndef OPENSSL_NO_PSK
1954 # ifdef OPENSSL_NO_JPAKE
1955     if (psk_key != NULL)
1956 # else
1957     if (psk_key != NULL || jpake_secret)
1958 # endif
1959     {
1960         if (s_debug)
1961             BIO_printf(bio_s_out,
1962                        "PSK key given or JPAKE in use, setting server callback\n");
1963         SSL_CTX_set_psk_server_callback(ctx, psk_server_cb);
1964     }
1965
1966     if (!SSL_CTX_use_psk_identity_hint(ctx, psk_identity_hint)) {
1967         BIO_printf(bio_err, "error setting PSK identity hint to context\n");
1968         ERR_print_errors(bio_err);
1969         goto end;
1970     }
1971 #endif
1972
1973     SSL_CTX_set_verify(ctx, s_server_verify, verify_callback);
1974     SSL_CTX_set_session_id_context(ctx, (void *)&s_server_session_id_context,
1975                                    sizeof s_server_session_id_context);
1976
1977     /* Set DTLS cookie generation and verification callbacks */
1978     SSL_CTX_set_cookie_generate_cb(ctx, generate_cookie_callback);
1979     SSL_CTX_set_cookie_verify_cb(ctx, verify_cookie_callback);
1980
1981 #ifndef OPENSSL_NO_TLSEXT
1982     if (ctx2) {
1983         SSL_CTX_set_verify(ctx2, s_server_verify, verify_callback);
1984         SSL_CTX_set_session_id_context(ctx2,
1985                                        (void *)&s_server_session_id_context,
1986                                        sizeof s_server_session_id_context);
1987
1988         tlsextcbp.biodebug = bio_s_out;
1989         SSL_CTX_set_tlsext_servername_callback(ctx2, ssl_servername_cb);
1990         SSL_CTX_set_tlsext_servername_arg(ctx2, &tlsextcbp);
1991         SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
1992         SSL_CTX_set_tlsext_servername_arg(ctx, &tlsextcbp);
1993     }
1994 #endif
1995
1996 #ifndef OPENSSL_NO_SRP
1997     if (srp_verifier_file != NULL) {
1998         srp_callback_parm.vb = SRP_VBASE_new(srpuserseed);
1999         srp_callback_parm.user = NULL;
2000         srp_callback_parm.login = NULL;
2001         if ((ret =
2002              SRP_VBASE_init(srp_callback_parm.vb,
2003                             srp_verifier_file)) != SRP_NO_ERROR) {
2004             BIO_printf(bio_err,
2005                        "Cannot initialize SRP verifier file \"%s\":ret=%d\n",
2006                        srp_verifier_file, ret);
2007             goto end;
2008         }
2009         SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, verify_callback);
2010         SSL_CTX_set_srp_cb_arg(ctx, &srp_callback_parm);
2011         SSL_CTX_set_srp_username_callback(ctx, ssl_srp_server_param_cb);
2012     } else
2013 #endif
2014     if (CAfile != NULL) {
2015         SSL_CTX_set_client_CA_list(ctx, SSL_load_client_CA_file(CAfile));
2016 #ifndef OPENSSL_NO_TLSEXT
2017         if (ctx2)
2018             SSL_CTX_set_client_CA_list(ctx2, SSL_load_client_CA_file(CAfile));
2019 #endif
2020     }
2021
2022     BIO_printf(bio_s_out, "ACCEPT\n");
2023     (void)BIO_flush(bio_s_out);
2024     if (rev)
2025         do_server(port, socket_type, &accept_socket, rev_body, context,
2026                   naccept);
2027     else if (www)
2028         do_server(port, socket_type, &accept_socket, www_body, context,
2029                   naccept);
2030     else
2031         do_server(port, socket_type, &accept_socket, sv_body, context,
2032                   naccept);
2033     print_stats(bio_s_out, ctx);
2034     ret = 0;
2035  end:
2036     if (ctx != NULL)
2037         SSL_CTX_free(ctx);
2038     if (s_cert)
2039         X509_free(s_cert);
2040     if (crls)
2041         sk_X509_CRL_pop_free(crls, X509_CRL_free);
2042     if (s_dcert)
2043         X509_free(s_dcert);
2044     if (s_key)
2045         EVP_PKEY_free(s_key);
2046     if (s_dkey)
2047         EVP_PKEY_free(s_dkey);
2048     if (s_chain)
2049         sk_X509_pop_free(s_chain, X509_free);
2050     if (s_dchain)
2051         sk_X509_pop_free(s_dchain, X509_free);
2052     if (pass)
2053         OPENSSL_free(pass);
2054     if (dpass)
2055         OPENSSL_free(dpass);
2056     if (vpm)
2057         X509_VERIFY_PARAM_free(vpm);
2058     free_sessions();
2059 #ifndef OPENSSL_NO_TLSEXT
2060     if (tlscstatp.host)
2061         OPENSSL_free(tlscstatp.host);
2062     if (tlscstatp.port)
2063         OPENSSL_free(tlscstatp.port);
2064     if (tlscstatp.path)
2065         OPENSSL_free(tlscstatp.path);
2066     if (ctx2 != NULL)
2067         SSL_CTX_free(ctx2);
2068     if (s_cert2)
2069         X509_free(s_cert2);
2070     if (s_key2)
2071         EVP_PKEY_free(s_key2);
2072     if (serverinfo_in != NULL)
2073         BIO_free(serverinfo_in);
2074 # ifndef OPENSSL_NO_NEXTPROTONEG
2075     if (next_proto.data)
2076         OPENSSL_free(next_proto.data);
2077 # endif
2078     if (alpn_ctx.data)
2079         OPENSSL_free(alpn_ctx.data);
2080 #endif
2081     ssl_excert_free(exc);
2082     if (ssl_args)
2083         sk_OPENSSL_STRING_free(ssl_args);
2084     if (cctx)
2085         SSL_CONF_CTX_free(cctx);
2086 #ifndef OPENSSL_NO_JPAKE
2087     if (jpake_secret && psk_key)
2088         OPENSSL_free(psk_key);
2089 #endif
2090     if (bio_s_out != NULL) {
2091         BIO_free(bio_s_out);
2092         bio_s_out = NULL;
2093     }
2094     if (bio_s_msg != NULL) {
2095         BIO_free(bio_s_msg);
2096         bio_s_msg = NULL;
2097     }
2098     apps_shutdown();
2099     OPENSSL_EXIT(ret);
2100 }
2101
2102 static void print_stats(BIO *bio, SSL_CTX *ssl_ctx)
2103 {
2104     BIO_printf(bio, "%4ld items in the session cache\n",
2105                SSL_CTX_sess_number(ssl_ctx));
2106     BIO_printf(bio, "%4ld client connects (SSL_connect())\n",
2107                SSL_CTX_sess_connect(ssl_ctx));
2108     BIO_printf(bio, "%4ld client renegotiates (SSL_connect())\n",
2109                SSL_CTX_sess_connect_renegotiate(ssl_ctx));
2110     BIO_printf(bio, "%4ld client connects that finished\n",
2111                SSL_CTX_sess_connect_good(ssl_ctx));
2112     BIO_printf(bio, "%4ld server accepts (SSL_accept())\n",
2113                SSL_CTX_sess_accept(ssl_ctx));
2114     BIO_printf(bio, "%4ld server renegotiates (SSL_accept())\n",
2115                SSL_CTX_sess_accept_renegotiate(ssl_ctx));
2116     BIO_printf(bio, "%4ld server accepts that finished\n",
2117                SSL_CTX_sess_accept_good(ssl_ctx));
2118     BIO_printf(bio, "%4ld session cache hits\n", SSL_CTX_sess_hits(ssl_ctx));
2119     BIO_printf(bio, "%4ld session cache misses\n",
2120                SSL_CTX_sess_misses(ssl_ctx));
2121     BIO_printf(bio, "%4ld session cache timeouts\n",
2122                SSL_CTX_sess_timeouts(ssl_ctx));
2123     BIO_printf(bio, "%4ld callback cache hits\n",
2124                SSL_CTX_sess_cb_hits(ssl_ctx));
2125     BIO_printf(bio, "%4ld cache full overflows (%ld allowed)\n",
2126                SSL_CTX_sess_cache_full(ssl_ctx),
2127                SSL_CTX_sess_get_cache_size(ssl_ctx));
2128 }
2129
2130 static int sv_body(char *hostname, int s, int stype, unsigned char *context)
2131 {
2132     char *buf = NULL;
2133     fd_set readfds;
2134     int ret = 1, width;
2135     int k, i;
2136     unsigned long l;
2137     SSL *con = NULL;
2138     BIO *sbio;
2139 #ifndef OPENSSL_NO_KRB5
2140     KSSL_CTX *kctx;
2141 #endif
2142     struct timeval timeout;
2143 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE) || defined(OPENSSL_SYS_BEOS_R5)
2144     struct timeval tv;
2145 #else
2146     struct timeval *timeoutp;
2147 #endif
2148
2149     if ((buf = OPENSSL_malloc(bufsize)) == NULL) {
2150         BIO_printf(bio_err, "out of memory\n");
2151         goto err;
2152     }
2153 #ifdef FIONBIO
2154     if (s_nbio) {
2155         unsigned long sl = 1;
2156
2157         if (!s_quiet)
2158             BIO_printf(bio_err, "turning on non blocking io\n");
2159         if (BIO_socket_ioctl(s, FIONBIO, &sl) < 0)
2160             ERR_print_errors(bio_err);
2161     }
2162 #endif
2163
2164     if (con == NULL) {
2165         con = SSL_new(ctx);
2166 #ifndef OPENSSL_NO_TLSEXT
2167         if (s_tlsextdebug) {
2168             SSL_set_tlsext_debug_callback(con, tlsext_cb);
2169             SSL_set_tlsext_debug_arg(con, bio_s_out);
2170         }
2171         if (s_tlsextstatus) {
2172             SSL_CTX_set_tlsext_status_cb(ctx, cert_status_cb);
2173             tlscstatp.err = bio_err;
2174             SSL_CTX_set_tlsext_status_arg(ctx, &tlscstatp);
2175         }
2176 #endif
2177 #ifndef OPENSSL_NO_KRB5
2178         if ((kctx = kssl_ctx_new()) != NULL) {
2179             SSL_set0_kssl_ctx(con, kctx);
2180             kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
2181             kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
2182         }
2183 #endif                          /* OPENSSL_NO_KRB5 */
2184         if (context)
2185             SSL_set_session_id_context(con, context, strlen((char *)context));
2186     }
2187     SSL_clear(con);
2188 #if 0
2189 # ifdef TLSEXT_TYPE_opaque_prf_input
2190     SSL_set_tlsext_opaque_prf_input(con, "Test server", 11);
2191 # endif
2192 #endif
2193
2194     if (stype == SOCK_DGRAM) {
2195
2196         sbio = BIO_new_dgram(s, BIO_NOCLOSE);
2197
2198         if (enable_timeouts) {
2199             timeout.tv_sec = 0;
2200             timeout.tv_usec = DGRAM_RCV_TIMEOUT;
2201             BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout);
2202
2203             timeout.tv_sec = 0;
2204             timeout.tv_usec = DGRAM_SND_TIMEOUT;
2205             BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_SEND_TIMEOUT, 0, &timeout);
2206         }
2207
2208         if (socket_mtu) {
2209             if (socket_mtu < DTLS_get_link_min_mtu(con)) {
2210                 BIO_printf(bio_err, "MTU too small. Must be at least %ld\n",
2211                            DTLS_get_link_min_mtu(con));
2212                 ret = -1;
2213                 BIO_free(sbio);
2214                 goto err;
2215             }
2216             SSL_set_options(con, SSL_OP_NO_QUERY_MTU);
2217             if (!DTLS_set_link_mtu(con, socket_mtu)) {
2218                 BIO_printf(bio_err, "Failed to set MTU\n");
2219                 ret = -1;
2220                 BIO_free(sbio);
2221                 goto err;
2222             }
2223         } else
2224             /* want to do MTU discovery */
2225             BIO_ctrl(sbio, BIO_CTRL_DGRAM_MTU_DISCOVER, 0, NULL);
2226
2227         /* turn on cookie exchange */
2228         SSL_set_options(con, SSL_OP_COOKIE_EXCHANGE);
2229     } else
2230         sbio = BIO_new_socket(s, BIO_NOCLOSE);
2231
2232     if (s_nbio_test) {
2233         BIO *test;
2234
2235         test = BIO_new(BIO_f_nbio_test());
2236         sbio = BIO_push(test, sbio);
2237     }
2238 #ifndef OPENSSL_NO_JPAKE
2239     if (jpake_secret)
2240         jpake_server_auth(bio_s_out, sbio, jpake_secret);
2241 #endif
2242
2243     SSL_set_bio(con, sbio, sbio);
2244     SSL_set_accept_state(con);
2245     /* SSL_set_fd(con,s); */
2246
2247     if (s_debug) {
2248         SSL_set_debug(con, 1);
2249         BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
2250         BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
2251     }
2252     if (s_msg) {
2253 #ifndef OPENSSL_NO_SSL_TRACE
2254         if (s_msg == 2)
2255             SSL_set_msg_callback(con, SSL_trace);
2256         else
2257 #endif
2258             SSL_set_msg_callback(con, msg_cb);
2259         SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
2260     }
2261 #ifndef OPENSSL_NO_TLSEXT
2262     if (s_tlsextdebug) {
2263         SSL_set_tlsext_debug_callback(con, tlsext_cb);
2264         SSL_set_tlsext_debug_arg(con, bio_s_out);
2265     }
2266 #endif
2267
2268     width = s + 1;
2269     for (;;) {
2270         int read_from_terminal;
2271         int read_from_sslcon;
2272
2273         read_from_terminal = 0;
2274         read_from_sslcon = SSL_pending(con);
2275
2276         if (!read_from_sslcon) {
2277             FD_ZERO(&readfds);
2278 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_NETWARE) && !defined(OPENSSL_SYS_BEOS_R5)
2279             openssl_fdset(fileno(stdin), &readfds);
2280 #endif
2281             openssl_fdset(s, &readfds);
2282             /*
2283              * Note: under VMS with SOCKETSHR the second parameter is
2284              * currently of type (int *) whereas under other systems it is
2285              * (void *) if you don't have a cast it will choke the compiler:
2286              * if you do have a cast then you can either go for (int *) or
2287              * (void *).
2288              */
2289 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE)
2290             /*
2291              * Under DOS (non-djgpp) and Windows we can't select on stdin:
2292              * only on sockets. As a workaround we timeout the select every
2293              * second and check for any keypress. In a proper Windows
2294              * application we wouldn't do this because it is inefficient.
2295              */
2296             tv.tv_sec = 1;
2297             tv.tv_usec = 0;
2298             i = select(width, (void *)&readfds, NULL, NULL, &tv);
2299             if ((i < 0) || (!i && !_kbhit()))
2300                 continue;
2301             if (_kbhit())
2302                 read_from_terminal = 1;
2303 #elif defined(OPENSSL_SYS_BEOS_R5)
2304             /* Under BeOS-R5 the situation is similar to DOS */
2305             tv.tv_sec = 1;
2306             tv.tv_usec = 0;
2307             (void)fcntl(fileno(stdin), F_SETFL, O_NONBLOCK);
2308             i = select(width, (void *)&readfds, NULL, NULL, &tv);
2309             if ((i < 0) || (!i && read(fileno(stdin), buf, 0) < 0))
2310                 continue;
2311             if (read(fileno(stdin), buf, 0) >= 0)
2312                 read_from_terminal = 1;
2313             (void)fcntl(fileno(stdin), F_SETFL, 0);
2314 #else
2315             if ((SSL_version(con) == DTLS1_VERSION) &&
2316                 DTLSv1_get_timeout(con, &timeout))
2317                 timeoutp = &timeout;
2318             else
2319                 timeoutp = NULL;
2320
2321             i = select(width, (void *)&readfds, NULL, NULL, timeoutp);
2322
2323             if ((SSL_version(con) == DTLS1_VERSION)
2324                 && DTLSv1_handle_timeout(con) > 0) {
2325                 BIO_printf(bio_err, "TIMEOUT occured\n");
2326             }
2327
2328             if (i <= 0)
2329                 continue;
2330             if (FD_ISSET(fileno(stdin), &readfds))
2331                 read_from_terminal = 1;
2332 #endif
2333             if (FD_ISSET(s, &readfds))
2334                 read_from_sslcon = 1;
2335         }
2336         if (read_from_terminal) {
2337             if (s_crlf) {
2338                 int j, lf_num;
2339
2340                 i = raw_read_stdin(buf, bufsize / 2);
2341                 lf_num = 0;
2342                 /* both loops are skipped when i <= 0 */
2343                 for (j = 0; j < i; j++)
2344                     if (buf[j] == '\n')
2345                         lf_num++;
2346                 for (j = i - 1; j >= 0; j--) {
2347                     buf[j + lf_num] = buf[j];
2348                     if (buf[j] == '\n') {
2349                         lf_num--;
2350                         i++;
2351                         buf[j + lf_num] = '\r';
2352                     }
2353                 }
2354                 assert(lf_num == 0);
2355             } else
2356                 i = raw_read_stdin(buf, bufsize);
2357             if (!s_quiet && !s_brief) {
2358                 if ((i <= 0) || (buf[0] == 'Q')) {
2359                     BIO_printf(bio_s_out, "DONE\n");
2360                     SHUTDOWN(s);
2361                     close_accept_socket();
2362                     ret = -11;
2363                     goto err;
2364                 }
2365                 if ((i <= 0) || (buf[0] == 'q')) {
2366                     BIO_printf(bio_s_out, "DONE\n");
2367                     if (SSL_version(con) != DTLS1_VERSION)
2368                         SHUTDOWN(s);
2369                     /*
2370                      * close_accept_socket(); ret= -11;
2371                      */
2372                     goto err;
2373                 }
2374 #ifndef OPENSSL_NO_HEARTBEATS
2375                 if ((buf[0] == 'B') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2376                     BIO_printf(bio_err, "HEARTBEATING\n");
2377                     SSL_heartbeat(con);
2378                     i = 0;
2379                     continue;
2380                 }
2381 #endif
2382                 if ((buf[0] == 'r') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2383                     SSL_renegotiate(con);
2384                     i = SSL_do_handshake(con);
2385                     printf("SSL_do_handshake -> %d\n", i);
2386                     i = 0;      /* 13; */
2387                     continue;
2388                     /*
2389                      * strcpy(buf,"server side RE-NEGOTIATE\n");
2390                      */
2391                 }
2392                 if ((buf[0] == 'R') && ((buf[1] == '\n') || (buf[1] == '\r'))) {
2393                     SSL_set_verify(con,
2394                                    SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE,
2395                                    NULL);
2396                     SSL_renegotiate(con);
2397                     i = SSL_do_handshake(con);
2398                     printf("SSL_do_handshake -> %d\n", i);
2399                     i = 0;      /* 13; */
2400                     continue;
2401                     /*
2402                      * strcpy(buf,"server side RE-NEGOTIATE asking for client
2403                      * cert\n");
2404                      */
2405                 }
2406                 if (buf[0] == 'P') {
2407                     static const char *str = "Lets print some clear text\n";
2408                     BIO_write(SSL_get_wbio(con), str, strlen(str));
2409                 }
2410                 if (buf[0] == 'S') {
2411                     print_stats(bio_s_out, SSL_get_SSL_CTX(con));
2412                 }
2413             }
2414 #ifdef CHARSET_EBCDIC
2415             ebcdic2ascii(buf, buf, i);
2416 #endif
2417             l = k = 0;
2418             for (;;) {
2419                 /* should do a select for the write */
2420 #ifdef RENEG
2421                 {
2422                     static count = 0;
2423                     if (++count == 100) {
2424                         count = 0;
2425                         SSL_renegotiate(con);
2426                     }
2427                 }
2428 #endif
2429                 k = SSL_write(con, &(buf[l]), (unsigned int)i);
2430 #ifndef OPENSSL_NO_SRP
2431                 while (SSL_get_error(con, k) == SSL_ERROR_WANT_X509_LOOKUP) {
2432                     BIO_printf(bio_s_out, "LOOKUP renego during write\n");
2433                     srp_callback_parm.user =
2434                         SRP_VBASE_get_by_user(srp_callback_parm.vb,
2435                                               srp_callback_parm.login);
2436                     if (srp_callback_parm.user)
2437                         BIO_printf(bio_s_out, "LOOKUP done %s\n",
2438                                    srp_callback_parm.user->info);
2439                     else
2440                         BIO_printf(bio_s_out, "LOOKUP not successful\n");
2441                     k = SSL_write(con, &(buf[l]), (unsigned int)i);
2442                 }
2443 #endif
2444                 switch (SSL_get_error(con, k)) {
2445                 case SSL_ERROR_NONE:
2446                     break;
2447                 case SSL_ERROR_WANT_WRITE:
2448                 case SSL_ERROR_WANT_READ:
2449                 case SSL_ERROR_WANT_X509_LOOKUP:
2450                     BIO_printf(bio_s_out, "Write BLOCK\n");
2451                     break;
2452                 case SSL_ERROR_SYSCALL:
2453                 case SSL_ERROR_SSL:
2454                     BIO_printf(bio_s_out, "ERROR\n");
2455                     ERR_print_errors(bio_err);
2456                     ret = 1;
2457                     goto err;
2458                     /* break; */
2459                 case SSL_ERROR_ZERO_RETURN:
2460                     BIO_printf(bio_s_out, "DONE\n");
2461                     ret = 1;
2462                     goto err;
2463                 }
2464                 l += k;
2465                 i -= k;
2466                 if (i <= 0)
2467                     break;
2468             }
2469         }
2470         if (read_from_sslcon) {
2471             if (!SSL_is_init_finished(con)) {
2472                 i = init_ssl_connection(con);
2473
2474                 if (i < 0) {
2475                     ret = 0;
2476                     goto err;
2477                 } else if (i == 0) {
2478                     ret = 1;
2479                     goto err;
2480                 }
2481             } else {
2482  again:
2483                 i = SSL_read(con, (char *)buf, bufsize);
2484 #ifndef OPENSSL_NO_SRP
2485                 while (SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2486                     BIO_printf(bio_s_out, "LOOKUP renego during read\n");
2487                     srp_callback_parm.user =
2488                         SRP_VBASE_get_by_user(srp_callback_parm.vb,
2489                                               srp_callback_parm.login);
2490                     if (srp_callback_parm.user)
2491                         BIO_printf(bio_s_out, "LOOKUP done %s\n",
2492                                    srp_callback_parm.user->info);
2493                     else
2494                         BIO_printf(bio_s_out, "LOOKUP not successful\n");
2495                     i = SSL_read(con, (char *)buf, bufsize);
2496                 }
2497 #endif
2498                 switch (SSL_get_error(con, i)) {
2499                 case SSL_ERROR_NONE:
2500 #ifdef CHARSET_EBCDIC
2501                     ascii2ebcdic(buf, buf, i);
2502 #endif
2503                     raw_write_stdout(buf, (unsigned int)i);
2504                     if (SSL_pending(con))
2505                         goto again;
2506                     break;
2507                 case SSL_ERROR_WANT_WRITE:
2508                 case SSL_ERROR_WANT_READ:
2509                     BIO_printf(bio_s_out, "Read BLOCK\n");
2510                     break;
2511                 case SSL_ERROR_SYSCALL:
2512                 case SSL_ERROR_SSL:
2513                     BIO_printf(bio_s_out, "ERROR\n");
2514                     ERR_print_errors(bio_err);
2515                     ret = 1;
2516                     goto err;
2517                 case SSL_ERROR_ZERO_RETURN:
2518                     BIO_printf(bio_s_out, "DONE\n");
2519                     ret = 1;
2520                     goto err;
2521                 }
2522             }
2523         }
2524     }
2525  err:
2526     if (con != NULL) {
2527         BIO_printf(bio_s_out, "shutting down SSL\n");
2528 #if 1
2529         SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
2530 #else
2531         SSL_shutdown(con);
2532 #endif
2533         SSL_free(con);
2534     }
2535     BIO_printf(bio_s_out, "CONNECTION CLOSED\n");
2536     if (buf != NULL) {
2537         OPENSSL_cleanse(buf, bufsize);
2538         OPENSSL_free(buf);
2539     }
2540     if (ret >= 0)
2541         BIO_printf(bio_s_out, "ACCEPT\n");
2542     return (ret);
2543 }
2544
2545 static void close_accept_socket(void)
2546 {
2547     BIO_printf(bio_err, "shutdown accept socket\n");
2548     if (accept_socket >= 0) {
2549         SHUTDOWN2(accept_socket);
2550     }
2551 }
2552
2553 static int init_ssl_connection(SSL *con)
2554 {
2555     int i;
2556     const char *str;
2557     X509 *peer;
2558     long verify_error;
2559     MS_STATIC char buf[BUFSIZ];
2560 #ifndef OPENSSL_NO_KRB5
2561     char *client_princ;
2562 #endif
2563 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2564     const unsigned char *next_proto_neg;
2565     unsigned next_proto_neg_len;
2566 #endif
2567     unsigned char *exportedkeymat;
2568
2569     i = SSL_accept(con);
2570 #ifdef CERT_CB_TEST_RETRY
2571     {
2572         while (i <= 0 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP
2573                && SSL_state(con) == SSL3_ST_SR_CLNT_HELLO_C) {
2574             fprintf(stderr,
2575                     "LOOKUP from certificate callback during accept\n");
2576             i = SSL_accept(con);
2577         }
2578     }
2579 #endif
2580 #ifndef OPENSSL_NO_SRP
2581     while (i <= 0 && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2582         BIO_printf(bio_s_out, "LOOKUP during accept %s\n",
2583                    srp_callback_parm.login);
2584         srp_callback_parm.user =
2585             SRP_VBASE_get_by_user(srp_callback_parm.vb,
2586                                   srp_callback_parm.login);
2587         if (srp_callback_parm.user)
2588             BIO_printf(bio_s_out, "LOOKUP done %s\n",
2589                        srp_callback_parm.user->info);
2590         else
2591             BIO_printf(bio_s_out, "LOOKUP not successful\n");
2592         i = SSL_accept(con);
2593     }
2594 #endif
2595
2596     if (i <= 0) {
2597         if (BIO_sock_should_retry(i)) {
2598             BIO_printf(bio_s_out, "DELAY\n");
2599             return (1);
2600         }
2601
2602         BIO_printf(bio_err, "ERROR\n");
2603         verify_error = SSL_get_verify_result(con);
2604         if (verify_error != X509_V_OK) {
2605             BIO_printf(bio_err, "verify error:%s\n",
2606                        X509_verify_cert_error_string(verify_error));
2607         }
2608         /* Always print any error messages */
2609         ERR_print_errors(bio_err);
2610         return (0);
2611     }
2612
2613     if (s_brief)
2614         print_ssl_summary(bio_err, con);
2615
2616     PEM_write_bio_SSL_SESSION(bio_s_out, SSL_get_session(con));
2617
2618     peer = SSL_get_peer_certificate(con);
2619     if (peer != NULL) {
2620         BIO_printf(bio_s_out, "Client certificate\n");
2621         PEM_write_bio_X509(bio_s_out, peer);
2622         X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof buf);
2623         BIO_printf(bio_s_out, "subject=%s\n", buf);
2624         X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof buf);
2625         BIO_printf(bio_s_out, "issuer=%s\n", buf);
2626         X509_free(peer);
2627     }
2628
2629     if (SSL_get_shared_ciphers(con, buf, sizeof buf) != NULL)
2630         BIO_printf(bio_s_out, "Shared ciphers:%s\n", buf);
2631     str = SSL_CIPHER_get_name(SSL_get_current_cipher(con));
2632     ssl_print_sigalgs(bio_s_out, con);
2633 #ifndef OPENSSL_NO_EC
2634     ssl_print_point_formats(bio_s_out, con);
2635     ssl_print_curves(bio_s_out, con, 0);
2636 #endif
2637     BIO_printf(bio_s_out, "CIPHER is %s\n", (str != NULL) ? str : "(NONE)");
2638
2639 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2640     SSL_get0_next_proto_negotiated(con, &next_proto_neg, &next_proto_neg_len);
2641     if (next_proto_neg) {
2642         BIO_printf(bio_s_out, "NEXTPROTO is ");
2643         BIO_write(bio_s_out, next_proto_neg, next_proto_neg_len);
2644         BIO_printf(bio_s_out, "\n");
2645     }
2646 #endif
2647 #ifndef OPENSSL_NO_SRTP
2648     {
2649         SRTP_PROTECTION_PROFILE *srtp_profile
2650             = SSL_get_selected_srtp_profile(con);
2651
2652         if (srtp_profile)
2653             BIO_printf(bio_s_out, "SRTP Extension negotiated, profile=%s\n",
2654                        srtp_profile->name);
2655     }
2656 #endif
2657     if (SSL_cache_hit(con))
2658         BIO_printf(bio_s_out, "Reused session-id\n");
2659     if (SSL_ctrl(con, SSL_CTRL_GET_FLAGS, 0, NULL) &
2660         TLS1_FLAGS_TLS_PADDING_BUG)
2661         BIO_printf(bio_s_out, "Peer has incorrect TLSv1 block padding\n");
2662 #ifndef OPENSSL_NO_KRB5
2663     client_princ = kssl_ctx_get0_client_princ(SSL_get0_kssl_ctx(con));
2664     if (client_princ != NULL) {
2665         BIO_printf(bio_s_out, "Kerberos peer principal is %s\n",
2666                    client_princ);
2667     }
2668 #endif                          /* OPENSSL_NO_KRB5 */
2669     BIO_printf(bio_s_out, "Secure Renegotiation IS%s supported\n",
2670                SSL_get_secure_renegotiation_support(con) ? "" : " NOT");
2671     if (keymatexportlabel != NULL) {
2672         BIO_printf(bio_s_out, "Keying material exporter:\n");
2673         BIO_printf(bio_s_out, "    Label: '%s'\n", keymatexportlabel);
2674         BIO_printf(bio_s_out, "    Length: %i bytes\n", keymatexportlen);
2675         exportedkeymat = OPENSSL_malloc(keymatexportlen);
2676         if (exportedkeymat != NULL) {
2677             if (!SSL_export_keying_material(con, exportedkeymat,
2678                                             keymatexportlen,
2679                                             keymatexportlabel,
2680                                             strlen(keymatexportlabel),
2681                                             NULL, 0, 0)) {
2682                 BIO_printf(bio_s_out, "    Error\n");
2683             } else {
2684                 BIO_printf(bio_s_out, "    Keying material: ");
2685                 for (i = 0; i < keymatexportlen; i++)
2686                     BIO_printf(bio_s_out, "%02X", exportedkeymat[i]);
2687                 BIO_printf(bio_s_out, "\n");
2688             }
2689             OPENSSL_free(exportedkeymat);
2690         }
2691     }
2692
2693     return (1);
2694 }
2695
2696 #ifndef OPENSSL_NO_DH
2697 static DH *load_dh_param(const char *dhfile)
2698 {
2699     DH *ret = NULL;
2700     BIO *bio;
2701
2702     if ((bio = BIO_new_file(dhfile, "r")) == NULL)
2703         goto err;
2704     ret = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
2705  err:
2706     if (bio != NULL)
2707         BIO_free(bio);
2708     return (ret);
2709 }
2710 #endif
2711 #ifndef OPENSSL_NO_KRB5
2712 char *client_princ;
2713 #endif
2714
2715 #if 0
2716 static int load_CA(SSL_CTX *ctx, char *file)
2717 {
2718     FILE *in;
2719     X509 *x = NULL;
2720
2721     if ((in = fopen(file, "r")) == NULL)
2722         return (0);
2723
2724     for (;;) {
2725         if (PEM_read_X509(in, &x, NULL) == NULL)
2726             break;
2727         SSL_CTX_add_client_CA(ctx, x);
2728     }
2729     if (x != NULL)
2730         X509_free(x);
2731     fclose(in);
2732     return (1);
2733 }
2734 #endif
2735
2736 static int www_body(char *hostname, int s, int stype, unsigned char *context)
2737 {
2738     char *buf = NULL;
2739     int ret = 1;
2740     int i, j, k, dot;
2741     SSL *con;
2742     const SSL_CIPHER *c;
2743     BIO *io, *ssl_bio, *sbio;
2744 #ifndef OPENSSL_NO_KRB5
2745     KSSL_CTX *kctx;
2746 #endif
2747
2748     buf = OPENSSL_malloc(bufsize);
2749     if (buf == NULL)
2750         return (0);
2751     io = BIO_new(BIO_f_buffer());
2752     ssl_bio = BIO_new(BIO_f_ssl());
2753     if ((io == NULL) || (ssl_bio == NULL))
2754         goto err;
2755
2756 #ifdef FIONBIO
2757     if (s_nbio) {
2758         unsigned long sl = 1;
2759
2760         if (!s_quiet)
2761             BIO_printf(bio_err, "turning on non blocking io\n");
2762         if (BIO_socket_ioctl(s, FIONBIO, &sl) < 0)
2763             ERR_print_errors(bio_err);
2764     }
2765 #endif
2766
2767     /* lets make the output buffer a reasonable size */
2768     if (!BIO_set_write_buffer_size(io, bufsize))
2769         goto err;
2770
2771     if ((con = SSL_new(ctx)) == NULL)
2772         goto err;
2773 #ifndef OPENSSL_NO_TLSEXT
2774     if (s_tlsextdebug) {
2775         SSL_set_tlsext_debug_callback(con, tlsext_cb);
2776         SSL_set_tlsext_debug_arg(con, bio_s_out);
2777     }
2778 #endif
2779 #ifndef OPENSSL_NO_KRB5
2780     if ((kctx = kssl_ctx_new()) != NULL) {
2781         kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
2782         kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
2783     }
2784 #endif                          /* OPENSSL_NO_KRB5 */
2785     if (context)
2786         SSL_set_session_id_context(con, context, strlen((char *)context));
2787
2788     sbio = BIO_new_socket(s, BIO_NOCLOSE);
2789     if (s_nbio_test) {
2790         BIO *test;
2791
2792         test = BIO_new(BIO_f_nbio_test());
2793         sbio = BIO_push(test, sbio);
2794     }
2795     SSL_set_bio(con, sbio, sbio);
2796     SSL_set_accept_state(con);
2797
2798     /* SSL_set_fd(con,s); */
2799     BIO_set_ssl(ssl_bio, con, BIO_CLOSE);
2800     BIO_push(io, ssl_bio);
2801 #ifdef CHARSET_EBCDIC
2802     io = BIO_push(BIO_new(BIO_f_ebcdic_filter()), io);
2803 #endif
2804
2805     if (s_debug) {
2806         SSL_set_debug(con, 1);
2807         BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
2808         BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
2809     }
2810     if (s_msg) {
2811 #ifndef OPENSSL_NO_SSL_TRACE
2812         if (s_msg == 2)
2813             SSL_set_msg_callback(con, SSL_trace);
2814         else
2815 #endif
2816             SSL_set_msg_callback(con, msg_cb);
2817         SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
2818     }
2819
2820     for (;;) {
2821         if (hack) {
2822             i = SSL_accept(con);
2823 #ifndef OPENSSL_NO_SRP
2824             while (i <= 0
2825                    && SSL_get_error(con, i) == SSL_ERROR_WANT_X509_LOOKUP) {
2826                 BIO_printf(bio_s_out, "LOOKUP during accept %s\n",
2827                            srp_callback_parm.login);
2828                 srp_callback_parm.user =
2829                     SRP_VBASE_get_by_user(srp_callback_parm.vb,
2830                                           srp_callback_parm.login);
2831                 if (srp_callback_parm.user)
2832                     BIO_printf(bio_s_out, "LOOKUP done %s\n",
2833                                srp_callback_parm.user->info);
2834                 else
2835                     BIO_printf(bio_s_out, "LOOKUP not successful\n");
2836                 i = SSL_accept(con);
2837             }
2838 #endif
2839             switch (SSL_get_error(con, i)) {
2840             case SSL_ERROR_NONE:
2841                 break;
2842             case SSL_ERROR_WANT_WRITE:
2843             case SSL_ERROR_WANT_READ:
2844             case SSL_ERROR_WANT_X509_LOOKUP:
2845                 continue;
2846             case SSL_ERROR_SYSCALL:
2847             case SSL_ERROR_SSL:
2848             case SSL_ERROR_ZERO_RETURN:
2849                 ret = 1;
2850                 goto err;
2851                 /* break; */
2852             }
2853
2854             SSL_renegotiate(con);
2855             SSL_write(con, NULL, 0);
2856         }
2857
2858         i = BIO_gets(io, buf, bufsize - 1);
2859         if (i < 0) {            /* error */
2860             if (!BIO_should_retry(io)) {
2861                 if (!s_quiet)
2862                     ERR_print_errors(bio_err);
2863                 goto err;
2864             } else {
2865                 BIO_printf(bio_s_out, "read R BLOCK\n");
2866 #if defined(OPENSSL_SYS_NETWARE)
2867                 delay(1000);
2868 #elif !defined(OPENSSL_SYS_MSDOS) && !defined(__DJGPP__)
2869                 sleep(1);
2870 #endif
2871                 continue;
2872             }
2873         } else if (i == 0) {    /* end of input */
2874             ret = 1;
2875             goto end;
2876         }
2877
2878         /* else we have data */
2879         if (((www == 1) && (strncmp("GET ", buf, 4) == 0)) ||
2880             ((www == 2) && (strncmp("GET /stats ", buf, 10) == 0))) {
2881             char *p;
2882             X509 *peer;
2883             STACK_OF(SSL_CIPHER) *sk;
2884             static const char *space = "                          ";
2885
2886             BIO_puts(io,
2887                      "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
2888             BIO_puts(io, "<HTML><BODY BGCOLOR=\"#ffffff\">\n");
2889             BIO_puts(io, "<pre>\n");
2890 /*                      BIO_puts(io,SSLeay_version(SSLEAY_VERSION));*/
2891             BIO_puts(io, "\n");
2892             for (i = 0; i < local_argc; i++) {
2893                 BIO_puts(io, local_argv[i]);
2894                 BIO_write(io, " ", 1);
2895             }
2896             BIO_puts(io, "\n");
2897
2898             BIO_printf(io,
2899                        "Secure Renegotiation IS%s supported\n",
2900                        SSL_get_secure_renegotiation_support(con) ?
2901                        "" : " NOT");
2902
2903             /*
2904              * The following is evil and should not really be done
2905              */
2906             BIO_printf(io, "Ciphers supported in s_server binary\n");
2907             sk = SSL_get_ciphers(con);
2908             j = sk_SSL_CIPHER_num(sk);
2909             for (i = 0; i < j; i++) {
2910                 c = sk_SSL_CIPHER_value(sk, i);
2911                 BIO_printf(io, "%-11s:%-25s",
2912                            SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2913                 if ((((i + 1) % 2) == 0) && (i + 1 != j))
2914                     BIO_puts(io, "\n");
2915             }
2916             BIO_puts(io, "\n");
2917             p = SSL_get_shared_ciphers(con, buf, bufsize);
2918             if (p != NULL) {
2919                 BIO_printf(io,
2920                            "---\nCiphers common between both SSL end points:\n");
2921                 j = i = 0;
2922                 while (*p) {
2923                     if (*p == ':') {
2924                         BIO_write(io, space, 26 - j);
2925                         i++;
2926                         j = 0;
2927                         BIO_write(io, ((i % 3) ? " " : "\n"), 1);
2928                     } else {
2929                         BIO_write(io, p, 1);
2930                         j++;
2931                     }
2932                     p++;
2933                 }
2934                 BIO_puts(io, "\n");
2935             }
2936             ssl_print_sigalgs(io, con);
2937 #ifndef OPENSSL_NO_EC
2938             ssl_print_curves(io, con, 0);
2939 #endif
2940             BIO_printf(io, (SSL_cache_hit(con)
2941                             ? "---\nReused, " : "---\nNew, "));
2942             c = SSL_get_current_cipher(con);
2943             BIO_printf(io, "%s, Cipher is %s\n",
2944                        SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2945             SSL_SESSION_print(io, SSL_get_session(con));
2946             BIO_printf(io, "---\n");
2947             print_stats(io, SSL_get_SSL_CTX(con));
2948             BIO_printf(io, "---\n");
2949             peer = SSL_get_peer_certificate(con);
2950             if (peer != NULL) {
2951                 BIO_printf(io, "Client certificate\n");
2952                 X509_print(io, peer);
2953                 PEM_write_bio_X509(io, peer);
2954             } else
2955                 BIO_puts(io, "no client certificate available\n");
2956             BIO_puts(io, "</BODY></HTML>\r\n\r\n");
2957             break;
2958         } else if ((www == 2 || www == 3)
2959                    && (strncmp("GET /", buf, 5) == 0)) {
2960             BIO *file;
2961             char *p, *e;
2962             static const char *text =
2963                 "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n";
2964
2965             /* skip the '/' */
2966             p = &(buf[5]);
2967
2968             dot = 1;
2969             for (e = p; *e != '\0'; e++) {
2970                 if (e[0] == ' ')
2971                     break;
2972
2973                 switch (dot) {
2974                 case 1:
2975                     dot = (e[0] == '.') ? 2 : 0;
2976                     break;
2977                 case 2:
2978                     dot = (e[0] == '.') ? 3 : 0;
2979                     break;
2980                 case 3:
2981                     dot = (e[0] == '/') ? -1 : 0;
2982                     break;
2983                 }
2984                 if (dot == 0)
2985                     dot = (e[0] == '/') ? 1 : 0;
2986             }
2987             dot = (dot == 3) || (dot == -1); /* filename contains ".."
2988                                               * component */
2989
2990             if (*e == '\0') {
2991                 BIO_puts(io, text);
2992                 BIO_printf(io, "'%s' is an invalid file name\r\n", p);
2993                 break;
2994             }
2995             *e = '\0';
2996
2997             if (dot) {
2998                 BIO_puts(io, text);
2999                 BIO_printf(io, "'%s' contains '..' reference\r\n", p);
3000                 break;
3001             }
3002
3003             if (*p == '/') {
3004                 BIO_puts(io, text);
3005                 BIO_printf(io, "'%s' is an invalid path\r\n", p);
3006                 break;
3007             }
3008 #if 0
3009             /* append if a directory lookup */
3010             if (e[-1] == '/')
3011                 strcat(p, "index.html");
3012 #endif
3013
3014             /* if a directory, do the index thang */
3015             if (app_isdir(p) > 0) {
3016 #if 0                           /* must check buffer size */
3017                 strcat(p, "/index.html");
3018 #else
3019                 BIO_puts(io, text);
3020                 BIO_printf(io, "'%s' is a directory\r\n", p);
3021                 break;
3022 #endif
3023             }
3024
3025             if ((file = BIO_new_file(p, "r")) == NULL) {
3026                 BIO_puts(io, text);
3027                 BIO_printf(io, "Error opening '%s'\r\n", p);
3028                 ERR_print_errors(io);
3029                 break;
3030             }
3031
3032             if (!s_quiet)
3033                 BIO_printf(bio_err, "FILE:%s\n", p);
3034
3035             if (www == 2) {
3036                 i = strlen(p);
3037                 if (((i > 5) && (strcmp(&(p[i - 5]), ".html") == 0)) ||
3038                     ((i > 4) && (strcmp(&(p[i - 4]), ".php") == 0)) ||
3039                     ((i > 4) && (strcmp(&(p[i - 4]), ".htm") == 0)))
3040                     BIO_puts(io,
3041                              "HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
3042                 else
3043                     BIO_puts(io,
3044                              "HTTP/1.0 200 ok\r\nContent-type: text/plain\r\n\r\n");
3045             }
3046             /* send the file */
3047             for (;;) {
3048                 i = BIO_read(file, buf, bufsize);
3049                 if (i <= 0)
3050                     break;
3051
3052 #ifdef RENEG
3053                 total_bytes += i;
3054                 fprintf(stderr, "%d\n", i);
3055                 if (total_bytes > 3 * 1024) {
3056                     total_bytes = 0;
3057                     fprintf(stderr, "RENEGOTIATE\n");
3058                     SSL_renegotiate(con);
3059                 }
3060 #endif
3061
3062                 for (j = 0; j < i;) {
3063 #ifdef RENEG
3064                     {
3065                         static count = 0;
3066                         if (++count == 13) {
3067                             SSL_renegotiate(con);
3068                         }
3069                     }
3070 #endif
3071                     k = BIO_write(io, &(buf[j]), i - j);
3072                     if (k <= 0) {
3073                         if (!BIO_should_retry(io))
3074                             goto write_error;
3075                         else {
3076                             BIO_printf(bio_s_out, "rwrite W BLOCK\n");
3077                         }
3078                     } else {
3079                         j += k;
3080                     }
3081                 }
3082             }
3083  write_error:
3084             BIO_free(file);
3085             break;
3086         }
3087     }
3088
3089     for (;;) {
3090         i = (int)BIO_flush(io);
3091         if (i <= 0) {
3092             if (!BIO_should_retry(io))
3093                 break;
3094         } else
3095             break;
3096     }
3097  end:
3098 #if 1
3099     /* make sure we re-use sessions */
3100     SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
3101 #else
3102     /* This kills performance */
3103     /*
3104      * SSL_shutdown(con); A shutdown gets sent in the BIO_free_all(io)
3105      * procession
3106      */
3107 #endif
3108
3109  err:
3110
3111     if (ret >= 0)
3112         BIO_printf(bio_s_out, "ACCEPT\n");
3113
3114     if (buf != NULL)
3115         OPENSSL_free(buf);
3116     if (io != NULL)
3117         BIO_free_all(io);
3118 /*      if (ssl_bio != NULL) BIO_free(ssl_bio);*/
3119     return (ret);
3120 }
3121
3122 static int rev_body(char *hostname, int s, int stype, unsigned char *context)
3123 {
3124     char *buf = NULL;
3125     int i;
3126     int ret = 1;
3127     SSL *con;
3128     BIO *io, *ssl_bio, *sbio;
3129 #ifndef OPENSSL_NO_KRB5
3130     KSSL_CTX *kctx;
3131 #endif
3132
3133     buf = OPENSSL_malloc(bufsize);
3134     if (buf == NULL)
3135         return (0);
3136     io = BIO_new(BIO_f_buffer());
3137     ssl_bio = BIO_new(BIO_f_ssl());
3138     if ((io == NULL) || (ssl_bio == NULL))
3139         goto err;
3140
3141     /* lets make the output buffer a reasonable size */
3142     if (!BIO_set_write_buffer_size(io, bufsize))
3143         goto err;
3144
3145     if ((con = SSL_new(ctx)) == NULL)
3146         goto err;
3147 #ifndef OPENSSL_NO_TLSEXT
3148     if (s_tlsextdebug) {
3149         SSL_set_tlsext_debug_callback(con, tlsext_cb);
3150         SSL_set_tlsext_debug_arg(con, bio_s_out);
3151     }
3152 #endif
3153 #ifndef OPENSSL_NO_KRB5
3154     if ((kctx = kssl_ctx_new()) != NULL) {
3155         kssl_ctx_setstring(kctx, KSSL_SERVICE, KRB5SVC);
3156         kssl_ctx_setstring(kctx, KSSL_KEYTAB, KRB5KEYTAB);
3157     }
3158 #endif                          /* OPENSSL_NO_KRB5 */
3159     if (context)
3160         SSL_set_session_id_context(con, context, strlen((char *)context));
3161
3162     sbio = BIO_new_socket(s, BIO_NOCLOSE);
3163     SSL_set_bio(con, sbio, sbio);
3164     SSL_set_accept_state(con);
3165
3166     BIO_set_ssl(ssl_bio, con, BIO_CLOSE);
3167     BIO_push(io, ssl_bio);
3168 #ifdef CHARSET_EBCDIC
3169     io = BIO_push(BIO_new(BIO_f_ebcdic_filter()), io);
3170 #endif
3171
3172     if (s_debug) {
3173         SSL_set_debug(con, 1);
3174         BIO_set_callback(SSL_get_rbio(con), bio_dump_callback);
3175         BIO_set_callback_arg(SSL_get_rbio(con), (char *)bio_s_out);
3176     }
3177     if (s_msg) {
3178 #ifndef OPENSSL_NO_SSL_TRACE
3179         if (s_msg == 2)
3180             SSL_set_msg_callback(con, SSL_trace);
3181         else
3182 #endif
3183             SSL_set_msg_callback(con, msg_cb);
3184         SSL_set_msg_callback_arg(con, bio_s_msg ? bio_s_msg : bio_s_out);
3185     }
3186
3187     for (;;) {
3188         i = BIO_do_handshake(io);
3189         if (i > 0)
3190             break;
3191         if (!BIO_should_retry(io)) {
3192             BIO_puts(bio_err, "CONNECTION FAILURE\n");
3193             ERR_print_errors(bio_err);
3194             goto end;
3195         }
3196     }
3197     BIO_printf(bio_err, "CONNECTION ESTABLISHED\n");
3198     print_ssl_summary(bio_err, con);
3199
3200     for (;;) {
3201         i = BIO_gets(io, buf, bufsize - 1);
3202         if (i < 0) {            /* error */
3203             if (!BIO_should_retry(io)) {
3204                 if (!s_quiet)
3205                     ERR_print_errors(bio_err);
3206                 goto err;
3207             } else {
3208                 BIO_printf(bio_s_out, "read R BLOCK\n");
3209 #if defined(OPENSSL_SYS_NETWARE)
3210                 delay(1000);
3211 #elif !defined(OPENSSL_SYS_MSDOS) && !defined(__DJGPP__)
3212                 sleep(1);
3213 #endif
3214                 continue;
3215             }
3216         } else if (i == 0) {    /* end of input */
3217             ret = 1;
3218             BIO_printf(bio_err, "CONNECTION CLOSED\n");
3219             goto end;
3220         } else {
3221             char *p = buf + i - 1;
3222             while (i && (*p == '\n' || *p == '\r')) {
3223                 p--;
3224                 i--;
3225             }
3226             if (!s_ign_eof && i == 5 && !strncmp(buf, "CLOSE", 5)) {
3227                 ret = 1;
3228                 BIO_printf(bio_err, "CONNECTION CLOSED\n");
3229                 goto end;
3230             }
3231             BUF_reverse((unsigned char *)buf, NULL, i);
3232             buf[i] = '\n';
3233             BIO_write(io, buf, i + 1);
3234             for (;;) {
3235                 i = BIO_flush(io);
3236                 if (i > 0)
3237                     break;
3238                 if (!BIO_should_retry(io))
3239                     goto end;
3240             }
3241         }
3242     }
3243  end:
3244     /* make sure we re-use sessions */
3245     SSL_set_shutdown(con, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
3246
3247  err:
3248
3249     if (buf != NULL)
3250         OPENSSL_free(buf);
3251     if (io != NULL)
3252         BIO_free_all(io);
3253     return (ret);
3254 }
3255
3256 #ifndef OPENSSL_NO_RSA
3257 static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int is_export, int keylength)
3258 {
3259     BIGNUM *bn = NULL;
3260     static RSA *rsa_tmp = NULL;
3261
3262     if (!rsa_tmp && ((bn = BN_new()) == NULL))
3263         BIO_printf(bio_err, "Allocation error in generating RSA key\n");
3264     if (!rsa_tmp && bn) {
3265         if (!s_quiet) {
3266             BIO_printf(bio_err, "Generating temp (%d bit) RSA key...",
3267                        keylength);
3268             (void)BIO_flush(bio_err);
3269         }
3270         if (!BN_set_word(bn, RSA_F4) || ((rsa_tmp = RSA_new()) == NULL) ||
3271             !RSA_generate_key_ex(rsa_tmp, keylength, bn, NULL)) {
3272             if (rsa_tmp)
3273                 RSA_free(rsa_tmp);
3274             rsa_tmp = NULL;
3275         }
3276         if (!s_quiet) {
3277             BIO_printf(bio_err, "\n");
3278             (void)BIO_flush(bio_err);
3279         }
3280         BN_free(bn);
3281     }
3282     return (rsa_tmp);
3283 }
3284 #endif
3285
3286 #define MAX_SESSION_ID_ATTEMPTS 10
3287 static int generate_session_id(const SSL *ssl, unsigned char *id,
3288                                unsigned int *id_len)
3289 {
3290     unsigned int count = 0;
3291     do {
3292         RAND_pseudo_bytes(id, *id_len);
3293         /*
3294          * Prefix the session_id with the required prefix. NB: If our prefix
3295          * is too long, clip it - but there will be worse effects anyway, eg.
3296          * the server could only possibly create 1 session ID (ie. the
3297          * prefix!) so all future session negotiations will fail due to
3298          * conflicts.
3299          */
3300         memcpy(id, session_id_prefix,
3301                (strlen(session_id_prefix) < *id_len) ?
3302                strlen(session_id_prefix) : *id_len);
3303     }
3304     while (SSL_has_matching_session_id(ssl, id, *id_len) &&
3305            (++count < MAX_SESSION_ID_ATTEMPTS));
3306     if (count >= MAX_SESSION_ID_ATTEMPTS)
3307         return 0;
3308     return 1;
3309 }
3310
3311 /*
3312  * By default s_server uses an in-memory cache which caches SSL_SESSION
3313  * structures without any serialisation. This hides some bugs which only
3314  * become apparent in deployed servers. By implementing a basic external
3315  * session cache some issues can be debugged using s_server.
3316  */
3317
3318 typedef struct simple_ssl_session_st {
3319     unsigned char *id;
3320     unsigned int idlen;
3321     unsigned char *der;
3322     int derlen;
3323     struct simple_ssl_session_st *next;
3324 } simple_ssl_session;
3325
3326 static simple_ssl_session *first = NULL;
3327
3328 static int add_session(SSL *ssl, SSL_SESSION *session)
3329 {
3330     simple_ssl_session *sess;
3331     unsigned char *p;
3332
3333     sess = OPENSSL_malloc(sizeof(simple_ssl_session));
3334
3335     SSL_SESSION_get_id(session, &sess->idlen);
3336     sess->derlen = i2d_SSL_SESSION(session, NULL);
3337
3338     sess->id = BUF_memdup(SSL_SESSION_get_id(session, NULL), sess->idlen);
3339
3340     sess->der = OPENSSL_malloc(sess->derlen);
3341     p = sess->der;
3342     i2d_SSL_SESSION(session, &p);
3343
3344     sess->next = first;
3345     first = sess;
3346     BIO_printf(bio_err, "New session added to external cache\n");
3347     return 0;
3348 }
3349
3350 static SSL_SESSION *get_session(SSL *ssl, unsigned char *id, int idlen,
3351                                 int *do_copy)
3352 {
3353     simple_ssl_session *sess;
3354     *do_copy = 0;
3355     for (sess = first; sess; sess = sess->next) {
3356         if (idlen == (int)sess->idlen && !memcmp(sess->id, id, idlen)) {
3357             const unsigned char *p = sess->der;
3358             BIO_printf(bio_err, "Lookup session: cache hit\n");
3359             return d2i_SSL_SESSION(NULL, &p, sess->derlen);
3360         }
3361     }
3362     BIO_printf(bio_err, "Lookup session: cache miss\n");
3363     return NULL;
3364 }
3365
3366 static void del_session(SSL_CTX *sctx, SSL_SESSION *session)
3367 {
3368     simple_ssl_session *sess, *prev = NULL;
3369     const unsigned char *id;
3370     unsigned int idlen;
3371     id = SSL_SESSION_get_id(session, &idlen);
3372     for (sess = first; sess; sess = sess->next) {
3373         if (idlen == sess->idlen && !memcmp(sess->id, id, idlen)) {
3374             if (prev)
3375                 prev->next = sess->next;
3376             else
3377                 first = sess->next;
3378             OPENSSL_free(sess->id);
3379             OPENSSL_free(sess->der);
3380             OPENSSL_free(sess);
3381             return;
3382         }
3383         prev = sess;
3384     }
3385 }
3386
3387 static void init_session_cache_ctx(SSL_CTX *sctx)
3388 {
3389     SSL_CTX_set_session_cache_mode(sctx,
3390                                    SSL_SESS_CACHE_NO_INTERNAL |
3391                                    SSL_SESS_CACHE_SERVER);
3392     SSL_CTX_sess_set_new_cb(sctx, add_session);
3393     SSL_CTX_sess_set_get_cb(sctx, get_session);
3394     SSL_CTX_sess_set_remove_cb(sctx, del_session);
3395 }
3396
3397 static void free_sessions(void)
3398 {
3399     simple_ssl_session *sess, *tsess;
3400     for (sess = first; sess;) {
3401         OPENSSL_free(sess->id);
3402         OPENSSL_free(sess->der);
3403         tsess = sess;
3404         sess = sess->next;
3405         OPENSSL_free(tsess);
3406     }
3407     first = NULL;
3408 }