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