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