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