apps/s_client.c

   1 /* apps/s_client.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 2005 Nokia. All rights reserved.
 113  *
 114  * The portions of the attached software ("Contribution") is developed by
 115  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
 116  * license.
 117  *
 118  * The Contribution, originally written by Mika Kousa and Pasi Eronen of
 119  * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
 120  * support (see RFC 4279) to OpenSSL.
 121  *
 122  * No patent licenses or other rights except those expressly stated in
 123  * the OpenSSL open source license shall be deemed granted or received
 124  * expressly, by implication, estoppel, or otherwise.
 125  *
 126  * No assurances are provided by Nokia that the Contribution does not
 127  * infringe the patent or other intellectual property rights of any third
 128  * party or that the license provides you with all the necessary rights
 129  * to make use of the Contribution.
 130  *
 131  * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
 132  * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
 133  * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
 134  * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
 135  * OTHERWISE.
 136  */
 137
 138 #include <assert.h>
 139 #include <ctype.h>
 140 #include <stdio.h>
 141 #include <stdlib.h>
 142 #include <string.h>
 143 #include <openssl/e_os2.h>
 144 /*
 145  * With IPv6, it looks like Digital has mixed up the proper order of
 146  * recursive header file inclusion, resulting in the compiler complaining
 147  * that u_int isn't defined, but only if _POSIX_C_SOURCE is defined, which is
 148  * needed to have fileno() declared correctly...  So let's define u_int
 149  */
 150 #if defined(OPENSSL_SYS_VMS_DECC) && !defined(__U_INT)
 151 # define __U_INT
 152 typedef unsigned int u_int;
 153 #endif
 154
 155 #define USE_SOCKETS
 156 #include "apps.h"
 157 #include <openssl/x509.h>
 158 #include <openssl/ssl.h>
 159 #include <openssl/err.h>
 160 #include <openssl/pem.h>
 161 #include <openssl/rand.h>
 162 #include <openssl/ocsp.h>
 163 #include <openssl/bn.h>
 164 #ifndef OPENSSL_NO_SRP
 165 # include <openssl/srp.h>
 166 #endif
 167 #include "s_apps.h"
 168 #include "timeouts.h"
 169
 170 #if (defined(OPENSSL_SYS_VMS) && __VMS_VER < 70000000)
 171 /* FIONBIO used as a switch to enable ioctl, and that isn't in VMS < 7.0 */
 172 # undef FIONBIO
 173 #endif
 174
 175 #undef PROG
 176 #define PROG    s_client_main
 177
 178 /*
 179  * #define SSL_HOST_NAME "www.netscape.com"
 180  */
 181 /*
 182  * #define SSL_HOST_NAME "193.118.187.102"
 183  */
 184 #define SSL_HOST_NAME   "localhost"
 185
 186 /* no default cert. */
 187 /*
 188  * #define TEST_CERT "client.pem"
 189  */
 190
 191 #undef BUFSIZZ
 192 #define BUFSIZZ 1024*8
 193
 194 extern int verify_depth;
 195 extern int verify_error;
 196 extern int verify_return_error;
 197 extern int verify_quiet;
 198
 199 #ifdef FIONBIO
 200 static int c_nbio = 0;
 201 #endif
 202 static int c_Pause = 0;
 203 static int c_debug = 0;
 204 #ifndef OPENSSL_NO_TLSEXT
 205 static int c_tlsextdebug = 0;
 206 static int c_status_req = 0;
 207 #endif
 208 static int c_msg = 0;
 209 static int c_showcerts = 0;
 210
 211 static char *keymatexportlabel = NULL;
 212 static int keymatexportlen = 20;
 213
 214 static void sc_usage(void);
 215 static void print_stuff(BIO *berr, SSL *con, int full);
 216 #ifndef OPENSSL_NO_TLSEXT
 217 static int ocsp_resp_cb(SSL *s, void *arg);
 218 #endif
 219 static BIO *bio_c_out = NULL;
 220 static BIO *bio_c_msg = NULL;
 221 static int c_quiet = 0;
 222 static int c_ign_eof = 0;
 223 static int c_brief = 0;
 224
 225 #ifndef OPENSSL_NO_PSK
 226 /* Default PSK identity and key */
 227 static char *psk_identity = "Client_identity";
 228 /*
 229  * char *psk_key=NULL; by default PSK is not used
 230  */
 231
 232 static unsigned int psk_client_cb(SSL *ssl, const char *hint, char *identity,
 233                                   unsigned int max_identity_len,
 234                                   unsigned char *psk,
 235                                   unsigned int max_psk_len)
 236 {
 237     unsigned int psk_len = 0;
 238     int ret;
 239     BIGNUM *bn = NULL;
 240
 241     if (c_debug)
 242         BIO_printf(bio_c_out, "psk_client_cb\n");
 243     if (!hint) {
 244         /* no ServerKeyExchange message */
 245         if (c_debug)
 246             BIO_printf(bio_c_out,
 247                        "NULL received PSK identity hint, continuing anyway\n");
 248     } else if (c_debug)
 249         BIO_printf(bio_c_out, "Received PSK identity hint '%s'\n", hint);
 250
 251     /*
 252      * lookup PSK identity and PSK key based on the given identity hint here
 253      */
 254     ret = BIO_snprintf(identity, max_identity_len, "%s", psk_identity);
 255     if (ret < 0 || (unsigned int)ret > max_identity_len)
 256         goto out_err;
 257     if (c_debug)
 258         BIO_printf(bio_c_out, "created identity '%s' len=%d\n", identity,
 259                    ret);
 260     ret = BN_hex2bn(&bn, psk_key);
 261     if (!ret) {
 262         BIO_printf(bio_err, "Could not convert PSK key '%s' to BIGNUM\n",
 263                    psk_key);
 264         if (bn)
 265             BN_free(bn);
 266         return 0;
 267     }
 268
 269     if ((unsigned int)BN_num_bytes(bn) > max_psk_len) {
 270         BIO_printf(bio_err,
 271                    "psk buffer of callback is too small (%d) for key (%d)\n",
 272                    max_psk_len, BN_num_bytes(bn));
 273         BN_free(bn);
 274         return 0;
 275     }
 276
 277     psk_len = BN_bn2bin(bn, psk);
 278     BN_free(bn);
 279     if (psk_len == 0)
 280         goto out_err;
 281
 282     if (c_debug)
 283         BIO_printf(bio_c_out, "created PSK len=%d\n", psk_len);
 284
 285     return psk_len;
 286  out_err:
 287     if (c_debug)
 288         BIO_printf(bio_err, "Error in PSK client callback\n");
 289     return 0;
 290 }
 291 #endif
 292
 293 static void sc_usage(void)
 294 {
 295     BIO_printf(bio_err, "usage: s_client args\n");
 296     BIO_printf(bio_err, "\n");
 297     BIO_printf(bio_err, " -host host     - use -connect instead\n");
 298     BIO_printf(bio_err, " -port port     - use -connect instead\n");
 299     BIO_printf(bio_err,
 300                " -connect host:port - connect over TCP/IP (default is %s:%s)\n",
 301                SSL_HOST_NAME, PORT_STR);
 302     BIO_printf(bio_err,
 303                " -unix path    - connect over unix domain sockets\n");
 304     BIO_printf(bio_err,
 305                " -verify arg   - turn on peer certificate verification\n");
 306     BIO_printf(bio_err,
 307                " -verify_return_error - return verification errors\n");
 308     BIO_printf(bio_err,
 309                " -cert arg     - certificate file to use, PEM format assumed\n");
 310     BIO_printf(bio_err,
 311                " -certform arg - certificate format (PEM or DER) PEM default\n");
 312     BIO_printf(bio_err,
 313                " -key arg      - Private key file to use, in cert file if\n");
 314     BIO_printf(bio_err, "                 not specified but cert file is.\n");
 315     BIO_printf(bio_err,
 316                " -keyform arg  - key format (PEM or DER) PEM default\n");
 317     BIO_printf(bio_err,
 318                " -pass arg     - private key file pass phrase source\n");
 319     BIO_printf(bio_err, " -CApath arg   - PEM format directory of CA's\n");
 320     BIO_printf(bio_err, " -CAfile arg   - PEM format file of CA's\n");
 321     BIO_printf(bio_err,
 322                " -trusted_first - Use local CA's first when building trust chain\n");
 323     BIO_printf(bio_err,
 324                " -reconnect    - Drop and re-make the connection with the same Session-ID\n");
 325     BIO_printf(bio_err,
 326                " -pause        - sleep(1) after each read(2) and write(2) system call\n");
 327     BIO_printf(bio_err,
 328                " -prexit       - print session information even on connection failure\n");
 329     BIO_printf(bio_err,
 330                " -showcerts    - show all certificates in the chain\n");
 331     BIO_printf(bio_err, " -debug        - extra output\n");
 332 #ifdef WATT32
 333     BIO_printf(bio_err, " -wdebug       - WATT-32 tcp debugging\n");
 334 #endif
 335     BIO_printf(bio_err, " -msg          - Show protocol messages\n");
 336     BIO_printf(bio_err, " -nbio_test    - more ssl protocol testing\n");
 337     BIO_printf(bio_err, " -state        - print the 'ssl' states\n");
 338 #ifdef FIONBIO
 339     BIO_printf(bio_err, " -nbio         - Run with non-blocking IO\n");
 340 #endif
 341     BIO_printf(bio_err,
 342                " -crlf         - convert LF from terminal into CRLF\n");
 343     BIO_printf(bio_err, " -quiet        - no s_client output\n");
 344     BIO_printf(bio_err,
 345                " -ign_eof      - ignore input eof (default when -quiet)\n");
 346     BIO_printf(bio_err, " -no_ign_eof   - don't ignore input eof\n");
 347 #ifndef OPENSSL_NO_PSK
 348     BIO_printf(bio_err, " -psk_identity arg - PSK identity\n");
 349     BIO_printf(bio_err, " -psk arg      - PSK in hex (without 0x)\n");
 350 # ifndef OPENSSL_NO_JPAKE
 351     BIO_printf(bio_err, " -jpake arg    - JPAKE secret to use\n");
 352 # endif
 353 #endif
 354 #ifndef OPENSSL_NO_SRP
 355     BIO_printf(bio_err,
 356                " -srpuser user     - SRP authentification for 'user'\n");
 357     BIO_printf(bio_err, " -srppass arg      - password for 'user'\n");
 358     BIO_printf(bio_err,
 359                " -srp_lateuser     - SRP username into second ClientHello message\n");
 360     BIO_printf(bio_err,
 361                " -srp_moregroups   - Tolerate other than the known g N values.\n");
 362     BIO_printf(bio_err,
 363                " -srp_strength int - minimal length in bits for N (default %d).\n",
 364                SRP_MINIMAL_N);
 365 #endif
 366 #ifndef OPENSSL_NO_SSL3_METHOD
 367     BIO_printf(bio_err, " -ssl3         - just use SSLv3\n");
 368 #endif
 369     BIO_printf(bio_err, " -tls1_2       - just use TLSv1.2\n");
 370     BIO_printf(bio_err, " -tls1_1       - just use TLSv1.1\n");
 371     BIO_printf(bio_err, " -tls1         - just use TLSv1\n");
 372     BIO_printf(bio_err, " -dtls1        - just use DTLSv1\n");
 373     BIO_printf(bio_err, " -fallback_scsv - send TLS_FALLBACK_SCSV\n");
 374     BIO_printf(bio_err, " -mtu          - set the link layer MTU\n");
 375     BIO_printf(bio_err,
 376                " -no_tls1_2/-no_tls1_1/-no_tls1/-no_ssl3 - turn off that protocol\n");
 377     BIO_printf(bio_err,
 378                " -bugs         - Switch on all SSL implementation bug workarounds\n");
 379     BIO_printf(bio_err,
 380                " -cipher       - preferred cipher to use, use the 'openssl ciphers'\n");
 381     BIO_printf(bio_err,
 382                "                 command to see what is available\n");
 383     BIO_printf(bio_err,
 384                " -starttls prot - use the STARTTLS command before starting TLS\n");
 385     BIO_printf(bio_err,
 386                "                 for those protocols that support it, where\n");
 387     BIO_printf(bio_err,
 388                "                 'prot' defines which one to assume.  Currently,\n");
 389     BIO_printf(bio_err,
 390                "                 only \"smtp\", \"pop3\", \"imap\", \"ftp\" and \"xmpp\"\n");
 391     BIO_printf(bio_err, "                 are supported.\n");
 392     BIO_printf(bio_err,
 393                " -xmpphost host - When used with \"-starttls xmpp\" specifies the virtual host.\n");
 394 #ifndef OPENSSL_NO_ENGINE
 395     BIO_printf(bio_err,
 396                " -engine id    - Initialise and use the specified engine\n");
 397 #endif
 398     BIO_printf(bio_err, " -rand file%cfile%c...\n", LIST_SEPARATOR_CHAR,
 399                LIST_SEPARATOR_CHAR);
 400     BIO_printf(bio_err, " -sess_out arg - file to write SSL session to\n");
 401     BIO_printf(bio_err, " -sess_in arg  - file to read SSL session from\n");
 402 #ifndef OPENSSL_NO_TLSEXT
 403     BIO_printf(bio_err,
 404                " -servername host  - Set TLS extension servername in ClientHello\n");
 405     BIO_printf(bio_err,
 406                " -tlsextdebug      - hex dump of all TLS extensions received\n");
 407     BIO_printf(bio_err,
 408                " -status           - request certificate status from server\n");
 409     BIO_printf(bio_err,
 410                " -no_ticket        - disable use of RFC4507bis session tickets\n");
 411     BIO_printf(bio_err,
 412                " -serverinfo types - send empty ClientHello extensions (comma-separated numbers)\n");
 413 # ifndef OPENSSL_NO_NEXTPROTONEG
 414     BIO_printf(bio_err,
 415                " -nextprotoneg arg - enable NPN extension, considering named protocols supported (comma-separated list)\n");
 416 # endif
 417     BIO_printf(bio_err,
 418                " -alpn arg         - enable ALPN extension, considering named protocols supported (comma-separated list)\n");
 419 #endif
 420     BIO_printf(bio_err,
 421                " -legacy_renegotiation - enable use of legacy renegotiation (dangerous)\n");
 422 #ifndef OPENSSL_NO_SRTP
 423     BIO_printf(bio_err,
 424                " -use_srtp profiles - Offer SRTP key management with a colon-separated profile list\n");
 425 #endif
 426     BIO_printf(bio_err,
 427                " -keymatexport label   - Export keying material using label\n");
 428     BIO_printf(bio_err,
 429                " -keymatexportlen len  - Export len bytes of keying material (default 20)\n");
 430 }
 431
 432 #ifndef OPENSSL_NO_TLSEXT
 433
 434 /* This is a context that we pass to callbacks */
 435 typedef struct tlsextctx_st {
 436     BIO *biodebug;
 437     int ack;
 438 } tlsextctx;
 439
 440 static int ssl_servername_cb(SSL *s, int *ad, void *arg)
 441 {
 442     tlsextctx *p = (tlsextctx *) arg;
 443     const char *hn = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
 444     if (SSL_get_servername_type(s) != -1)
 445         p->ack = !SSL_session_reused(s) && hn != NULL;
 446     else
 447         BIO_printf(bio_err, "Can't use SSL_get_servername\n");
 448
 449     return SSL_TLSEXT_ERR_OK;
 450 }
 451
 452 # ifndef OPENSSL_NO_SRP
 453
 454 /* This is a context that we pass to all callbacks */
 455 typedef struct srp_arg_st {
 456     char *srppassin;
 457     char *srplogin;
 458     int msg;                    /* copy from c_msg */
 459     int debug;                  /* copy from c_debug */
 460     int amp;                    /* allow more groups */
 461     int strength /* minimal size for N */ ;
 462 } SRP_ARG;
 463
 464 #  define SRP_NUMBER_ITERATIONS_FOR_PRIME 64
 465
 466 static int srp_Verify_N_and_g(const BIGNUM *N, const BIGNUM *g)
 467 {
 468     BN_CTX *bn_ctx = BN_CTX_new();
 469     BIGNUM *p = BN_new();
 470     BIGNUM *r = BN_new();
 471     int ret =
 472         g != NULL && N != NULL && bn_ctx != NULL && BN_is_odd(N) &&
 473         BN_is_prime_ex(N, SRP_NUMBER_ITERATIONS_FOR_PRIME, bn_ctx, NULL) &&
 474         p != NULL && BN_rshift1(p, N) &&
 475         /* p = (N-1)/2 */
 476         BN_is_prime_ex(p, SRP_NUMBER_ITERATIONS_FOR_PRIME, bn_ctx, NULL) &&
 477         r != NULL &&
 478         /* verify g^((N-1)/2) == -1 (mod N) */
 479         BN_mod_exp(r, g, p, N, bn_ctx) &&
 480         BN_add_word(r, 1) && BN_cmp(r, N) == 0;
 481
 482     if (r)
 483         BN_free(r);
 484     if (p)
 485         BN_free(p);
 486     if (bn_ctx)
 487         BN_CTX_free(bn_ctx);
 488     return ret;
 489 }
 490
 491 /*-
 492  * This callback is used here for two purposes:
 493  * - extended debugging
 494  * - making some primality tests for unknown groups
 495  * The callback is only called for a non default group.
 496  *
 497  * An application does not need the call back at all if
 498  * only the stanard groups are used.  In real life situations,
 499  * client and server already share well known groups,
 500  * thus there is no need to verify them.
 501  * Furthermore, in case that a server actually proposes a group that
 502  * is not one of those defined in RFC 5054, it is more appropriate
 503  * to add the group to a static list and then compare since
 504  * primality tests are rather cpu consuming.
 505  */
 506
 507 static int ssl_srp_verify_param_cb(SSL *s, void *arg)
 508 {
 509     SRP_ARG *srp_arg = (SRP_ARG *)arg;
 510     BIGNUM *N = NULL, *g = NULL;
 511     if (!(N = SSL_get_srp_N(s)) || !(g = SSL_get_srp_g(s)))
 512         return 0;
 513     if (srp_arg->debug || srp_arg->msg || srp_arg->amp == 1) {
 514         BIO_printf(bio_err, "SRP parameters:\n");
 515         BIO_printf(bio_err, "\tN=");
 516         BN_print(bio_err, N);
 517         BIO_printf(bio_err, "\n\tg=");
 518         BN_print(bio_err, g);
 519         BIO_printf(bio_err, "\n");
 520     }
 521
 522     if (SRP_check_known_gN_param(g, N))
 523         return 1;
 524
 525     if (srp_arg->amp == 1) {
 526         if (srp_arg->debug)
 527             BIO_printf(bio_err,
 528                        "SRP param N and g are not known params, going to check deeper.\n");
 529
 530         /*
 531          * The srp_moregroups is a real debugging feature. Implementors
 532          * should rather add the value to the known ones. The minimal size
 533          * has already been tested.
 534          */
 535         if (BN_num_bits(g) <= BN_BITS && srp_Verify_N_and_g(N, g))
 536             return 1;
 537     }
 538     BIO_printf(bio_err, "SRP param N and g rejected.\n");
 539     return 0;
 540 }
 541
 542 #  define PWD_STRLEN 1024
 543
 544 static char *ssl_give_srp_client_pwd_cb(SSL *s, void *arg)
 545 {
 546     SRP_ARG *srp_arg = (SRP_ARG *)arg;
 547     char *pass = (char *)OPENSSL_malloc(PWD_STRLEN + 1);
 548     PW_CB_DATA cb_tmp;
 549     int l;
 550
 551     cb_tmp.password = (char *)srp_arg->srppassin;
 552     cb_tmp.prompt_info = "SRP user";
 553     if ((l = password_callback(pass, PWD_STRLEN, 0, &cb_tmp)) < 0) {
 554         BIO_printf(bio_err, "Can't read Password\n");
 555         OPENSSL_free(pass);
 556         return NULL;
 557     }
 558     *(pass + l) = '\0';
 559
 560     return pass;
 561 }
 562
 563 # endif
 564 # ifndef OPENSSL_NO_SRTP
 565 char *srtp_profiles = NULL;
 566 # endif
 567
 568 # ifndef OPENSSL_NO_NEXTPROTONEG
 569 /* This the context that we pass to next_proto_cb */
 570 typedef struct tlsextnextprotoctx_st {
 571     unsigned char *data;
 572     unsigned short len;
 573     int status;
 574 } tlsextnextprotoctx;
 575
 576 static tlsextnextprotoctx next_proto;
 577
 578 static int next_proto_cb(SSL *s, unsigned char **out, unsigned char *outlen,
 579                          const unsigned char *in, unsigned int inlen,
 580                          void *arg)
 581 {
 582     tlsextnextprotoctx *ctx = arg;
 583
 584     if (!c_quiet) {
 585         /* We can assume that |in| is syntactically valid. */
 586         unsigned i;
 587         BIO_printf(bio_c_out, "Protocols advertised by server: ");
 588         for (i = 0; i < inlen;) {
 589             if (i)
 590                 BIO_write(bio_c_out, ", ", 2);
 591             BIO_write(bio_c_out, &in[i + 1], in[i]);
 592             i += in[i] + 1;
 593         }
 594         BIO_write(bio_c_out, "\n", 1);
 595     }
 596
 597     ctx->status =
 598         SSL_select_next_proto(out, outlen, in, inlen, ctx->data, ctx->len);
 599     return SSL_TLSEXT_ERR_OK;
 600 }
 601 # endif                         /* ndef OPENSSL_NO_NEXTPROTONEG */
 602
 603 static int serverinfo_cli_parse_cb(SSL *s, unsigned int ext_type,
 604                                    const unsigned char *in, size_t inlen,
 605                                    int *al, void *arg)
 606 {
 607     char pem_name[100];
 608     unsigned char ext_buf[4 + 65536];
 609
 610     /* Reconstruct the type/len fields prior to extension data */
 611     ext_buf[0] = ext_type >> 8;
 612     ext_buf[1] = ext_type & 0xFF;
 613     ext_buf[2] = inlen >> 8;
 614     ext_buf[3] = inlen & 0xFF;
 615     memcpy(ext_buf + 4, in, inlen);
 616
 617     BIO_snprintf(pem_name, sizeof(pem_name), "SERVERINFO FOR EXTENSION %d",
 618                  ext_type);
 619     PEM_write_bio(bio_c_out, pem_name, "", ext_buf, 4 + inlen);
 620     return 1;
 621 }
 622
 623 #endif
 624
 625 enum {
 626     PROTO_OFF = 0,
 627     PROTO_SMTP,
 628     PROTO_POP3,
 629     PROTO_IMAP,
 630     PROTO_FTP,
 631     PROTO_XMPP
 632 };
 633
 634 int MAIN(int, char **);
 635
 636 int MAIN(int argc, char **argv)
 637 {
 638     int build_chain = 0;
 639     SSL *con = NULL;
 640 #ifndef OPENSSL_NO_KRB5
 641     KSSL_CTX *kctx;
 642 #endif
 643     int s, k, width, state = 0;
 644     char *cbuf = NULL, *sbuf = NULL, *mbuf = NULL;
 645     int cbuf_len, cbuf_off;
 646     int sbuf_len, sbuf_off;
 647     fd_set readfds, writefds;
 648     short port = PORT;
 649     int full_log = 1;
 650     char *host = SSL_HOST_NAME;
 651     const char *unix_path = NULL;
 652     char *xmpphost = NULL;
 653     char *cert_file = NULL, *key_file = NULL, *chain_file = NULL;
 654     int cert_format = FORMAT_PEM, key_format = FORMAT_PEM;
 655     char *passarg = NULL, *pass = NULL;
 656     X509 *cert = NULL;
 657     EVP_PKEY *key = NULL;
 658     STACK_OF(X509) *chain = NULL;
 659     char *CApath = NULL, *CAfile = NULL;
 660     char *chCApath = NULL, *chCAfile = NULL;
 661     char *vfyCApath = NULL, *vfyCAfile = NULL;
 662     int reconnect = 0, badop = 0, verify = SSL_VERIFY_NONE;
 663     int crlf = 0;
 664     int write_tty, read_tty, write_ssl, read_ssl, tty_on, ssl_pending;
 665     SSL_CTX *ctx = NULL;
 666     int ret = 1, in_init = 1, i, nbio_test = 0;
 667     int starttls_proto = PROTO_OFF;
 668     int prexit = 0;
 669     X509_VERIFY_PARAM *vpm = NULL;
 670     int badarg = 0;
 671     const SSL_METHOD *meth = NULL;
 672     int socket_type = SOCK_STREAM;
 673     BIO *sbio;
 674     char *inrand = NULL;
 675     int mbuf_len = 0;
 676     struct timeval timeout, *timeoutp;
 677 #ifndef OPENSSL_NO_ENGINE
 678     char *engine_id = NULL;
 679     char *ssl_client_engine_id = NULL;
 680     ENGINE *ssl_client_engine = NULL;
 681 #endif
 682     ENGINE *e = NULL;
 683 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE)
 684     struct timeval tv;
 685 #endif
 686 #ifndef OPENSSL_NO_TLSEXT
 687     char *servername = NULL;
 688     tlsextctx tlsextcbp = { NULL, 0 };
 689 # ifndef OPENSSL_NO_NEXTPROTONEG
 690     const char *next_proto_neg_in = NULL;
 691 # endif
 692     const char *alpn_in = NULL;
 693 # define MAX_SI_TYPES 100
 694     unsigned short serverinfo_types[MAX_SI_TYPES];
 695     int serverinfo_types_count = 0;
 696 #endif
 697     char *sess_in = NULL;
 698     char *sess_out = NULL;
 699     struct sockaddr peer;
 700     int peerlen = sizeof(peer);
 701     int fallback_scsv = 0;
 702     int enable_timeouts = 0;
 703     long socket_mtu = 0;
 704 #ifndef OPENSSL_NO_JPAKE
 705     static char *jpake_secret = NULL;
 706 # define no_jpake !jpake_secret
 707 #else
 708 # define no_jpake 1
 709 #endif
 710 #ifndef OPENSSL_NO_SRP
 711     char *srppass = NULL;
 712     int srp_lateuser = 0;
 713     SRP_ARG srp_arg = { NULL, NULL, 0, 0, 0, 1024 };
 714 #endif
 715     SSL_EXCERT *exc = NULL;
 716
 717     SSL_CONF_CTX *cctx = NULL;
 718     STACK_OF(OPENSSL_STRING) *ssl_args = NULL;
 719
 720     char *crl_file = NULL;
 721     int crl_format = FORMAT_PEM;
 722     int crl_download = 0;
 723     STACK_OF(X509_CRL) *crls = NULL;
 724     int sdebug = 0;
 725
 726     meth = SSLv23_client_method();
 727
 728     apps_startup();
 729     c_Pause = 0;
 730     c_quiet = 0;
 731     c_ign_eof = 0;
 732     c_debug = 0;
 733     c_msg = 0;
 734     c_showcerts = 0;
 735
 736     if (bio_err == NULL)
 737         bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);
 738
 739     if (!load_config(bio_err, NULL))
 740         goto end;
 741     cctx = SSL_CONF_CTX_new();
 742     if (!cctx)
 743         goto end;
 744     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CLIENT);
 745     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CMDLINE);
 746
 747     if (((cbuf = OPENSSL_malloc(BUFSIZZ)) == NULL) ||
 748         ((sbuf = OPENSSL_malloc(BUFSIZZ)) == NULL) ||
 749         ((mbuf = OPENSSL_malloc(BUFSIZZ)) == NULL)) {
 750         BIO_printf(bio_err, "out of memory\n");
 751         goto end;
 752     }
 753
 754     verify_depth = 0;
 755     verify_error = X509_V_OK;
 756 #ifdef FIONBIO
 757     c_nbio = 0;
 758 #endif
 759
 760     argc--;
 761     argv++;
 762     while (argc >= 1) {
 763         if (strcmp(*argv, "-host") == 0) {
 764             if (--argc < 1)
 765                 goto bad;
 766             host = *(++argv);
 767         } else if (strcmp(*argv, "-port") == 0) {
 768             if (--argc < 1)
 769                 goto bad;
 770             port = atoi(*(++argv));
 771             if (port == 0)
 772                 goto bad;
 773         } else if (strcmp(*argv, "-connect") == 0) {
 774             if (--argc < 1)
 775                 goto bad;
 776             if (!extract_host_port(*(++argv), &host, NULL, &port))
 777                 goto bad;
 778         } else if (strcmp(*argv, "-unix") == 0) {
 779             if (--argc < 1)
 780                 goto bad;
 781             unix_path = *(++argv);
 782         } else if (strcmp(*argv, "-xmpphost") == 0) {
 783             if (--argc < 1)
 784                 goto bad;
 785             xmpphost = *(++argv);
 786         } else if (strcmp(*argv, "-verify") == 0) {
 787             verify = SSL_VERIFY_PEER;
 788             if (--argc < 1)
 789                 goto bad;
 790             verify_depth = atoi(*(++argv));
 791             if (!c_quiet)
 792                 BIO_printf(bio_err, "verify depth is %d\n", verify_depth);
 793         } else if (strcmp(*argv, "-cert") == 0) {
 794             if (--argc < 1)
 795                 goto bad;
 796             cert_file = *(++argv);
 797         } else if (strcmp(*argv, "-CRL") == 0) {
 798             if (--argc < 1)
 799                 goto bad;
 800             crl_file = *(++argv);
 801         } else if (strcmp(*argv, "-crl_download") == 0)
 802             crl_download = 1;
 803         else if (strcmp(*argv, "-sess_out") == 0) {
 804             if (--argc < 1)
 805                 goto bad;
 806             sess_out = *(++argv);
 807         } else if (strcmp(*argv, "-sess_in") == 0) {
 808             if (--argc < 1)
 809                 goto bad;
 810             sess_in = *(++argv);
 811         } else if (strcmp(*argv, "-certform") == 0) {
 812             if (--argc < 1)
 813                 goto bad;
 814             cert_format = str2fmt(*(++argv));
 815         } else if (strcmp(*argv, "-CRLform") == 0) {
 816             if (--argc < 1)
 817                 goto bad;
 818             crl_format = str2fmt(*(++argv));
 819         } else if (args_verify(&argv, &argc, &badarg, bio_err, &vpm)) {
 820             if (badarg)
 821                 goto bad;
 822             continue;
 823         } else if (strcmp(*argv, "-verify_return_error") == 0)
 824             verify_return_error = 1;
 825         else if (strcmp(*argv, "-verify_quiet") == 0)
 826             verify_quiet = 1;
 827         else if (strcmp(*argv, "-brief") == 0) {
 828             c_brief = 1;
 829             verify_quiet = 1;
 830             c_quiet = 1;
 831         } else if (args_excert(&argv, &argc, &badarg, bio_err, &exc)) {
 832             if (badarg)
 833                 goto bad;
 834             continue;
 835         } else if (args_ssl(&argv, &argc, cctx, &badarg, bio_err, &ssl_args)) {
 836             if (badarg)
 837                 goto bad;
 838             continue;
 839         } else if (strcmp(*argv, "-prexit") == 0)
 840             prexit = 1;
 841         else if (strcmp(*argv, "-crlf") == 0)
 842             crlf = 1;
 843         else if (strcmp(*argv, "-quiet") == 0) {
 844             c_quiet = 1;
 845             c_ign_eof = 1;
 846         } else if (strcmp(*argv, "-ign_eof") == 0)
 847             c_ign_eof = 1;
 848         else if (strcmp(*argv, "-no_ign_eof") == 0)
 849             c_ign_eof = 0;
 850         else if (strcmp(*argv, "-pause") == 0)
 851             c_Pause = 1;
 852         else if (strcmp(*argv, "-debug") == 0)
 853             c_debug = 1;
 854 #ifndef OPENSSL_NO_TLSEXT
 855         else if (strcmp(*argv, "-tlsextdebug") == 0)
 856             c_tlsextdebug = 1;
 857         else if (strcmp(*argv, "-status") == 0)
 858             c_status_req = 1;
 859 #endif
 860 #ifdef WATT32
 861         else if (strcmp(*argv, "-wdebug") == 0)
 862             dbug_init();
 863 #endif
 864         else if (strcmp(*argv, "-msg") == 0)
 865             c_msg = 1;
 866         else if (strcmp(*argv, "-msgfile") == 0) {
 867             if (--argc < 1)
 868                 goto bad;
 869             bio_c_msg = BIO_new_file(*(++argv), "w");
 870         }
 871 #ifndef OPENSSL_NO_SSL_TRACE
 872         else if (strcmp(*argv, "-trace") == 0)
 873             c_msg = 2;
 874 #endif
 875         else if (strcmp(*argv, "-security_debug") == 0) {
 876             sdebug = 1;
 877         } else if (strcmp(*argv, "-security_debug_verbose") == 0) {
 878             sdebug = 2;
 879         } else if (strcmp(*argv, "-showcerts") == 0)
 880             c_showcerts = 1;
 881         else if (strcmp(*argv, "-nbio_test") == 0)
 882             nbio_test = 1;
 883         else if (strcmp(*argv, "-state") == 0)
 884             state = 1;
 885 #ifndef OPENSSL_NO_PSK
 886         else if (strcmp(*argv, "-psk_identity") == 0) {
 887             if (--argc < 1)
 888                 goto bad;
 889             psk_identity = *(++argv);
 890         } else if (strcmp(*argv, "-psk") == 0) {
 891             size_t j;
 892
 893             if (--argc < 1)
 894                 goto bad;
 895             psk_key = *(++argv);
 896             for (j = 0; j < strlen(psk_key); j++) {
 897                 if (isxdigit((unsigned char)psk_key[j]))
 898                     continue;
 899                 BIO_printf(bio_err, "Not a hex number '%s'\n", *argv);
 900                 goto bad;
 901             }
 902         }
 903 #endif
 904 #ifndef OPENSSL_NO_SRP
 905         else if (strcmp(*argv, "-srpuser") == 0) {
 906             if (--argc < 1)
 907                 goto bad;
 908             srp_arg.srplogin = *(++argv);
 909             meth = TLSv1_client_method();
 910         } else if (strcmp(*argv, "-srppass") == 0) {
 911             if (--argc < 1)
 912                 goto bad;
 913             srppass = *(++argv);
 914             meth = TLSv1_client_method();
 915         } else if (strcmp(*argv, "-srp_strength") == 0) {
 916             if (--argc < 1)
 917                 goto bad;
 918             srp_arg.strength = atoi(*(++argv));
 919             BIO_printf(bio_err, "SRP minimal length for N is %d\n",
 920                        srp_arg.strength);
 921             meth = TLSv1_client_method();
 922         } else if (strcmp(*argv, "-srp_lateuser") == 0) {
 923             srp_lateuser = 1;
 924             meth = TLSv1_client_method();
 925         } else if (strcmp(*argv, "-srp_moregroups") == 0) {
 926             srp_arg.amp = 1;
 927             meth = TLSv1_client_method();
 928         }
 929 #endif
 930 #ifndef OPENSSL_NO_SSL3_METHOD
 931         else if (strcmp(*argv, "-ssl3") == 0)
 932             meth = SSLv3_client_method();
 933 #endif
 934         else if (strcmp(*argv, "-tls1_2") == 0)
 935             meth = TLSv1_2_client_method();
 936         else if (strcmp(*argv, "-tls1_1") == 0)
 937             meth = TLSv1_1_client_method();
 938         else if (strcmp(*argv, "-tls1") == 0)
 939             meth = TLSv1_client_method();
 940 #ifndef OPENSSL_NO_DTLS1
 941         else if (strcmp(*argv, "-dtls") == 0) {
 942             meth = DTLS_client_method();
 943             socket_type = SOCK_DGRAM;
 944         } else if (strcmp(*argv, "-dtls1") == 0) {
 945             meth = DTLSv1_client_method();
 946             socket_type = SOCK_DGRAM;
 947         } else if (strcmp(*argv, "-dtls1_2") == 0) {
 948             meth = DTLSv1_2_client_method();
 949             socket_type = SOCK_DGRAM;
 950         } else if (strcmp(*argv, "-timeout") == 0)
 951             enable_timeouts = 1;
 952         else if (strcmp(*argv, "-mtu") == 0) {
 953             if (--argc < 1)
 954                 goto bad;
 955             socket_mtu = atol(*(++argv));
 956         }
 957 #endif
 958         else if (strcmp(*argv, "-fallback_scsv") == 0) {
 959             fallback_scsv = 1;
 960         } else if (strcmp(*argv, "-keyform") == 0) {
 961             if (--argc < 1)
 962                 goto bad;
 963             key_format = str2fmt(*(++argv));
 964         } else if (strcmp(*argv, "-pass") == 0) {
 965             if (--argc < 1)
 966                 goto bad;
 967             passarg = *(++argv);
 968         } else if (strcmp(*argv, "-cert_chain") == 0) {
 969             if (--argc < 1)
 970                 goto bad;
 971             chain_file = *(++argv);
 972         } else if (strcmp(*argv, "-key") == 0) {
 973             if (--argc < 1)
 974                 goto bad;
 975             key_file = *(++argv);
 976         } else if (strcmp(*argv, "-reconnect") == 0) {
 977             reconnect = 5;
 978         } else if (strcmp(*argv, "-CApath") == 0) {
 979             if (--argc < 1)
 980                 goto bad;
 981             CApath = *(++argv);
 982         } else if (strcmp(*argv, "-chainCApath") == 0) {
 983             if (--argc < 1)
 984                 goto bad;
 985             chCApath = *(++argv);
 986         } else if (strcmp(*argv, "-verifyCApath") == 0) {
 987             if (--argc < 1)
 988                 goto bad;
 989             vfyCApath = *(++argv);
 990         } else if (strcmp(*argv, "-build_chain") == 0)
 991             build_chain = 1;
 992         else if (strcmp(*argv, "-CAfile") == 0) {
 993             if (--argc < 1)
 994                 goto bad;
 995             CAfile = *(++argv);
 996         } else if (strcmp(*argv, "-chainCAfile") == 0) {
 997             if (--argc < 1)
 998                 goto bad;
 999             chCAfile = *(++argv);
1000         } else if (strcmp(*argv, "-verifyCAfile") == 0) {
1001             if (--argc < 1)
1002                 goto bad;
1003             vfyCAfile = *(++argv);
1004         }
1005 #ifndef OPENSSL_NO_TLSEXT
1006 # ifndef OPENSSL_NO_NEXTPROTONEG
1007         else if (strcmp(*argv, "-nextprotoneg") == 0) {
1008             if (--argc < 1)
1009                 goto bad;
1010             next_proto_neg_in = *(++argv);
1011         }
1012 # endif
1013         else if (strcmp(*argv, "-alpn") == 0) {
1014             if (--argc < 1)
1015                 goto bad;
1016             alpn_in = *(++argv);
1017         } else if (strcmp(*argv, "-serverinfo") == 0) {
1018             char *c;
1019             int start = 0;
1020             int len;
1021
1022             if (--argc < 1)
1023                 goto bad;
1024             c = *(++argv);
1025             serverinfo_types_count = 0;
1026             len = strlen(c);
1027             for (i = 0; i <= len; ++i) {
1028                 if (i == len || c[i] == ',') {
1029                     serverinfo_types[serverinfo_types_count]
1030                         = atoi(c + start);
1031                     serverinfo_types_count++;
1032                     start = i + 1;
1033                 }
1034                 if (serverinfo_types_count == MAX_SI_TYPES)
1035                     break;
1036             }
1037         }
1038 #endif
1039 #ifdef FIONBIO
1040         else if (strcmp(*argv, "-nbio") == 0) {
1041             c_nbio = 1;
1042         }
1043 #endif
1044         else if (strcmp(*argv, "-starttls") == 0) {
1045             if (--argc < 1)
1046                 goto bad;
1047             ++argv;
1048             if (strcmp(*argv, "smtp") == 0)
1049                 starttls_proto = PROTO_SMTP;
1050             else if (strcmp(*argv, "pop3") == 0)
1051                 starttls_proto = PROTO_POP3;
1052             else if (strcmp(*argv, "imap") == 0)
1053                 starttls_proto = PROTO_IMAP;
1054             else if (strcmp(*argv, "ftp") == 0)
1055                 starttls_proto = PROTO_FTP;
1056             else if (strcmp(*argv, "xmpp") == 0)
1057                 starttls_proto = PROTO_XMPP;
1058             else
1059                 goto bad;
1060         }
1061 #ifndef OPENSSL_NO_ENGINE
1062         else if (strcmp(*argv, "-engine") == 0) {
1063             if (--argc < 1)
1064                 goto bad;
1065             engine_id = *(++argv);
1066         } else if (strcmp(*argv, "-ssl_client_engine") == 0) {
1067             if (--argc < 1)
1068                 goto bad;
1069             ssl_client_engine_id = *(++argv);
1070         }
1071 #endif
1072         else if (strcmp(*argv, "-rand") == 0) {
1073             if (--argc < 1)
1074                 goto bad;
1075             inrand = *(++argv);
1076         }
1077 #ifndef OPENSSL_NO_TLSEXT
1078         else if (strcmp(*argv, "-servername") == 0) {
1079             if (--argc < 1)
1080                 goto bad;
1081             servername = *(++argv);
1082             /* meth=TLSv1_client_method(); */
1083         }
1084 #endif
1085 #ifndef OPENSSL_NO_JPAKE
1086         else if (strcmp(*argv, "-jpake") == 0) {
1087             if (--argc < 1)
1088                 goto bad;
1089             jpake_secret = *++argv;
1090         }
1091 #endif
1092 #ifndef OPENSSL_NO_SRTP
1093         else if (strcmp(*argv, "-use_srtp") == 0) {
1094             if (--argc < 1)
1095                 goto bad;
1096             srtp_profiles = *(++argv);
1097         }
1098 #endif
1099         else if (strcmp(*argv, "-keymatexport") == 0) {
1100             if (--argc < 1)
1101                 goto bad;
1102             keymatexportlabel = *(++argv);
1103         } else if (strcmp(*argv, "-keymatexportlen") == 0) {
1104             if (--argc < 1)
1105                 goto bad;
1106             keymatexportlen = atoi(*(++argv));
1107             if (keymatexportlen == 0)
1108                 goto bad;
1109         } else {
1110             BIO_printf(bio_err, "unknown option %s\n", *argv);
1111             badop = 1;
1112             break;
1113         }
1114         argc--;
1115         argv++;
1116     }
1117     if (badop) {
1118  bad:
1119         sc_usage();
1120         goto end;
1121     }
1122
1123     if (unix_path && (socket_type != SOCK_STREAM)) {
1124         BIO_printf(bio_err,
1125                    "Can't use unix sockets and datagrams together\n");
1126         goto end;
1127     }
1128 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
1129     if (jpake_secret) {
1130         if (psk_key) {
1131             BIO_printf(bio_err, "Can't use JPAKE and PSK together\n");
1132             goto end;
1133         }
1134         psk_identity = "JPAKE";
1135     }
1136 #endif
1137
1138     OpenSSL_add_ssl_algorithms();
1139     SSL_load_error_strings();
1140
1141 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
1142     next_proto.status = -1;
1143     if (next_proto_neg_in) {
1144         next_proto.data =
1145             next_protos_parse(&next_proto.len, next_proto_neg_in);
1146         if (next_proto.data == NULL) {
1147             BIO_printf(bio_err, "Error parsing -nextprotoneg argument\n");
1148             goto end;
1149         }
1150     } else
1151         next_proto.data = NULL;
1152 #endif
1153
1154 #ifndef OPENSSL_NO_ENGINE
1155     e = setup_engine(bio_err, engine_id, 1);
1156     if (ssl_client_engine_id) {
1157         ssl_client_engine = ENGINE_by_id(ssl_client_engine_id);
1158         if (!ssl_client_engine) {
1159             BIO_printf(bio_err, "Error getting client auth engine\n");
1160             goto end;
1161         }
1162     }
1163 #endif
1164     if (!app_passwd(bio_err, passarg, NULL, &pass, NULL)) {
1165         BIO_printf(bio_err, "Error getting password\n");
1166         goto end;
1167     }
1168
1169     if (key_file == NULL)
1170         key_file = cert_file;
1171
1172     if (key_file) {
1173
1174         key = load_key(bio_err, key_file, key_format, 0, pass, e,
1175                        "client certificate private key file");
1176         if (!key) {
1177             ERR_print_errors(bio_err);
1178             goto end;
1179         }
1180
1181     }
1182
1183     if (cert_file) {
1184         cert = load_cert(bio_err, cert_file, cert_format,
1185                          NULL, e, "client certificate file");
1186
1187         if (!cert) {
1188             ERR_print_errors(bio_err);
1189             goto end;
1190         }
1191     }
1192
1193     if (chain_file) {
1194         chain = load_certs(bio_err, chain_file, FORMAT_PEM,
1195                            NULL, e, "client certificate chain");
1196         if (!chain)
1197             goto end;
1198     }
1199
1200     if (crl_file) {
1201         X509_CRL *crl;
1202         crl = load_crl(crl_file, crl_format);
1203         if (!crl) {
1204             BIO_puts(bio_err, "Error loading CRL\n");
1205             ERR_print_errors(bio_err);
1206             goto end;
1207         }
1208         crls = sk_X509_CRL_new_null();
1209         if (!crls || !sk_X509_CRL_push(crls, crl)) {
1210             BIO_puts(bio_err, "Error adding CRL\n");
1211             ERR_print_errors(bio_err);
1212             X509_CRL_free(crl);
1213             goto end;
1214         }
1215     }
1216
1217     if (!load_excert(&exc, bio_err))
1218         goto end;
1219
1220     if (!app_RAND_load_file(NULL, bio_err, 1) && inrand == NULL
1221         && !RAND_status()) {
1222         BIO_printf(bio_err,
1223                    "warning, not much extra random data, consider using the -rand option\n");
1224     }
1225     if (inrand != NULL)
1226         BIO_printf(bio_err, "%ld semi-random bytes loaded\n",
1227                    app_RAND_load_files(inrand));
1228
1229     if (bio_c_out == NULL) {
1230         if (c_quiet && !c_debug) {
1231             bio_c_out = BIO_new(BIO_s_null());
1232             if (c_msg && !bio_c_msg)
1233                 bio_c_msg = BIO_new_fp(stdout, BIO_NOCLOSE);
1234         } else {
1235             if (bio_c_out == NULL)
1236                 bio_c_out = BIO_new_fp(stdout, BIO_NOCLOSE);
1237         }
1238     }
1239 #ifndef OPENSSL_NO_SRP
1240     if (!app_passwd(bio_err, srppass, NULL, &srp_arg.srppassin, NULL)) {
1241         BIO_printf(bio_err, "Error getting password\n");
1242         goto end;
1243     }
1244 #endif
1245
1246     ctx = SSL_CTX_new(meth);
1247     if (ctx == NULL) {
1248         ERR_print_errors(bio_err);
1249         goto end;
1250     }
1251
1252     if (sdebug)
1253         ssl_ctx_security_debug(ctx, bio_err, sdebug);
1254
1255     if (vpm)
1256         SSL_CTX_set1_param(ctx, vpm);
1257
1258     if (!args_ssl_call(ctx, bio_err, cctx, ssl_args, 1, no_jpake)) {
1259         ERR_print_errors(bio_err);
1260         goto end;
1261     }
1262
1263     if (!ssl_load_stores(ctx, vfyCApath, vfyCAfile, chCApath, chCAfile,
1264                          crls, crl_download)) {
1265         BIO_printf(bio_err, "Error loading store locations\n");
1266         ERR_print_errors(bio_err);
1267         goto end;
1268     }
1269 #ifndef OPENSSL_NO_ENGINE
1270     if (ssl_client_engine) {
1271         if (!SSL_CTX_set_client_cert_engine(ctx, ssl_client_engine)) {
1272             BIO_puts(bio_err, "Error setting client auth engine\n");
1273             ERR_print_errors(bio_err);
1274             ENGINE_free(ssl_client_engine);
1275             goto end;
1276         }
1277         ENGINE_free(ssl_client_engine);
1278     }
1279 #endif
1280
1281 #ifndef OPENSSL_NO_PSK
1282 # ifdef OPENSSL_NO_JPAKE
1283     if (psk_key != NULL)
1284 # else
1285     if (psk_key != NULL || jpake_secret)
1286 # endif
1287     {
1288         if (c_debug)
1289             BIO_printf(bio_c_out,
1290                        "PSK key given or JPAKE in use, setting client callback\n");
1291         SSL_CTX_set_psk_client_callback(ctx, psk_client_cb);
1292     }
1293 #endif
1294 #ifndef OPENSSL_NO_SRTP
1295     if (srtp_profiles != NULL)
1296         SSL_CTX_set_tlsext_use_srtp(ctx, srtp_profiles);
1297 #endif
1298     if (exc)
1299         ssl_ctx_set_excert(ctx, exc);
1300
1301 #if !defined(OPENSSL_NO_TLSEXT)
1302 # if !defined(OPENSSL_NO_NEXTPROTONEG)
1303     if (next_proto.data)
1304         SSL_CTX_set_next_proto_select_cb(ctx, next_proto_cb, &next_proto);
1305 # endif
1306     if (alpn_in) {
1307         unsigned short alpn_len;
1308         unsigned char *alpn = next_protos_parse(&alpn_len, alpn_in);
1309
1310         if (alpn == NULL) {
1311             BIO_printf(bio_err, "Error parsing -alpn argument\n");
1312             goto end;
1313         }
1314         SSL_CTX_set_alpn_protos(ctx, alpn, alpn_len);
1315         OPENSSL_free(alpn);
1316     }
1317 #endif
1318 #ifndef OPENSSL_NO_TLSEXT
1319     for (i = 0; i < serverinfo_types_count; i++) {
1320         SSL_CTX_add_client_custom_ext(ctx,
1321                                       serverinfo_types[i],
1322                                       NULL, NULL, NULL,
1323                                       serverinfo_cli_parse_cb, NULL);
1324     }
1325 #endif
1326
1327     if (state)
1328         SSL_CTX_set_info_callback(ctx, apps_ssl_info_callback);
1329 #if 0
1330     else
1331         SSL_CTX_set_cipher_list(ctx, getenv("SSL_CIPHER"));
1332 #endif
1333
1334     SSL_CTX_set_verify(ctx, verify, verify_callback);
1335
1336     if ((!SSL_CTX_load_verify_locations(ctx, CAfile, CApath)) ||
1337         (!SSL_CTX_set_default_verify_paths(ctx))) {
1338         /*
1339          * BIO_printf(bio_err,"error setting default verify locations\n");
1340          */
1341         ERR_print_errors(bio_err);
1342         /* goto end; */
1343     }
1344
1345     ssl_ctx_add_crls(ctx, crls, crl_download);
1346
1347     if (!set_cert_key_stuff(ctx, cert, key, chain, build_chain))
1348         goto end;
1349
1350 #ifndef OPENSSL_NO_TLSEXT
1351     if (servername != NULL) {
1352         tlsextcbp.biodebug = bio_err;
1353         SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
1354         SSL_CTX_set_tlsext_servername_arg(ctx, &tlsextcbp);
1355     }
1356 # ifndef OPENSSL_NO_SRP
1357     if (srp_arg.srplogin) {
1358         if (!srp_lateuser && !SSL_CTX_set_srp_username(ctx, srp_arg.srplogin)) {
1359             BIO_printf(bio_err, "Unable to set SRP username\n");
1360             goto end;
1361         }
1362         srp_arg.msg = c_msg;
1363         srp_arg.debug = c_debug;
1364         SSL_CTX_set_srp_cb_arg(ctx, &srp_arg);
1365         SSL_CTX_set_srp_client_pwd_callback(ctx, ssl_give_srp_client_pwd_cb);
1366         SSL_CTX_set_srp_strength(ctx, srp_arg.strength);
1367         if (c_msg || c_debug || srp_arg.amp == 0)
1368             SSL_CTX_set_srp_verify_param_callback(ctx,
1369                                                   ssl_srp_verify_param_cb);
1370     }
1371 # endif
1372 #endif
1373
1374     con = SSL_new(ctx);
1375     if (sess_in) {
1376         SSL_SESSION *sess;
1377         BIO *stmp = BIO_new_file(sess_in, "r");
1378         if (!stmp) {
1379             BIO_printf(bio_err, "Can't open session file %s\n", sess_in);
1380             ERR_print_errors(bio_err);
1381             goto end;
1382         }
1383         sess = PEM_read_bio_SSL_SESSION(stmp, NULL, 0, NULL);
1384         BIO_free(stmp);
1385         if (!sess) {
1386             BIO_printf(bio_err, "Can't open session file %s\n", sess_in);
1387             ERR_print_errors(bio_err);
1388             goto end;
1389         }
1390         SSL_set_session(con, sess);
1391         SSL_SESSION_free(sess);
1392     }
1393
1394     if (fallback_scsv)
1395         SSL_set_mode(con, SSL_MODE_SEND_FALLBACK_SCSV);
1396
1397 #ifndef OPENSSL_NO_TLSEXT
1398     if (servername != NULL) {
1399         if (!SSL_set_tlsext_host_name(con, servername)) {
1400             BIO_printf(bio_err, "Unable to set TLS servername extension.\n");
1401             ERR_print_errors(bio_err);
1402             goto end;
1403         }
1404     }
1405 #endif
1406 #ifndef OPENSSL_NO_KRB5
1407     if (con && (kctx = kssl_ctx_new()) != NULL) {
1408         SSL_set0_kssl_ctx(con, kctx);
1409         kssl_ctx_setstring(kctx, KSSL_SERVER, host);
1410     }
1411 #endif                          /* OPENSSL_NO_KRB5 */
1412
1413  re_start:
1414 #ifdef NO_SYS_UN_H
1415     if (init_client(&s, host, port, socket_type) == 0)
1416 #else
1417     if ((!unix_path && (init_client(&s, host, port, socket_type) == 0)) ||
1418         (unix_path && (init_client_unix(&s, unix_path) == 0)))
1419 #endif
1420     {
1421         BIO_printf(bio_err, "connect:errno=%d\n", get_last_socket_error());
1422         SHUTDOWN(s);
1423         goto end;
1424     }
1425     BIO_printf(bio_c_out, "CONNECTED(%08X)\n", s);
1426
1427 #ifdef FIONBIO
1428     if (c_nbio) {
1429         unsigned long l = 1;
1430         BIO_printf(bio_c_out, "turning on non blocking io\n");
1431         if (BIO_socket_ioctl(s, FIONBIO, &l) < 0) {
1432             ERR_print_errors(bio_err);
1433             goto end;
1434         }
1435     }
1436 #endif
1437     if (c_Pause & 0x01)
1438         SSL_set_debug(con, 1);
1439
1440     if (socket_type == SOCK_DGRAM) {
1441
1442         sbio = BIO_new_dgram(s, BIO_NOCLOSE);
1443         if (getsockname(s, &peer, (void *)&peerlen) < 0) {
1444             BIO_printf(bio_err, "getsockname:errno=%d\n",
1445                        get_last_socket_error());
1446             SHUTDOWN(s);
1447             goto end;
1448         }
1449
1450         (void)BIO_ctrl_set_connected(sbio, 1, &peer);
1451
1452         if (enable_timeouts) {
1453             timeout.tv_sec = 0;
1454             timeout.tv_usec = DGRAM_RCV_TIMEOUT;
1455             BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout);
1456
1457             timeout.tv_sec = 0;
1458             timeout.tv_usec = DGRAM_SND_TIMEOUT;
1459             BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_SEND_TIMEOUT, 0, &timeout);
1460         }
1461
1462         if (socket_mtu) {
1463             if (socket_mtu < DTLS_get_link_min_mtu(con)) {
1464                 BIO_printf(bio_err, "MTU too small. Must be at least %ld\n",
1465                            DTLS_get_link_min_mtu(con));
1466                 BIO_free(sbio);
1467                 goto shut;
1468             }
1469             SSL_set_options(con, SSL_OP_NO_QUERY_MTU);
1470             if (!DTLS_set_link_mtu(con, socket_mtu)) {
1471                 BIO_printf(bio_err, "Failed to set MTU\n");
1472                 BIO_free(sbio);
1473                 goto shut;
1474             }
1475         } else
1476             /* want to do MTU discovery */
1477             BIO_ctrl(sbio, BIO_CTRL_DGRAM_MTU_DISCOVER, 0, NULL);
1478     } else
1479         sbio = BIO_new_socket(s, BIO_NOCLOSE);
1480
1481     if (nbio_test) {
1482         BIO *test;
1483
1484         test = BIO_new(BIO_f_nbio_test());
1485         sbio = BIO_push(test, sbio);
1486     }
1487
1488     if (c_debug) {
1489         SSL_set_debug(con, 1);
1490         BIO_set_callback(sbio, bio_dump_callback);
1491         BIO_set_callback_arg(sbio, (char *)bio_c_out);
1492     }
1493     if (c_msg) {
1494 #ifndef OPENSSL_NO_SSL_TRACE
1495         if (c_msg == 2)
1496             SSL_set_msg_callback(con, SSL_trace);
1497         else
1498 #endif
1499             SSL_set_msg_callback(con, msg_cb);
1500         SSL_set_msg_callback_arg(con, bio_c_msg ? bio_c_msg : bio_c_out);
1501     }
1502 #ifndef OPENSSL_NO_TLSEXT
1503     if (c_tlsextdebug) {
1504         SSL_set_tlsext_debug_callback(con, tlsext_cb);
1505         SSL_set_tlsext_debug_arg(con, bio_c_out);
1506     }
1507     if (c_status_req) {
1508         SSL_set_tlsext_status_type(con, TLSEXT_STATUSTYPE_ocsp);
1509         SSL_CTX_set_tlsext_status_cb(ctx, ocsp_resp_cb);
1510         SSL_CTX_set_tlsext_status_arg(ctx, bio_c_out);
1511 # if 0
1512         {
1513             STACK_OF(OCSP_RESPID) *ids = sk_OCSP_RESPID_new_null();
1514             OCSP_RESPID *id = OCSP_RESPID_new();
1515             id->value.byKey = ASN1_OCTET_STRING_new();
1516             id->type = V_OCSP_RESPID_KEY;
1517             ASN1_STRING_set(id->value.byKey, "Hello World", -1);
1518             sk_OCSP_RESPID_push(ids, id);
1519             SSL_set_tlsext_status_ids(con, ids);
1520         }
1521 # endif
1522     }
1523 #endif
1524 #ifndef OPENSSL_NO_JPAKE
1525     if (jpake_secret)
1526         jpake_client_auth(bio_c_out, sbio, jpake_secret);
1527 #endif
1528
1529     SSL_set_bio(con, sbio, sbio);
1530     SSL_set_connect_state(con);
1531
1532     /* ok, lets connect */
1533     width = SSL_get_fd(con) + 1;
1534
1535     read_tty = 1;
1536     write_tty = 0;
1537     tty_on = 0;
1538     read_ssl = 1;
1539     write_ssl = 1;
1540
1541     cbuf_len = 0;
1542     cbuf_off = 0;
1543     sbuf_len = 0;
1544     sbuf_off = 0;
1545
1546     /* This is an ugly hack that does a lot of assumptions */
1547     /*
1548      * We do have to handle multi-line responses which may come in a single
1549      * packet or not. We therefore have to use BIO_gets() which does need a
1550      * buffering BIO. So during the initial chitchat we do push a buffering
1551      * BIO into the chain that is removed again later on to not disturb the
1552      * rest of the s_client operation.
1553      */
1554     if (starttls_proto == PROTO_SMTP) {
1555         int foundit = 0;
1556         BIO *fbio = BIO_new(BIO_f_buffer());
1557         BIO_push(fbio, sbio);
1558         /* wait for multi-line response to end from SMTP */
1559         do {
1560             mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
1561         }
1562         while (mbuf_len > 3 && mbuf[3] == '-');
1563         /* STARTTLS command requires EHLO... */
1564         BIO_printf(fbio, "EHLO openssl.client.net\r\n");
1565         (void)BIO_flush(fbio);
1566         /* wait for multi-line response to end EHLO SMTP response */
1567         do {
1568             mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
1569             if (strstr(mbuf, "STARTTLS"))
1570                 foundit = 1;
1571         }
1572         while (mbuf_len > 3 && mbuf[3] == '-');
1573         (void)BIO_flush(fbio);
1574         BIO_pop(fbio);
1575         BIO_free(fbio);
1576         if (!foundit)
1577             BIO_printf(bio_err,
1578                        "didn't found starttls in server response,"
1579                        " try anyway...\n");
1580         BIO_printf(sbio, "STARTTLS\r\n");
1581         BIO_read(sbio, sbuf, BUFSIZZ);
1582     } else if (starttls_proto == PROTO_POP3) {
1583         BIO_read(sbio, mbuf, BUFSIZZ);
1584         BIO_printf(sbio, "STLS\r\n");
1585         BIO_read(sbio, sbuf, BUFSIZZ);
1586     } else if (starttls_proto == PROTO_IMAP) {
1587         int foundit = 0;
1588         BIO *fbio = BIO_new(BIO_f_buffer());
1589         BIO_push(fbio, sbio);
1590         BIO_gets(fbio, mbuf, BUFSIZZ);
1591         /* STARTTLS command requires CAPABILITY... */
1592         BIO_printf(fbio, ". CAPABILITY\r\n");
1593         (void)BIO_flush(fbio);
1594         /* wait for multi-line CAPABILITY response */
1595         do {
1596             mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
1597             if (strstr(mbuf, "STARTTLS"))
1598                 foundit = 1;
1599         }
1600         while (mbuf_len > 3 && mbuf[0] != '.');
1601         (void)BIO_flush(fbio);
1602         BIO_pop(fbio);
1603         BIO_free(fbio);
1604         if (!foundit)
1605             BIO_printf(bio_err,
1606                        "didn't found STARTTLS in server response,"
1607                        " try anyway...\n");
1608         BIO_printf(sbio, ". STARTTLS\r\n");
1609         BIO_read(sbio, sbuf, BUFSIZZ);
1610     } else if (starttls_proto == PROTO_FTP) {
1611         BIO *fbio = BIO_new(BIO_f_buffer());
1612         BIO_push(fbio, sbio);
1613         /* wait for multi-line response to end from FTP */
1614         do {
1615             mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
1616         }
1617         while (mbuf_len > 3 && mbuf[3] == '-');
1618         (void)BIO_flush(fbio);
1619         BIO_pop(fbio);
1620         BIO_free(fbio);
1621         BIO_printf(sbio, "AUTH TLS\r\n");
1622         BIO_read(sbio, sbuf, BUFSIZZ);
1623     }
1624     if (starttls_proto == PROTO_XMPP) {
1625         int seen = 0;
1626         BIO_printf(sbio, "<stream:stream "
1627                    "xmlns:stream='http://etherx.jabber.org/streams' "
1628                    "xmlns='jabber:client' to='%s' version='1.0'>", xmpphost ?
1629                    xmpphost : host);
1630         seen = BIO_read(sbio, mbuf, BUFSIZZ);
1631         mbuf[seen] = 0;
1632         while (!strstr
1633                (mbuf, "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'")
1634                && !strstr(mbuf,
1635                           "<starttls xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\""))
1636         {
1637             seen = BIO_read(sbio, mbuf, BUFSIZZ);
1638
1639             if (seen <= 0)
1640                 goto shut;
1641
1642             mbuf[seen] = 0;
1643         }
1644         BIO_printf(sbio,
1645                    "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>");
1646         seen = BIO_read(sbio, sbuf, BUFSIZZ);
1647         sbuf[seen] = 0;
1648         if (!strstr(sbuf, "<proceed"))
1649             goto shut;
1650         mbuf[0] = 0;
1651     }
1652
1653     for (;;) {
1654         FD_ZERO(&readfds);
1655         FD_ZERO(&writefds);
1656
1657         if ((SSL_version(con) == DTLS1_VERSION) &&
1658             DTLSv1_get_timeout(con, &timeout))
1659             timeoutp = &timeout;
1660         else
1661             timeoutp = NULL;
1662
1663         if (SSL_in_init(con) && !SSL_total_renegotiations(con)) {
1664             in_init = 1;
1665             tty_on = 0;
1666         } else {
1667             tty_on = 1;
1668             if (in_init) {
1669                 in_init = 0;
1670 #if 0                           /* This test doesn't really work as intended
1671                                  * (needs to be fixed) */
1672 # ifndef OPENSSL_NO_TLSEXT
1673                 if (servername != NULL && !SSL_session_reused(con)) {
1674                     BIO_printf(bio_c_out,
1675                                "Server did %sacknowledge servername extension.\n",
1676                                tlsextcbp.ack ? "" : "not ");
1677                 }
1678 # endif
1679 #endif
1680                 if (sess_out) {
1681                     BIO *stmp = BIO_new_file(sess_out, "w");
1682                     if (stmp) {
1683                         PEM_write_bio_SSL_SESSION(stmp, SSL_get_session(con));
1684                         BIO_free(stmp);
1685                     } else
1686                         BIO_printf(bio_err, "Error writing session file %s\n",
1687                                    sess_out);
1688                 }
1689                 if (c_brief) {
1690                     BIO_puts(bio_err, "CONNECTION ESTABLISHED\n");
1691                     print_ssl_summary(bio_err, con);
1692                 }
1693
1694                 print_stuff(bio_c_out, con, full_log);
1695                 if (full_log > 0)
1696                     full_log--;
1697
1698                 if (starttls_proto) {
1699                     BIO_printf(bio_err, "%s", mbuf);
1700                     /* We don't need to know any more */
1701                     starttls_proto = PROTO_OFF;
1702                 }
1703
1704                 if (reconnect) {
1705                     reconnect--;
1706                     BIO_printf(bio_c_out,
1707                                "drop connection and then reconnect\n");
1708                     SSL_shutdown(con);
1709                     SSL_set_connect_state(con);
1710                     SHUTDOWN(SSL_get_fd(con));
1711                     goto re_start;
1712                 }
1713             }
1714         }
1715
1716         ssl_pending = read_ssl && SSL_pending(con);
1717
1718         if (!ssl_pending) {
1719 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_NETWARE)
1720             if (tty_on) {
1721                 if (read_tty)
1722                     openssl_fdset(fileno(stdin), &readfds);
1723                 if (write_tty)
1724                     openssl_fdset(fileno(stdout), &writefds);
1725             }
1726             if (read_ssl)
1727                 openssl_fdset(SSL_get_fd(con), &readfds);
1728             if (write_ssl)
1729                 openssl_fdset(SSL_get_fd(con), &writefds);
1730 #else
1731             if (!tty_on || !write_tty) {
1732                 if (read_ssl)
1733                     openssl_fdset(SSL_get_fd(con), &readfds);
1734                 if (write_ssl)
1735                     openssl_fdset(SSL_get_fd(con), &writefds);
1736             }
1737 #endif
1738 /*-         printf("mode tty(%d %d%d) ssl(%d%d)\n",
1739                     tty_on,read_tty,write_tty,read_ssl,write_ssl);*/
1740
1741             /*
1742              * Note: under VMS with SOCKETSHR the second parameter is
1743              * currently of type (int *) whereas under other systems it is
1744              * (void *) if you don't have a cast it will choke the compiler:
1745              * if you do have a cast then you can either go for (int *) or
1746              * (void *).
1747              */
1748 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS)
1749             /*
1750              * Under Windows/DOS we make the assumption that we can always
1751              * write to the tty: therefore if we need to write to the tty we
1752              * just fall through. Otherwise we timeout the select every
1753              * second and see if there are any keypresses. Note: this is a
1754              * hack, in a proper Windows application we wouldn't do this.
1755              */
1756             i = 0;
1757             if (!write_tty) {
1758                 if (read_tty) {
1759                     tv.tv_sec = 1;
1760                     tv.tv_usec = 0;
1761                     i = select(width, (void *)&readfds, (void *)&writefds,
1762                                NULL, &tv);
1763 # if defined(OPENSSL_SYS_WINCE) || defined(OPENSSL_SYS_MSDOS)
1764                     if (!i && (!_kbhit() || !read_tty))
1765                         continue;
1766 # else
1767                     if (!i && (!((_kbhit())
1768                                  || (WAIT_OBJECT_0 ==
1769                                      WaitForSingleObject(GetStdHandle
1770                                                          (STD_INPUT_HANDLE),
1771                                                          0)))
1772                                || !read_tty))
1773                         continue;
1774 # endif
1775                 } else
1776                     i = select(width, (void *)&readfds, (void *)&writefds,
1777                                NULL, timeoutp);
1778             }
1779 #elif defined(OPENSSL_SYS_NETWARE)
1780             if (!write_tty) {
1781                 if (read_tty) {
1782                     tv.tv_sec = 1;
1783                     tv.tv_usec = 0;
1784                     i = select(width, (void *)&readfds, (void *)&writefds,
1785                                NULL, &tv);
1786                 } else
1787                     i = select(width, (void *)&readfds, (void *)&writefds,
1788                                NULL, timeoutp);
1789             }
1790 #else
1791             i = select(width, (void *)&readfds, (void *)&writefds,
1792                        NULL, timeoutp);
1793 #endif
1794             if (i < 0) {
1795                 BIO_printf(bio_err, "bad select %d\n",
1796                            get_last_socket_error());
1797                 goto shut;
1798                 /* goto end; */
1799             }
1800         }
1801
1802         if ((SSL_version(con) == DTLS1_VERSION)
1803             && DTLSv1_handle_timeout(con) > 0) {
1804             BIO_printf(bio_err, "TIMEOUT occurred\n");
1805         }
1806
1807         if (!ssl_pending && FD_ISSET(SSL_get_fd(con), &writefds)) {
1808             k = SSL_write(con, &(cbuf[cbuf_off]), (unsigned int)cbuf_len);
1809             switch (SSL_get_error(con, k)) {
1810             case SSL_ERROR_NONE:
1811                 cbuf_off += k;
1812                 cbuf_len -= k;
1813                 if (k <= 0)
1814                     goto end;
1815                 /* we have done a  write(con,NULL,0); */
1816                 if (cbuf_len <= 0) {
1817                     read_tty = 1;
1818                     write_ssl = 0;
1819                 } else {        /* if (cbuf_len > 0) */
1820
1821                     read_tty = 0;
1822                     write_ssl = 1;
1823                 }
1824                 break;
1825             case SSL_ERROR_WANT_WRITE:
1826                 BIO_printf(bio_c_out, "write W BLOCK\n");
1827                 write_ssl = 1;
1828                 read_tty = 0;
1829                 break;
1830             case SSL_ERROR_WANT_READ:
1831                 BIO_printf(bio_c_out, "write R BLOCK\n");
1832                 write_tty = 0;
1833                 read_ssl = 1;
1834                 write_ssl = 0;
1835                 break;
1836             case SSL_ERROR_WANT_X509_LOOKUP:
1837                 BIO_printf(bio_c_out, "write X BLOCK\n");
1838                 break;
1839             case SSL_ERROR_ZERO_RETURN:
1840                 if (cbuf_len != 0) {
1841                     BIO_printf(bio_c_out, "shutdown\n");
1842                     ret = 0;
1843                     goto shut;
1844                 } else {
1845                     read_tty = 1;
1846                     write_ssl = 0;
1847                     break;
1848                 }
1849
1850             case SSL_ERROR_SYSCALL:
1851                 if ((k != 0) || (cbuf_len != 0)) {
1852                     BIO_printf(bio_err, "write:errno=%d\n",
1853                                get_last_socket_error());
1854                     goto shut;
1855                 } else {
1856                     read_tty = 1;
1857                     write_ssl = 0;
1858                 }
1859                 break;
1860             case SSL_ERROR_SSL:
1861                 ERR_print_errors(bio_err);
1862                 goto shut;
1863             }
1864         }
1865 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_NETWARE)
1866         /* Assume Windows/DOS/BeOS can always write */
1867         else if (!ssl_pending && write_tty)
1868 #else
1869         else if (!ssl_pending && FD_ISSET(fileno(stdout), &writefds))
1870 #endif
1871         {
1872 #ifdef CHARSET_EBCDIC
1873             ascii2ebcdic(&(sbuf[sbuf_off]), &(sbuf[sbuf_off]), sbuf_len);
1874 #endif
1875             i = raw_write_stdout(&(sbuf[sbuf_off]), sbuf_len);
1876
1877             if (i <= 0) {
1878                 BIO_printf(bio_c_out, "DONE\n");
1879                 ret = 0;
1880                 goto shut;
1881                 /* goto end; */
1882             }
1883
1884             sbuf_len -= i;;
1885             sbuf_off += i;
1886             if (sbuf_len <= 0) {
1887                 read_ssl = 1;
1888                 write_tty = 0;
1889             }
1890         } else if (ssl_pending || FD_ISSET(SSL_get_fd(con), &readfds)) {
1891 #ifdef RENEG
1892             {
1893                 static int iiii;
1894                 if (++iiii == 52) {
1895                     SSL_renegotiate(con);
1896                     iiii = 0;
1897                 }
1898             }
1899 #endif
1900 #if 1
1901             k = SSL_read(con, sbuf, 1024 /* BUFSIZZ */ );
1902 #else
1903 /* Demo for pending and peek :-) */
1904             k = SSL_read(con, sbuf, 16);
1905             {
1906                 char zbuf[10240];
1907                 printf("read=%d pending=%d peek=%d\n", k, SSL_pending(con),
1908                        SSL_peek(con, zbuf, 10240));
1909             }
1910 #endif
1911
1912             switch (SSL_get_error(con, k)) {
1913             case SSL_ERROR_NONE:
1914                 if (k <= 0)
1915                     goto end;
1916                 sbuf_off = 0;
1917                 sbuf_len = k;
1918
1919                 read_ssl = 0;
1920                 write_tty = 1;
1921                 break;
1922             case SSL_ERROR_WANT_WRITE:
1923                 BIO_printf(bio_c_out, "read W BLOCK\n");
1924                 write_ssl = 1;
1925                 read_tty = 0;
1926                 break;
1927             case SSL_ERROR_WANT_READ:
1928                 BIO_printf(bio_c_out, "read R BLOCK\n");
1929                 write_tty = 0;
1930                 read_ssl = 1;
1931                 if ((read_tty == 0) && (write_ssl == 0))
1932                     write_ssl = 1;
1933                 break;
1934             case SSL_ERROR_WANT_X509_LOOKUP:
1935                 BIO_printf(bio_c_out, "read X BLOCK\n");
1936                 break;
1937             case SSL_ERROR_SYSCALL:
1938                 ret = get_last_socket_error();
1939                 if (c_brief)
1940                     BIO_puts(bio_err, "CONNECTION CLOSED BY SERVER\n");
1941                 else
1942                     BIO_printf(bio_err, "read:errno=%d\n", ret);
1943                 goto shut;
1944             case SSL_ERROR_ZERO_RETURN:
1945                 BIO_printf(bio_c_out, "closed\n");
1946                 ret = 0;
1947                 goto shut;
1948             case SSL_ERROR_SSL:
1949                 ERR_print_errors(bio_err);
1950                 goto shut;
1951                 /* break; */
1952             }
1953         }
1954 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS)
1955 # if defined(OPENSSL_SYS_WINCE) || defined(OPENSSL_SYS_MSDOS)
1956         else if (_kbhit())
1957 # else
1958         else if ((_kbhit())
1959                  || (WAIT_OBJECT_0 ==
1960                      WaitForSingleObject(GetStdHandle(STD_INPUT_HANDLE), 0)))
1961 # endif
1962 #elif defined (OPENSSL_SYS_NETWARE)
1963         else if (_kbhit())
1964 #else
1965         else if (FD_ISSET(fileno(stdin), &readfds))
1966 #endif
1967         {
1968             if (crlf) {
1969                 int j, lf_num;
1970
1971                 i = raw_read_stdin(cbuf, BUFSIZZ / 2);
1972                 lf_num = 0;
1973                 /* both loops are skipped when i <= 0 */
1974                 for (j = 0; j < i; j++)
1975                     if (cbuf[j] == '\n')
1976                         lf_num++;
1977                 for (j = i - 1; j >= 0; j--) {
1978                     cbuf[j + lf_num] = cbuf[j];
1979                     if (cbuf[j] == '\n') {
1980                         lf_num--;
1981                         i++;
1982                         cbuf[j + lf_num] = '\r';
1983                     }
1984                 }
1985                 assert(lf_num == 0);
1986             } else
1987                 i = raw_read_stdin(cbuf, BUFSIZZ);
1988
1989             if ((!c_ign_eof) && ((i <= 0) || (cbuf[0] == 'Q'))) {
1990                 BIO_printf(bio_err, "DONE\n");
1991                 ret = 0;
1992                 goto shut;
1993             }
1994
1995             if ((!c_ign_eof) && (cbuf[0] == 'R')) {
1996                 BIO_printf(bio_err, "RENEGOTIATING\n");
1997                 SSL_renegotiate(con);
1998                 cbuf_len = 0;
1999             }
2000 #ifndef OPENSSL_NO_HEARTBEATS
2001             else if ((!c_ign_eof) && (cbuf[0] == 'B')) {
2002                 BIO_printf(bio_err, "HEARTBEATING\n");
2003                 SSL_heartbeat(con);
2004                 cbuf_len = 0;
2005             }
2006 #endif
2007             else {
2008                 cbuf_len = i;
2009                 cbuf_off = 0;
2010 #ifdef CHARSET_EBCDIC
2011                 ebcdic2ascii(cbuf, cbuf, i);
2012 #endif
2013             }
2014
2015             write_ssl = 1;
2016             read_tty = 0;
2017         }
2018     }
2019
2020     ret = 0;
2021  shut:
2022     if (in_init)
2023         print_stuff(bio_c_out, con, full_log);
2024     SSL_shutdown(con);
2025     SHUTDOWN(SSL_get_fd(con));
2026  end:
2027     if (con != NULL) {
2028         if (prexit != 0)
2029             print_stuff(bio_c_out, con, 1);
2030         SSL_free(con);
2031     }
2032 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2033     if (next_proto.data)
2034         OPENSSL_free(next_proto.data);
2035 #endif
2036     if (ctx != NULL)
2037         SSL_CTX_free(ctx);
2038     if (cert)
2039         X509_free(cert);
2040     if (crls)
2041         sk_X509_CRL_pop_free(crls, X509_CRL_free);
2042     if (key)
2043         EVP_PKEY_free(key);
2044     if (chain)
2045         sk_X509_pop_free(chain, X509_free);
2046     if (pass)
2047         OPENSSL_free(pass);
2048     if (vpm)
2049         X509_VERIFY_PARAM_free(vpm);
2050     ssl_excert_free(exc);
2051     if (ssl_args)
2052         sk_OPENSSL_STRING_free(ssl_args);
2053     if (cctx)
2054         SSL_CONF_CTX_free(cctx);
2055 #ifndef OPENSSL_NO_JPAKE
2056     if (jpake_secret && psk_key)
2057         OPENSSL_free(psk_key);
2058 #endif
2059     if (cbuf != NULL) {
2060         OPENSSL_cleanse(cbuf, BUFSIZZ);
2061         OPENSSL_free(cbuf);
2062     }
2063     if (sbuf != NULL) {
2064         OPENSSL_cleanse(sbuf, BUFSIZZ);
2065         OPENSSL_free(sbuf);
2066     }
2067     if (mbuf != NULL) {
2068         OPENSSL_cleanse(mbuf, BUFSIZZ);
2069         OPENSSL_free(mbuf);
2070     }
2071     if (bio_c_out != NULL) {
2072         BIO_free(bio_c_out);
2073         bio_c_out = NULL;
2074     }
2075     if (bio_c_msg != NULL) {
2076         BIO_free(bio_c_msg);
2077         bio_c_msg = NULL;
2078     }
2079     apps_shutdown();
2080     OPENSSL_EXIT(ret);
2081 }
2082
2083 static void print_stuff(BIO *bio, SSL *s, int full)
2084 {
2085     X509 *peer = NULL;
2086     char buf[BUFSIZ];
2087     STACK_OF(X509) *sk;
2088     STACK_OF(X509_NAME) *sk2;
2089     const SSL_CIPHER *c;
2090     X509_NAME *xn;
2091     int i;
2092 #ifndef OPENSSL_NO_COMP
2093     const COMP_METHOD *comp, *expansion;
2094 #endif
2095     unsigned char *exportedkeymat;
2096
2097     if (full) {
2098         int got_a_chain = 0;
2099
2100         sk = SSL_get_peer_cert_chain(s);
2101         if (sk != NULL) {
2102             got_a_chain = 1;    /* we don't have it for SSL2 (yet) */
2103
2104             BIO_printf(bio, "---\nCertificate chain\n");
2105             for (i = 0; i < sk_X509_num(sk); i++) {
2106                 X509_NAME_oneline(X509_get_subject_name(sk_X509_value(sk, i)),
2107                                   buf, sizeof buf);
2108                 BIO_printf(bio, "%2d s:%s\n", i, buf);
2109                 X509_NAME_oneline(X509_get_issuer_name(sk_X509_value(sk, i)),
2110                                   buf, sizeof buf);
2111                 BIO_printf(bio, "   i:%s\n", buf);
2112                 if (c_showcerts)
2113                     PEM_write_bio_X509(bio, sk_X509_value(sk, i));
2114             }
2115         }
2116
2117         BIO_printf(bio, "---\n");
2118         peer = SSL_get_peer_certificate(s);
2119         if (peer != NULL) {
2120             BIO_printf(bio, "Server certificate\n");
2121
2122             /* Redundant if we showed the whole chain */
2123             if (!(c_showcerts && got_a_chain))
2124                 PEM_write_bio_X509(bio, peer);
2125             X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof buf);
2126             BIO_printf(bio, "subject=%s\n", buf);
2127             X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof buf);
2128             BIO_printf(bio, "issuer=%s\n", buf);
2129         } else
2130             BIO_printf(bio, "no peer certificate available\n");
2131
2132         sk2 = SSL_get_client_CA_list(s);
2133         if ((sk2 != NULL) && (sk_X509_NAME_num(sk2) > 0)) {
2134             BIO_printf(bio, "---\nAcceptable client certificate CA names\n");
2135             for (i = 0; i < sk_X509_NAME_num(sk2); i++) {
2136                 xn = sk_X509_NAME_value(sk2, i);
2137                 X509_NAME_oneline(xn, buf, sizeof(buf));
2138                 BIO_write(bio, buf, strlen(buf));
2139                 BIO_write(bio, "\n", 1);
2140             }
2141         } else {
2142             BIO_printf(bio, "---\nNo client certificate CA names sent\n");
2143         }
2144
2145         ssl_print_sigalgs(bio, s);
2146         ssl_print_tmp_key(bio, s);
2147
2148         BIO_printf(bio,
2149                    "---\nSSL handshake has read %ld bytes and written %ld bytes\n",
2150                    BIO_number_read(SSL_get_rbio(s)),
2151                    BIO_number_written(SSL_get_wbio(s)));
2152     }
2153     BIO_printf(bio, (SSL_cache_hit(s) ? "---\nReused, " : "---\nNew, "));
2154     c = SSL_get_current_cipher(s);
2155     BIO_printf(bio, "%s, Cipher is %s\n",
2156                SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
2157     if (peer != NULL) {
2158         EVP_PKEY *pktmp;
2159         pktmp = X509_get_pubkey(peer);
2160         BIO_printf(bio, "Server public key is %d bit\n",
2161                    EVP_PKEY_bits(pktmp));
2162         EVP_PKEY_free(pktmp);
2163     }
2164     BIO_printf(bio, "Secure Renegotiation IS%s supported\n",
2165                SSL_get_secure_renegotiation_support(s) ? "" : " NOT");
2166 #ifndef OPENSSL_NO_COMP
2167     comp = SSL_get_current_compression(s);
2168     expansion = SSL_get_current_expansion(s);
2169     BIO_printf(bio, "Compression: %s\n",
2170                comp ? SSL_COMP_get_name(comp) : "NONE");
2171     BIO_printf(bio, "Expansion: %s\n",
2172                expansion ? SSL_COMP_get_name(expansion) : "NONE");
2173 #endif
2174
2175 #ifdef SSL_DEBUG
2176     {
2177         /* Print out local port of connection: useful for debugging */
2178         int sock;
2179         struct sockaddr_in ladd;
2180         socklen_t ladd_size = sizeof(ladd);
2181         sock = SSL_get_fd(s);
2182         getsockname(sock, (struct sockaddr *)&ladd, &ladd_size);
2183         BIO_printf(bio_c_out, "LOCAL PORT is %u\n", ntohs(ladd.sin_port));
2184     }
2185 #endif
2186
2187 #if !defined(OPENSSL_NO_TLSEXT)
2188 # if !defined(OPENSSL_NO_NEXTPROTONEG)
2189     if (next_proto.status != -1) {
2190         const unsigned char *proto;
2191         unsigned int proto_len;
2192         SSL_get0_next_proto_negotiated(s, &proto, &proto_len);
2193         BIO_printf(bio, "Next protocol: (%d) ", next_proto.status);
2194         BIO_write(bio, proto, proto_len);
2195         BIO_write(bio, "\n", 1);
2196     }
2197 # endif
2198     {
2199         const unsigned char *proto;
2200         unsigned int proto_len;
2201         SSL_get0_alpn_selected(s, &proto, &proto_len);
2202         if (proto_len > 0) {
2203             BIO_printf(bio, "ALPN protocol: ");
2204             BIO_write(bio, proto, proto_len);
2205             BIO_write(bio, "\n", 1);
2206         } else
2207             BIO_printf(bio, "No ALPN negotiated\n");
2208     }
2209 #endif
2210
2211 #ifndef OPENSSL_NO_SRTP
2212     {
2213         SRTP_PROTECTION_PROFILE *srtp_profile =
2214             SSL_get_selected_srtp_profile(s);
2215
2216         if (srtp_profile)
2217             BIO_printf(bio, "SRTP Extension negotiated, profile=%s\n",
2218                        srtp_profile->name);
2219     }
2220 #endif
2221
2222     SSL_SESSION_print(bio, SSL_get_session(s));
2223     if (keymatexportlabel != NULL) {
2224         BIO_printf(bio, "Keying material exporter:\n");
2225         BIO_printf(bio, "    Label: '%s'\n", keymatexportlabel);
2226         BIO_printf(bio, "    Length: %i bytes\n", keymatexportlen);
2227         exportedkeymat = OPENSSL_malloc(keymatexportlen);
2228         if (exportedkeymat != NULL) {
2229             if (!SSL_export_keying_material(s, exportedkeymat,
2230                                             keymatexportlen,
2231                                             keymatexportlabel,
2232                                             strlen(keymatexportlabel),
2233                                             NULL, 0, 0)) {
2234                 BIO_printf(bio, "    Error\n");
2235             } else {
2236                 BIO_printf(bio, "    Keying material: ");
2237                 for (i = 0; i < keymatexportlen; i++)
2238                     BIO_printf(bio, "%02X", exportedkeymat[i]);
2239                 BIO_printf(bio, "\n");
2240             }
2241             OPENSSL_free(exportedkeymat);
2242         }
2243     }
2244     BIO_printf(bio, "---\n");
2245     if (peer != NULL)
2246         X509_free(peer);
2247     /* flush, or debugging output gets mixed with http response */
2248     (void)BIO_flush(bio);
2249 }
2250
2251 #ifndef OPENSSL_NO_TLSEXT
2252
2253 static int ocsp_resp_cb(SSL *s, void *arg)
2254 {
2255     const unsigned char *p;
2256     int len;
2257     OCSP_RESPONSE *rsp;
2258     len = SSL_get_tlsext_status_ocsp_resp(s, &p);
2259     BIO_puts(arg, "OCSP response: ");
2260     if (!p) {
2261         BIO_puts(arg, "no response sent\n");
2262         return 1;
2263     }
2264     rsp = d2i_OCSP_RESPONSE(NULL, &p, len);
2265     if (!rsp) {
2266         BIO_puts(arg, "response parse error\n");
2267         BIO_dump_indent(arg, (char *)p, len, 4);
2268         return 0;
2269     }
2270     BIO_puts(arg, "\n======================================\n");
2271     OCSP_RESPONSE_print(arg, rsp, 0);
2272     BIO_puts(arg, "======================================\n");
2273     OCSP_RESPONSE_free(rsp);
2274     return 1;
2275 }
2276
2277 #endif