apps/s_client.c

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