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