Introducing option SSL_OP_IGNORE_UNEXPECTED_EOF
[openssl.git] / apps / s_client.c
1 /*
2  * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
3  * Copyright 2005 Nokia. All rights reserved.
4  *
5  * Licensed under the Apache License 2.0 (the "License").  You may not use
6  * this file except in compliance with the License.  You can obtain a copy
7  * in the file LICENSE in the source distribution or at
8  * https://www.openssl.org/source/license.html
9  */
10
11 #include "e_os.h"
12 #include <ctype.h>
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <errno.h>
17 #include <openssl/e_os2.h>
18
19 #ifndef OPENSSL_NO_SOCK
20
21 /*
22  * With IPv6, it looks like Digital has mixed up the proper order of
23  * recursive header file inclusion, resulting in the compiler complaining
24  * that u_int isn't defined, but only if _POSIX_C_SOURCE is defined, which is
25  * needed to have fileno() declared correctly...  So let's define u_int
26  */
27 #if defined(OPENSSL_SYS_VMS_DECC) && !defined(__U_INT)
28 # define __U_INT
29 typedef unsigned int u_int;
30 #endif
31
32 #include "apps.h"
33 #include "progs.h"
34 #include <openssl/x509.h>
35 #include <openssl/ssl.h>
36 #include <openssl/err.h>
37 #include <openssl/pem.h>
38 #include <openssl/rand.h>
39 #include <openssl/ocsp.h>
40 #include <openssl/bn.h>
41 #include <openssl/trace.h>
42 #include <openssl/async.h>
43 #ifndef OPENSSL_NO_SRP
44 # include <openssl/srp.h>
45 #endif
46 #ifndef OPENSSL_NO_CT
47 # include <openssl/ct.h>
48 #endif
49 #include "s_apps.h"
50 #include "timeouts.h"
51 #include "internal/sockets.h"
52
53 #if defined(__has_feature)
54 # if __has_feature(memory_sanitizer)
55 #  include <sanitizer/msan_interface.h>
56 # endif
57 #endif
58
59 DEFINE_STACK_OF(X509)
60 DEFINE_STACK_OF(X509_CRL)
61 DEFINE_STACK_OF(X509_NAME)
62 DEFINE_STACK_OF(SCT)
63 DEFINE_STACK_OF_STRING()
64
65 #undef BUFSIZZ
66 #define BUFSIZZ 1024*8
67 #define S_CLIENT_IRC_READ_TIMEOUT 8
68
69 static char *prog;
70 static int c_debug = 0;
71 static int c_showcerts = 0;
72 static char *keymatexportlabel = NULL;
73 static int keymatexportlen = 20;
74 static BIO *bio_c_out = NULL;
75 static int c_quiet = 0;
76 static char *sess_out = NULL;
77 static SSL_SESSION *psksess = NULL;
78
79 static void print_stuff(BIO *berr, SSL *con, int full);
80 #ifndef OPENSSL_NO_OCSP
81 static int ocsp_resp_cb(SSL *s, void *arg);
82 #endif
83 static int ldap_ExtendedResponse_parse(const char *buf, long rem);
84 static int is_dNS_name(const char *host);
85
86 static int saved_errno;
87
88 static void save_errno(void)
89 {
90     saved_errno = errno;
91     errno = 0;
92 }
93
94 static int restore_errno(void)
95 {
96     int ret = errno;
97     errno = saved_errno;
98     return ret;
99 }
100
101 /* Default PSK identity and key */
102 static char *psk_identity = "Client_identity";
103
104 #ifndef OPENSSL_NO_PSK
105 static unsigned int psk_client_cb(SSL *ssl, const char *hint, char *identity,
106                                   unsigned int max_identity_len,
107                                   unsigned char *psk,
108                                   unsigned int max_psk_len)
109 {
110     int ret;
111     long key_len;
112     unsigned char *key;
113
114     if (c_debug)
115         BIO_printf(bio_c_out, "psk_client_cb\n");
116     if (!hint) {
117         /* no ServerKeyExchange message */
118         if (c_debug)
119             BIO_printf(bio_c_out,
120                        "NULL received PSK identity hint, continuing anyway\n");
121     } else if (c_debug) {
122         BIO_printf(bio_c_out, "Received PSK identity hint '%s'\n", hint);
123     }
124
125     /*
126      * lookup PSK identity and PSK key based on the given identity hint here
127      */
128     ret = BIO_snprintf(identity, max_identity_len, "%s", psk_identity);
129     if (ret < 0 || (unsigned int)ret > max_identity_len)
130         goto out_err;
131     if (c_debug)
132         BIO_printf(bio_c_out, "created identity '%s' len=%d\n", identity,
133                    ret);
134
135     /* convert the PSK key to binary */
136     key = OPENSSL_hexstr2buf(psk_key, &key_len);
137     if (key == NULL) {
138         BIO_printf(bio_err, "Could not convert PSK key '%s' to buffer\n",
139                    psk_key);
140         return 0;
141     }
142     if (max_psk_len > INT_MAX || key_len > (long)max_psk_len) {
143         BIO_printf(bio_err,
144                    "psk buffer of callback is too small (%d) for key (%ld)\n",
145                    max_psk_len, key_len);
146         OPENSSL_free(key);
147         return 0;
148     }
149
150     memcpy(psk, key, key_len);
151     OPENSSL_free(key);
152
153     if (c_debug)
154         BIO_printf(bio_c_out, "created PSK len=%ld\n", key_len);
155
156     return key_len;
157  out_err:
158     if (c_debug)
159         BIO_printf(bio_err, "Error in PSK client callback\n");
160     return 0;
161 }
162 #endif
163
164 const unsigned char tls13_aes128gcmsha256_id[] = { 0x13, 0x01 };
165 const unsigned char tls13_aes256gcmsha384_id[] = { 0x13, 0x02 };
166
167 static int psk_use_session_cb(SSL *s, const EVP_MD *md,
168                               const unsigned char **id, size_t *idlen,
169                               SSL_SESSION **sess)
170 {
171     SSL_SESSION *usesess = NULL;
172     const SSL_CIPHER *cipher = NULL;
173
174     if (psksess != NULL) {
175         SSL_SESSION_up_ref(psksess);
176         usesess = psksess;
177     } else {
178         long key_len;
179         unsigned char *key = OPENSSL_hexstr2buf(psk_key, &key_len);
180
181         if (key == NULL) {
182             BIO_printf(bio_err, "Could not convert PSK key '%s' to buffer\n",
183                        psk_key);
184             return 0;
185         }
186
187         /* We default to SHA-256 */
188         cipher = SSL_CIPHER_find(s, tls13_aes128gcmsha256_id);
189         if (cipher == NULL) {
190             BIO_printf(bio_err, "Error finding suitable ciphersuite\n");
191             OPENSSL_free(key);
192             return 0;
193         }
194
195         usesess = SSL_SESSION_new();
196         if (usesess == NULL
197                 || !SSL_SESSION_set1_master_key(usesess, key, key_len)
198                 || !SSL_SESSION_set_cipher(usesess, cipher)
199                 || !SSL_SESSION_set_protocol_version(usesess, TLS1_3_VERSION)) {
200             OPENSSL_free(key);
201             goto err;
202         }
203         OPENSSL_free(key);
204     }
205
206     cipher = SSL_SESSION_get0_cipher(usesess);
207     if (cipher == NULL)
208         goto err;
209
210     if (md != NULL && SSL_CIPHER_get_handshake_digest(cipher) != md) {
211         /* PSK not usable, ignore it */
212         *id = NULL;
213         *idlen = 0;
214         *sess = NULL;
215         SSL_SESSION_free(usesess);
216     } else {
217         *sess = usesess;
218         *id = (unsigned char *)psk_identity;
219         *idlen = strlen(psk_identity);
220     }
221
222     return 1;
223
224  err:
225     SSL_SESSION_free(usesess);
226     return 0;
227 }
228
229 /* This is a context that we pass to callbacks */
230 typedef struct tlsextctx_st {
231     BIO *biodebug;
232     int ack;
233 } tlsextctx;
234
235 static int ssl_servername_cb(SSL *s, int *ad, void *arg)
236 {
237     tlsextctx *p = (tlsextctx *) arg;
238     const char *hn = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
239     if (SSL_get_servername_type(s) != -1)
240         p->ack = !SSL_session_reused(s) && hn != NULL;
241     else
242         BIO_printf(bio_err, "Can't use SSL_get_servername\n");
243
244     return SSL_TLSEXT_ERR_OK;
245 }
246
247 #ifndef OPENSSL_NO_SRP
248
249 /* This is a context that we pass to all callbacks */
250 typedef struct srp_arg_st {
251     char *srppassin;
252     char *srplogin;
253     int msg;                    /* copy from c_msg */
254     int debug;                  /* copy from c_debug */
255     int amp;                    /* allow more groups */
256     int strength;               /* minimal size for N */
257 } SRP_ARG;
258
259 static int srp_Verify_N_and_g(const BIGNUM *N, const BIGNUM *g)
260 {
261     BN_CTX *bn_ctx = BN_CTX_new();
262     BIGNUM *p = BN_new();
263     BIGNUM *r = BN_new();
264     int ret =
265         g != NULL && N != NULL && bn_ctx != NULL && BN_is_odd(N) &&
266         BN_check_prime(N, bn_ctx, NULL) == 1 &&
267         p != NULL && BN_rshift1(p, N) &&
268         /* p = (N-1)/2 */
269         BN_check_prime(p, bn_ctx, NULL) == 1 &&
270         r != NULL &&
271         /* verify g^((N-1)/2) == -1 (mod N) */
272         BN_mod_exp(r, g, p, N, bn_ctx) &&
273         BN_add_word(r, 1) && BN_cmp(r, N) == 0;
274
275     BN_free(r);
276     BN_free(p);
277     BN_CTX_free(bn_ctx);
278     return ret;
279 }
280
281 /*-
282  * This callback is used here for two purposes:
283  * - extended debugging
284  * - making some primality tests for unknown groups
285  * The callback is only called for a non default group.
286  *
287  * An application does not need the call back at all if
288  * only the standard groups are used.  In real life situations,
289  * client and server already share well known groups,
290  * thus there is no need to verify them.
291  * Furthermore, in case that a server actually proposes a group that
292  * is not one of those defined in RFC 5054, it is more appropriate
293  * to add the group to a static list and then compare since
294  * primality tests are rather cpu consuming.
295  */
296
297 static int ssl_srp_verify_param_cb(SSL *s, void *arg)
298 {
299     SRP_ARG *srp_arg = (SRP_ARG *)arg;
300     BIGNUM *N = NULL, *g = NULL;
301
302     if (((N = SSL_get_srp_N(s)) == NULL) || ((g = SSL_get_srp_g(s)) == NULL))
303         return 0;
304     if (srp_arg->debug || srp_arg->msg || srp_arg->amp == 1) {
305         BIO_printf(bio_err, "SRP parameters:\n");
306         BIO_printf(bio_err, "\tN=");
307         BN_print(bio_err, N);
308         BIO_printf(bio_err, "\n\tg=");
309         BN_print(bio_err, g);
310         BIO_printf(bio_err, "\n");
311     }
312
313     if (SRP_check_known_gN_param(g, N))
314         return 1;
315
316     if (srp_arg->amp == 1) {
317         if (srp_arg->debug)
318             BIO_printf(bio_err,
319                        "SRP param N and g are not known params, going to check deeper.\n");
320
321         /*
322          * The srp_moregroups is a real debugging feature. Implementors
323          * should rather add the value to the known ones. The minimal size
324          * has already been tested.
325          */
326         if (BN_num_bits(g) <= BN_BITS && srp_Verify_N_and_g(N, g))
327             return 1;
328     }
329     BIO_printf(bio_err, "SRP param N and g rejected.\n");
330     return 0;
331 }
332
333 # define PWD_STRLEN 1024
334
335 static char *ssl_give_srp_client_pwd_cb(SSL *s, void *arg)
336 {
337     SRP_ARG *srp_arg = (SRP_ARG *)arg;
338     char *pass = app_malloc(PWD_STRLEN + 1, "SRP password buffer");
339     PW_CB_DATA cb_tmp;
340     int l;
341
342     cb_tmp.password = (char *)srp_arg->srppassin;
343     cb_tmp.prompt_info = "SRP user";
344     if ((l = password_callback(pass, PWD_STRLEN, 0, &cb_tmp)) < 0) {
345         BIO_printf(bio_err, "Can't read Password\n");
346         OPENSSL_free(pass);
347         return NULL;
348     }
349     *(pass + l) = '\0';
350
351     return pass;
352 }
353
354 #endif
355
356 #ifndef OPENSSL_NO_NEXTPROTONEG
357 /* This the context that we pass to next_proto_cb */
358 typedef struct tlsextnextprotoctx_st {
359     unsigned char *data;
360     size_t len;
361     int status;
362 } tlsextnextprotoctx;
363
364 static tlsextnextprotoctx next_proto;
365
366 static int next_proto_cb(SSL *s, unsigned char **out, unsigned char *outlen,
367                          const unsigned char *in, unsigned int inlen,
368                          void *arg)
369 {
370     tlsextnextprotoctx *ctx = arg;
371
372     if (!c_quiet) {
373         /* We can assume that |in| is syntactically valid. */
374         unsigned i;
375         BIO_printf(bio_c_out, "Protocols advertised by server: ");
376         for (i = 0; i < inlen;) {
377             if (i)
378                 BIO_write(bio_c_out, ", ", 2);
379             BIO_write(bio_c_out, &in[i + 1], in[i]);
380             i += in[i] + 1;
381         }
382         BIO_write(bio_c_out, "\n", 1);
383     }
384
385     ctx->status =
386         SSL_select_next_proto(out, outlen, in, inlen, ctx->data, ctx->len);
387     return SSL_TLSEXT_ERR_OK;
388 }
389 #endif                         /* ndef OPENSSL_NO_NEXTPROTONEG */
390
391 static int serverinfo_cli_parse_cb(SSL *s, unsigned int ext_type,
392                                    const unsigned char *in, size_t inlen,
393                                    int *al, void *arg)
394 {
395     char pem_name[100];
396     unsigned char ext_buf[4 + 65536];
397
398     /* Reconstruct the type/len fields prior to extension data */
399     inlen &= 0xffff; /* for formal memcmpy correctness */
400     ext_buf[0] = (unsigned char)(ext_type >> 8);
401     ext_buf[1] = (unsigned char)(ext_type);
402     ext_buf[2] = (unsigned char)(inlen >> 8);
403     ext_buf[3] = (unsigned char)(inlen);
404     memcpy(ext_buf + 4, in, inlen);
405
406     BIO_snprintf(pem_name, sizeof(pem_name), "SERVERINFO FOR EXTENSION %d",
407                  ext_type);
408     PEM_write_bio(bio_c_out, pem_name, "", ext_buf, 4 + inlen);
409     return 1;
410 }
411
412 /*
413  * Hex decoder that tolerates optional whitespace.  Returns number of bytes
414  * produced, advances inptr to end of input string.
415  */
416 static ossl_ssize_t hexdecode(const char **inptr, void *result)
417 {
418     unsigned char **out = (unsigned char **)result;
419     const char *in = *inptr;
420     unsigned char *ret = app_malloc(strlen(in) / 2, "hexdecode");
421     unsigned char *cp = ret;
422     uint8_t byte;
423     int nibble = 0;
424
425     if (ret == NULL)
426         return -1;
427
428     for (byte = 0; *in; ++in) {
429         int x;
430
431         if (isspace(_UC(*in)))
432             continue;
433         x = OPENSSL_hexchar2int(*in);
434         if (x < 0) {
435             OPENSSL_free(ret);
436             return 0;
437         }
438         byte |= (char)x;
439         if ((nibble ^= 1) == 0) {
440             *cp++ = byte;
441             byte = 0;
442         } else {
443             byte <<= 4;
444         }
445     }
446     if (nibble != 0) {
447         OPENSSL_free(ret);
448         return 0;
449     }
450     *inptr = in;
451
452     return cp - (*out = ret);
453 }
454
455 /*
456  * Decode unsigned 0..255, returns 1 on success, <= 0 on failure. Advances
457  * inptr to next field skipping leading whitespace.
458  */
459 static ossl_ssize_t checked_uint8(const char **inptr, void *out)
460 {
461     uint8_t *result = (uint8_t *)out;
462     const char *in = *inptr;
463     char *endp;
464     long v;
465     int e;
466
467     save_errno();
468     v = strtol(in, &endp, 10);
469     e = restore_errno();
470
471     if (((v == LONG_MIN || v == LONG_MAX) && e == ERANGE) ||
472         endp == in || !isspace(_UC(*endp)) ||
473         v != (*result = (uint8_t) v)) {
474         return -1;
475     }
476     for (in = endp; isspace(_UC(*in)); ++in)
477         continue;
478
479     *inptr = in;
480     return 1;
481 }
482
483 struct tlsa_field {
484     void *var;
485     const char *name;
486     ossl_ssize_t (*parser)(const char **, void *);
487 };
488
489 static int tlsa_import_rr(SSL *con, const char *rrdata)
490 {
491     /* Not necessary to re-init these values; the "parsers" do that. */
492     static uint8_t usage;
493     static uint8_t selector;
494     static uint8_t mtype;
495     static unsigned char *data;
496     static struct tlsa_field tlsa_fields[] = {
497         { &usage, "usage", checked_uint8 },
498         { &selector, "selector", checked_uint8 },
499         { &mtype, "mtype", checked_uint8 },
500         { &data, "data", hexdecode },
501         { NULL, }
502     };
503     struct tlsa_field *f;
504     int ret;
505     const char *cp = rrdata;
506     ossl_ssize_t len = 0;
507
508     for (f = tlsa_fields; f->var; ++f) {
509         /* Returns number of bytes produced, advances cp to next field */
510         if ((len = f->parser(&cp, f->var)) <= 0) {
511             BIO_printf(bio_err, "%s: warning: bad TLSA %s field in: %s\n",
512                        prog, f->name, rrdata);
513             return 0;
514         }
515     }
516     /* The data field is last, so len is its length */
517     ret = SSL_dane_tlsa_add(con, usage, selector, mtype, data, len);
518     OPENSSL_free(data);
519
520     if (ret == 0) {
521         ERR_print_errors(bio_err);
522         BIO_printf(bio_err, "%s: warning: unusable TLSA rrdata: %s\n",
523                    prog, rrdata);
524         return 0;
525     }
526     if (ret < 0) {
527         ERR_print_errors(bio_err);
528         BIO_printf(bio_err, "%s: warning: error loading TLSA rrdata: %s\n",
529                    prog, rrdata);
530         return 0;
531     }
532     return ret;
533 }
534
535 static int tlsa_import_rrset(SSL *con, STACK_OF(OPENSSL_STRING) *rrset)
536 {
537     int num = sk_OPENSSL_STRING_num(rrset);
538     int count = 0;
539     int i;
540
541     for (i = 0; i < num; ++i) {
542         char *rrdata = sk_OPENSSL_STRING_value(rrset, i);
543         if (tlsa_import_rr(con, rrdata) > 0)
544             ++count;
545     }
546     return count > 0;
547 }
548
549 typedef enum OPTION_choice {
550     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
551     OPT_4, OPT_6, OPT_HOST, OPT_PORT, OPT_CONNECT, OPT_BIND, OPT_UNIX,
552     OPT_XMPPHOST, OPT_VERIFY, OPT_NAMEOPT,
553     OPT_CERT, OPT_CRL, OPT_CRL_DOWNLOAD, OPT_SESS_OUT, OPT_SESS_IN,
554     OPT_CERTFORM, OPT_CRLFORM, OPT_VERIFY_RET_ERROR, OPT_VERIFY_QUIET,
555     OPT_BRIEF, OPT_PREXIT, OPT_CRLF, OPT_QUIET, OPT_NBIO,
556     OPT_SSL_CLIENT_ENGINE, OPT_IGN_EOF, OPT_NO_IGN_EOF,
557     OPT_DEBUG, OPT_TLSEXTDEBUG, OPT_STATUS, OPT_WDEBUG,
558     OPT_MSG, OPT_MSGFILE, OPT_ENGINE, OPT_TRACE, OPT_SECURITY_DEBUG,
559     OPT_SECURITY_DEBUG_VERBOSE, OPT_SHOWCERTS, OPT_NBIO_TEST, OPT_STATE,
560     OPT_PSK_IDENTITY, OPT_PSK, OPT_PSK_SESS,
561 #ifndef OPENSSL_NO_SRP
562     OPT_SRPUSER, OPT_SRPPASS, OPT_SRP_STRENGTH, OPT_SRP_LATEUSER,
563     OPT_SRP_MOREGROUPS,
564 #endif
565     OPT_SSL3, OPT_SSL_CONFIG,
566     OPT_TLS1_3, OPT_TLS1_2, OPT_TLS1_1, OPT_TLS1, OPT_DTLS, OPT_DTLS1,
567     OPT_DTLS1_2, OPT_SCTP, OPT_TIMEOUT, OPT_MTU, OPT_KEYFORM, OPT_PASS,
568     OPT_CERT_CHAIN, OPT_KEY, OPT_RECONNECT, OPT_BUILD_CHAIN,
569     OPT_NEXTPROTONEG, OPT_ALPN,
570     OPT_CAPATH, OPT_NOCAPATH, OPT_CHAINCAPATH, OPT_VERIFYCAPATH,
571     OPT_CAFILE, OPT_NOCAFILE, OPT_CHAINCAFILE, OPT_VERIFYCAFILE,
572     OPT_CASTORE, OPT_NOCASTORE, OPT_CHAINCASTORE, OPT_VERIFYCASTORE,
573     OPT_SERVERINFO, OPT_STARTTLS, OPT_SERVERNAME, OPT_NOSERVERNAME, OPT_ASYNC,
574     OPT_USE_SRTP, OPT_KEYMATEXPORT, OPT_KEYMATEXPORTLEN, OPT_PROTOHOST,
575     OPT_MAXFRAGLEN, OPT_MAX_SEND_FRAG, OPT_SPLIT_SEND_FRAG, OPT_MAX_PIPELINES,
576     OPT_READ_BUF, OPT_KEYLOG_FILE, OPT_EARLY_DATA, OPT_REQCAFILE,
577     OPT_V_ENUM,
578     OPT_X_ENUM,
579     OPT_S_ENUM, OPT_IGNORE_UNEXPECTED_EOF,
580     OPT_FALLBACKSCSV, OPT_NOCMDS, OPT_PROXY, OPT_PROXY_USER, OPT_PROXY_PASS,
581     OPT_DANE_TLSA_DOMAIN,
582 #ifndef OPENSSL_NO_CT
583     OPT_CT, OPT_NOCT, OPT_CTLOG_FILE,
584 #endif
585     OPT_DANE_TLSA_RRDATA, OPT_DANE_EE_NO_NAME,
586     OPT_ENABLE_PHA,
587     OPT_SCTP_LABEL_BUG,
588     OPT_R_ENUM, OPT_PROV_ENUM
589 } OPTION_CHOICE;
590
591 const OPTIONS s_client_options[] = {
592     {OPT_HELP_STR, 1, '-', "Usage: %s [options] [host:port]\n"},
593
594     OPT_SECTION("General"),
595     {"help", OPT_HELP, '-', "Display this summary"},
596 #ifndef OPENSSL_NO_ENGINE
597     {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
598     {"ssl_client_engine", OPT_SSL_CLIENT_ENGINE, 's',
599      "Specify engine to be used for client certificate operations"},
600 #endif
601     {"ssl_config", OPT_SSL_CONFIG, 's', "Use specified section for SSL_CTX configuration"},
602 #ifndef OPENSSL_NO_CT
603     {"ct", OPT_CT, '-', "Request and parse SCTs (also enables OCSP stapling)"},
604     {"noct", OPT_NOCT, '-', "Do not request or parse SCTs (default)"},
605     {"ctlogfile", OPT_CTLOG_FILE, '<', "CT log list CONF file"},
606 #endif
607
608     OPT_SECTION("Network"),
609     {"host", OPT_HOST, 's', "Use -connect instead"},
610     {"port", OPT_PORT, 'p', "Use -connect instead"},
611     {"connect", OPT_CONNECT, 's',
612      "TCP/IP where to connect (default is :" PORT ")"},
613     {"bind", OPT_BIND, 's', "bind local address for connection"},
614     {"proxy", OPT_PROXY, 's',
615      "Connect to via specified proxy to the real server"},
616     {"proxy_user", OPT_PROXY_USER, 's', "UserID for proxy authentication"},
617     {"proxy_pass", OPT_PROXY_PASS, 's', "Proxy authentication password source"},
618 #ifdef AF_UNIX
619     {"unix", OPT_UNIX, 's', "Connect over the specified Unix-domain socket"},
620 #endif
621     {"4", OPT_4, '-', "Use IPv4 only"},
622 #ifdef AF_INET6
623     {"6", OPT_6, '-', "Use IPv6 only"},
624 #endif
625     {"maxfraglen", OPT_MAXFRAGLEN, 'p',
626      "Enable Maximum Fragment Length Negotiation (len values: 512, 1024, 2048 and 4096)"},
627     {"max_send_frag", OPT_MAX_SEND_FRAG, 'p', "Maximum Size of send frames "},
628     {"split_send_frag", OPT_SPLIT_SEND_FRAG, 'p',
629      "Size used to split data for encrypt pipelines"},
630     {"max_pipelines", OPT_MAX_PIPELINES, 'p',
631      "Maximum number of encrypt/decrypt pipelines to be used"},
632     {"read_buf", OPT_READ_BUF, 'p',
633      "Default read buffer size to be used for connections"},
634     {"fallback_scsv", OPT_FALLBACKSCSV, '-', "Send the fallback SCSV"},
635
636     OPT_SECTION("Identity"),
637     {"cert", OPT_CERT, '<', "Client certificate file to use"},
638     {"certform", OPT_CERTFORM, 'F',
639      "Client certificate file format (PEM/DER/P12); has no effect"},
640     {"cert_chain", OPT_CERT_CHAIN, '<',
641      "Client certificate chain file (in PEM format)"},
642     {"build_chain", OPT_BUILD_CHAIN, '-', "Build client certificate chain"},
643     {"key", OPT_KEY, 's', "Private key file to use; default is: -cert file"},
644     {"keyform", OPT_KEYFORM, 'E', "Key format (ENGINE, other values ignored)"},
645     {"pass", OPT_PASS, 's', "Private key file pass phrase source"},
646     {"verify", OPT_VERIFY, 'p', "Turn on peer certificate verification"},
647     {"nameopt", OPT_NAMEOPT, 's', "Certificate subject/issuer name printing options"},
648     {"CApath", OPT_CAPATH, '/', "PEM format directory of CA's"},
649     {"CAfile", OPT_CAFILE, '<', "PEM format file of CA's"},
650     {"CAstore", OPT_CASTORE, ':', "URI to store of CA's"},
651     {"no-CAfile", OPT_NOCAFILE, '-',
652      "Do not load the default certificates file"},
653     {"no-CApath", OPT_NOCAPATH, '-',
654      "Do not load certificates from the default certificates directory"},
655     {"no-CAstore", OPT_NOCASTORE, '-',
656      "Do not load certificates from the default certificates store"},
657     {"requestCAfile", OPT_REQCAFILE, '<',
658       "PEM format file of CA names to send to the server"},
659     {"dane_tlsa_domain", OPT_DANE_TLSA_DOMAIN, 's', "DANE TLSA base domain"},
660     {"dane_tlsa_rrdata", OPT_DANE_TLSA_RRDATA, 's',
661      "DANE TLSA rrdata presentation form"},
662     {"dane_ee_no_namechecks", OPT_DANE_EE_NO_NAME, '-',
663      "Disable name checks when matching DANE-EE(3) TLSA records"},
664     {"psk_identity", OPT_PSK_IDENTITY, 's', "PSK identity"},
665     {"psk", OPT_PSK, 's', "PSK in hex (without 0x)"},
666     {"psk_session", OPT_PSK_SESS, '<', "File to read PSK SSL session from"},
667     {"name", OPT_PROTOHOST, 's',
668      "Hostname to use for \"-starttls lmtp\", \"-starttls smtp\" or \"-starttls xmpp[-server]\""},
669
670     OPT_SECTION("Session"),
671     {"reconnect", OPT_RECONNECT, '-',
672      "Drop and re-make the connection with the same Session-ID"},
673     {"sess_out", OPT_SESS_OUT, '>', "File to write SSL session to"},
674     {"sess_in", OPT_SESS_IN, '<', "File to read SSL session from"},
675
676     OPT_SECTION("Input/Output"),
677     {"crlf", OPT_CRLF, '-', "Convert LF from terminal into CRLF"},
678     {"quiet", OPT_QUIET, '-', "No s_client output"},
679     {"ign_eof", OPT_IGN_EOF, '-', "Ignore input eof (default when -quiet)"},
680     {"no_ign_eof", OPT_NO_IGN_EOF, '-', "Don't ignore input eof"},
681     {"starttls", OPT_STARTTLS, 's',
682      "Use the appropriate STARTTLS command before starting TLS"},
683     {"xmpphost", OPT_XMPPHOST, 's',
684      "Alias of -name option for \"-starttls xmpp[-server]\""},
685     {"brief", OPT_BRIEF, '-',
686      "Restrict output to brief summary of connection parameters"},
687     {"prexit", OPT_PREXIT, '-',
688      "Print session information when the program exits"},
689
690     OPT_SECTION("Debug"),
691     {"showcerts", OPT_SHOWCERTS, '-',
692      "Show all certificates sent by the server"},
693     {"debug", OPT_DEBUG, '-', "Extra output"},
694     {"msg", OPT_MSG, '-', "Show protocol messages"},
695     {"msgfile", OPT_MSGFILE, '>',
696      "File to send output of -msg or -trace, instead of stdout"},
697     {"nbio_test", OPT_NBIO_TEST, '-', "More ssl protocol testing"},
698     {"state", OPT_STATE, '-', "Print the ssl states"},
699     {"keymatexport", OPT_KEYMATEXPORT, 's',
700      "Export keying material using label"},
701     {"keymatexportlen", OPT_KEYMATEXPORTLEN, 'p',
702      "Export len bytes of keying material (default 20)"},
703     {"security_debug", OPT_SECURITY_DEBUG, '-',
704      "Enable security debug messages"},
705     {"security_debug_verbose", OPT_SECURITY_DEBUG_VERBOSE, '-',
706      "Output more security debug output"},
707 #ifndef OPENSSL_NO_SSL_TRACE
708     {"trace", OPT_TRACE, '-', "Show trace output of protocol messages"},
709 #endif
710 #ifdef WATT32
711     {"wdebug", OPT_WDEBUG, '-', "WATT-32 tcp debugging"},
712 #endif
713     {"keylogfile", OPT_KEYLOG_FILE, '>', "Write TLS secrets to file"},
714     {"nocommands", OPT_NOCMDS, '-', "Do not use interactive command letters"},
715     {"servername", OPT_SERVERNAME, 's',
716      "Set TLS extension servername (SNI) in ClientHello (default)"},
717     {"noservername", OPT_NOSERVERNAME, '-',
718      "Do not send the server name (SNI) extension in the ClientHello"},
719     {"tlsextdebug", OPT_TLSEXTDEBUG, '-',
720      "Hex dump of all TLS extensions received"},
721     {"ignore_unexpected_eof", OPT_IGNORE_UNEXPECTED_EOF, '-',
722      "Do not treat lack of close_notify from a peer as an error"},
723 #ifndef OPENSSL_NO_OCSP
724     {"status", OPT_STATUS, '-', "Request certificate status from server"},
725 #endif
726     {"serverinfo", OPT_SERVERINFO, 's',
727      "types  Send empty ClientHello extensions (comma-separated numbers)"},
728     {"alpn", OPT_ALPN, 's',
729      "Enable ALPN extension, considering named protocols supported (comma-separated list)"},
730     {"async", OPT_ASYNC, '-', "Support asynchronous operation"},
731     {"nbio", OPT_NBIO, '-', "Use non-blocking IO"},
732
733     OPT_SECTION("Protocol and version"),
734 #ifndef OPENSSL_NO_SSL3
735     {"ssl3", OPT_SSL3, '-', "Just use SSLv3"},
736 #endif
737 #ifndef OPENSSL_NO_TLS1
738     {"tls1", OPT_TLS1, '-', "Just use TLSv1"},
739 #endif
740 #ifndef OPENSSL_NO_TLS1_1
741     {"tls1_1", OPT_TLS1_1, '-', "Just use TLSv1.1"},
742 #endif
743 #ifndef OPENSSL_NO_TLS1_2
744     {"tls1_2", OPT_TLS1_2, '-', "Just use TLSv1.2"},
745 #endif
746 #ifndef OPENSSL_NO_TLS1_3
747     {"tls1_3", OPT_TLS1_3, '-', "Just use TLSv1.3"},
748 #endif
749 #ifndef OPENSSL_NO_DTLS
750     {"dtls", OPT_DTLS, '-', "Use any version of DTLS"},
751     {"timeout", OPT_TIMEOUT, '-',
752      "Enable send/receive timeout on DTLS connections"},
753     {"mtu", OPT_MTU, 'p', "Set the link layer MTU"},
754 #endif
755 #ifndef OPENSSL_NO_DTLS1
756     {"dtls1", OPT_DTLS1, '-', "Just use DTLSv1"},
757 #endif
758 #ifndef OPENSSL_NO_DTLS1_2
759     {"dtls1_2", OPT_DTLS1_2, '-', "Just use DTLSv1.2"},
760 #endif
761 #ifndef OPENSSL_NO_SCTP
762     {"sctp", OPT_SCTP, '-', "Use SCTP"},
763     {"sctp_label_bug", OPT_SCTP_LABEL_BUG, '-', "Enable SCTP label length bug"},
764 #endif
765 #ifndef OPENSSL_NO_NEXTPROTONEG
766     {"nextprotoneg", OPT_NEXTPROTONEG, 's',
767      "Enable NPN extension, considering named protocols supported (comma-separated list)"},
768 #endif
769     {"early_data", OPT_EARLY_DATA, '<', "File to send as early data"},
770     {"enable_pha", OPT_ENABLE_PHA, '-', "Enable post-handshake-authentication"},
771 #ifndef OPENSSL_NO_SRTP
772     {"use_srtp", OPT_USE_SRTP, 's',
773      "Offer SRTP key management with a colon-separated profile list"},
774 #endif
775 #ifndef OPENSSL_NO_SRP
776     {"srpuser", OPT_SRPUSER, 's', "SRP authentication for 'user'"},
777     {"srppass", OPT_SRPPASS, 's', "Password for 'user'"},
778     {"srp_lateuser", OPT_SRP_LATEUSER, '-',
779      "SRP username into second ClientHello message"},
780     {"srp_moregroups", OPT_SRP_MOREGROUPS, '-',
781      "Tolerate other than the known g N values."},
782     {"srp_strength", OPT_SRP_STRENGTH, 'p', "Minimal length in bits for N"},
783 #endif
784
785     OPT_R_OPTIONS,
786     OPT_S_OPTIONS,
787     OPT_V_OPTIONS,
788     {"CRL", OPT_CRL, '<', "CRL file to use"},
789     {"crl_download", OPT_CRL_DOWNLOAD, '-', "Download CRL from distribution points"},
790     {"CRLform", OPT_CRLFORM, 'F', "CRL format (PEM or DER) PEM is default"},
791     {"verify_return_error", OPT_VERIFY_RET_ERROR, '-',
792      "Close connection on verification error"},
793     {"verify_quiet", OPT_VERIFY_QUIET, '-', "Restrict verify output to errors"},
794     {"chainCAfile", OPT_CHAINCAFILE, '<',
795      "CA file for certificate chain (PEM format)"},
796     {"chainCApath", OPT_CHAINCAPATH, '/',
797      "Use dir as certificate store path to build CA certificate chain"},
798     {"chainCAstore", OPT_CHAINCASTORE, ':',
799      "CA store URI for certificate chain"},
800     {"verifyCAfile", OPT_VERIFYCAFILE, '<',
801      "CA file for certificate verification (PEM format)"},
802     {"verifyCApath", OPT_VERIFYCAPATH, '/',
803      "Use dir as certificate store path to verify CA certificate"},
804     {"verifyCAstore", OPT_VERIFYCASTORE, ':',
805      "CA store URI for certificate verification"},
806     OPT_X_OPTIONS,
807     OPT_PROV_OPTIONS,
808
809     OPT_PARAMETERS(),
810     {"host:port", 0, 0, "Where to connect; same as -connect option"},
811     {NULL}
812 };
813
814 typedef enum PROTOCOL_choice {
815     PROTO_OFF,
816     PROTO_SMTP,
817     PROTO_POP3,
818     PROTO_IMAP,
819     PROTO_FTP,
820     PROTO_TELNET,
821     PROTO_XMPP,
822     PROTO_XMPP_SERVER,
823     PROTO_CONNECT,
824     PROTO_IRC,
825     PROTO_MYSQL,
826     PROTO_POSTGRES,
827     PROTO_LMTP,
828     PROTO_NNTP,
829     PROTO_SIEVE,
830     PROTO_LDAP
831 } PROTOCOL_CHOICE;
832
833 static const OPT_PAIR services[] = {
834     {"smtp", PROTO_SMTP},
835     {"pop3", PROTO_POP3},
836     {"imap", PROTO_IMAP},
837     {"ftp", PROTO_FTP},
838     {"xmpp", PROTO_XMPP},
839     {"xmpp-server", PROTO_XMPP_SERVER},
840     {"telnet", PROTO_TELNET},
841     {"irc", PROTO_IRC},
842     {"mysql", PROTO_MYSQL},
843     {"postgres", PROTO_POSTGRES},
844     {"lmtp", PROTO_LMTP},
845     {"nntp", PROTO_NNTP},
846     {"sieve", PROTO_SIEVE},
847     {"ldap", PROTO_LDAP},
848     {NULL, 0}
849 };
850
851 #define IS_INET_FLAG(o) \
852  (o == OPT_4 || o == OPT_6 || o == OPT_HOST || o == OPT_PORT || o == OPT_CONNECT)
853 #define IS_UNIX_FLAG(o) (o == OPT_UNIX)
854
855 #define IS_PROT_FLAG(o) \
856  (o == OPT_SSL3 || o == OPT_TLS1 || o == OPT_TLS1_1 || o == OPT_TLS1_2 \
857   || o == OPT_TLS1_3 || o == OPT_DTLS || o == OPT_DTLS1 || o == OPT_DTLS1_2)
858
859 /* Free |*dest| and optionally set it to a copy of |source|. */
860 static void freeandcopy(char **dest, const char *source)
861 {
862     OPENSSL_free(*dest);
863     *dest = NULL;
864     if (source != NULL)
865         *dest = OPENSSL_strdup(source);
866 }
867
868 static int new_session_cb(SSL *s, SSL_SESSION *sess)
869 {
870
871     if (sess_out != NULL) {
872         BIO *stmp = BIO_new_file(sess_out, "w");
873
874         if (stmp == NULL) {
875             BIO_printf(bio_err, "Error writing session file %s\n", sess_out);
876         } else {
877             PEM_write_bio_SSL_SESSION(stmp, sess);
878             BIO_free(stmp);
879         }
880     }
881
882     /*
883      * Session data gets dumped on connection for TLSv1.2 and below, and on
884      * arrival of the NewSessionTicket for TLSv1.3.
885      */
886     if (SSL_version(s) == TLS1_3_VERSION) {
887         BIO_printf(bio_c_out,
888                    "---\nPost-Handshake New Session Ticket arrived:\n");
889         SSL_SESSION_print(bio_c_out, sess);
890         BIO_printf(bio_c_out, "---\n");
891     }
892
893     /*
894      * We always return a "fail" response so that the session gets freed again
895      * because we haven't used the reference.
896      */
897     return 0;
898 }
899
900 int s_client_main(int argc, char **argv)
901 {
902     BIO *sbio;
903     EVP_PKEY *key = NULL;
904     SSL *con = NULL;
905     SSL_CTX *ctx = NULL;
906     STACK_OF(X509) *chain = NULL;
907     X509 *cert = NULL;
908     X509_VERIFY_PARAM *vpm = NULL;
909     SSL_EXCERT *exc = NULL;
910     SSL_CONF_CTX *cctx = NULL;
911     STACK_OF(OPENSSL_STRING) *ssl_args = NULL;
912     char *dane_tlsa_domain = NULL;
913     STACK_OF(OPENSSL_STRING) *dane_tlsa_rrset = NULL;
914     int dane_ee_no_name = 0;
915     STACK_OF(X509_CRL) *crls = NULL;
916     const SSL_METHOD *meth = TLS_client_method();
917     const char *CApath = NULL, *CAfile = NULL, *CAstore = NULL;
918     char *cbuf = NULL, *sbuf = NULL, *mbuf = NULL;
919     char *proxystr = NULL, *proxyuser = NULL;
920     char *proxypassarg = NULL, *proxypass = NULL;
921     char *connectstr = NULL, *bindstr = NULL;
922     char *cert_file = NULL, *key_file = NULL, *chain_file = NULL;
923     char *chCApath = NULL, *chCAfile = NULL, *chCAstore = NULL, *host = NULL;
924     char *port = OPENSSL_strdup(PORT);
925     char *bindhost = NULL, *bindport = NULL;
926     char *passarg = NULL, *pass = NULL;
927     char *vfyCApath = NULL, *vfyCAfile = NULL, *vfyCAstore = NULL;
928     char *ReqCAfile = NULL;
929     char *sess_in = NULL, *crl_file = NULL, *p;
930     const char *protohost = NULL;
931     struct timeval timeout, *timeoutp;
932     fd_set readfds, writefds;
933     int noCApath = 0, noCAfile = 0, noCAstore = 0;
934     int build_chain = 0, cbuf_len, cbuf_off, cert_format = FORMAT_PEM;
935     int key_format = FORMAT_PEM, crlf = 0, full_log = 1, mbuf_len = 0;
936     int prexit = 0;
937     int sdebug = 0;
938     int reconnect = 0, verify = SSL_VERIFY_NONE, vpmtouched = 0;
939     int ret = 1, in_init = 1, i, nbio_test = 0, sock = -1, k, width, state = 0;
940     int sbuf_len, sbuf_off, cmdletters = 1;
941     int socket_family = AF_UNSPEC, socket_type = SOCK_STREAM, protocol = 0;
942     int starttls_proto = PROTO_OFF, crl_format = FORMAT_PEM, crl_download = 0;
943     int write_tty, read_tty, write_ssl, read_ssl, tty_on, ssl_pending;
944 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS)
945     int at_eof = 0;
946 #endif
947     int read_buf_len = 0;
948     int fallback_scsv = 0;
949     OPTION_CHOICE o;
950 #ifndef OPENSSL_NO_DTLS
951     int enable_timeouts = 0;
952     long socket_mtu = 0;
953 #endif
954 #ifndef OPENSSL_NO_ENGINE
955     ENGINE *ssl_client_engine = NULL;
956 #endif
957     ENGINE *e = NULL;
958 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS)
959     struct timeval tv;
960 #endif
961     const char *servername = NULL;
962     int noservername = 0;
963     const char *alpn_in = NULL;
964     tlsextctx tlsextcbp = { NULL, 0 };
965     const char *ssl_config = NULL;
966 #define MAX_SI_TYPES 100
967     unsigned short serverinfo_types[MAX_SI_TYPES];
968     int serverinfo_count = 0, start = 0, len;
969 #ifndef OPENSSL_NO_NEXTPROTONEG
970     const char *next_proto_neg_in = NULL;
971 #endif
972 #ifndef OPENSSL_NO_SRP
973     char *srppass = NULL;
974     int srp_lateuser = 0;
975     SRP_ARG srp_arg = { NULL, NULL, 0, 0, 0, 1024 };
976 #endif
977 #ifndef OPENSSL_NO_SRTP
978     char *srtp_profiles = NULL;
979 #endif
980 #ifndef OPENSSL_NO_CT
981     char *ctlog_file = NULL;
982     int ct_validation = 0;
983 #endif
984     int min_version = 0, max_version = 0, prot_opt = 0, no_prot_opt = 0;
985     int async = 0;
986     unsigned int max_send_fragment = 0;
987     unsigned int split_send_fragment = 0, max_pipelines = 0;
988     enum { use_inet, use_unix, use_unknown } connect_type = use_unknown;
989     int count4or6 = 0;
990     uint8_t maxfraglen = 0;
991     int c_nbio = 0, c_msg = 0, c_ign_eof = 0, c_brief = 0;
992     int c_tlsextdebug = 0;
993 #ifndef OPENSSL_NO_OCSP
994     int c_status_req = 0;
995 #endif
996     BIO *bio_c_msg = NULL;
997     const char *keylog_file = NULL, *early_data_file = NULL;
998 #ifndef OPENSSL_NO_DTLS
999     int isdtls = 0;
1000 #endif
1001     char *psksessf = NULL;
1002     int enable_pha = 0;
1003 #ifndef OPENSSL_NO_SCTP
1004     int sctp_label_bug = 0;
1005 #endif
1006     int ignore_unexpected_eof = 0;
1007
1008     FD_ZERO(&readfds);
1009     FD_ZERO(&writefds);
1010 /* Known false-positive of MemorySanitizer. */
1011 #if defined(__has_feature)
1012 # if __has_feature(memory_sanitizer)
1013     __msan_unpoison(&readfds, sizeof(readfds));
1014     __msan_unpoison(&writefds, sizeof(writefds));
1015 # endif
1016 #endif
1017
1018     prog = opt_progname(argv[0]);
1019     c_quiet = 0;
1020     c_debug = 0;
1021     c_showcerts = 0;
1022     c_nbio = 0;
1023     vpm = X509_VERIFY_PARAM_new();
1024     cctx = SSL_CONF_CTX_new();
1025
1026     if (vpm == NULL || cctx == NULL) {
1027         BIO_printf(bio_err, "%s: out of memory\n", prog);
1028         goto end;
1029     }
1030
1031     cbuf = app_malloc(BUFSIZZ, "cbuf");
1032     sbuf = app_malloc(BUFSIZZ, "sbuf");
1033     mbuf = app_malloc(BUFSIZZ, "mbuf");
1034
1035     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CLIENT | SSL_CONF_FLAG_CMDLINE);
1036
1037     prog = opt_init(argc, argv, s_client_options);
1038     while ((o = opt_next()) != OPT_EOF) {
1039         /* Check for intermixing flags. */
1040         if (connect_type == use_unix && IS_INET_FLAG(o)) {
1041             BIO_printf(bio_err,
1042                        "%s: Intermixed protocol flags (unix and internet domains)\n",
1043                        prog);
1044             goto end;
1045         }
1046         if (connect_type == use_inet && IS_UNIX_FLAG(o)) {
1047             BIO_printf(bio_err,
1048                        "%s: Intermixed protocol flags (internet and unix domains)\n",
1049                        prog);
1050             goto end;
1051         }
1052
1053         if (IS_PROT_FLAG(o) && ++prot_opt > 1) {
1054             BIO_printf(bio_err, "Cannot supply multiple protocol flags\n");
1055             goto end;
1056         }
1057         if (IS_NO_PROT_FLAG(o))
1058             no_prot_opt++;
1059         if (prot_opt == 1 && no_prot_opt) {
1060             BIO_printf(bio_err,
1061                        "Cannot supply both a protocol flag and '-no_<prot>'\n");
1062             goto end;
1063         }
1064
1065         switch (o) {
1066         case OPT_EOF:
1067         case OPT_ERR:
1068  opthelp:
1069             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1070             goto end;
1071         case OPT_HELP:
1072             opt_help(s_client_options);
1073             ret = 0;
1074             goto end;
1075         case OPT_4:
1076             connect_type = use_inet;
1077             socket_family = AF_INET;
1078             count4or6++;
1079             break;
1080 #ifdef AF_INET6
1081         case OPT_6:
1082             connect_type = use_inet;
1083             socket_family = AF_INET6;
1084             count4or6++;
1085             break;
1086 #endif
1087         case OPT_HOST:
1088             connect_type = use_inet;
1089             freeandcopy(&host, opt_arg());
1090             break;
1091         case OPT_PORT:
1092             connect_type = use_inet;
1093             freeandcopy(&port, opt_arg());
1094             break;
1095         case OPT_CONNECT:
1096             connect_type = use_inet;
1097             freeandcopy(&connectstr, opt_arg());
1098             break;
1099         case OPT_BIND:
1100             freeandcopy(&bindstr, opt_arg());
1101             break;
1102         case OPT_PROXY:
1103             proxystr = opt_arg();
1104             starttls_proto = PROTO_CONNECT;
1105             break;
1106         case OPT_PROXY_USER:
1107             proxyuser = opt_arg();
1108             break;
1109         case OPT_PROXY_PASS:
1110             proxypassarg = opt_arg();
1111             break;
1112 #ifdef AF_UNIX
1113         case OPT_UNIX:
1114             connect_type = use_unix;
1115             socket_family = AF_UNIX;
1116             freeandcopy(&host, opt_arg());
1117             break;
1118 #endif
1119         case OPT_XMPPHOST:
1120             /* fall through, since this is an alias */
1121         case OPT_PROTOHOST:
1122             protohost = opt_arg();
1123             break;
1124         case OPT_VERIFY:
1125             verify = SSL_VERIFY_PEER;
1126             verify_args.depth = atoi(opt_arg());
1127             if (!c_quiet)
1128                 BIO_printf(bio_err, "verify depth is %d\n", verify_args.depth);
1129             break;
1130         case OPT_CERT:
1131             cert_file = opt_arg();
1132             break;
1133         case OPT_NAMEOPT:
1134             if (!set_nameopt(opt_arg()))
1135                 goto end;
1136             break;
1137         case OPT_CRL:
1138             crl_file = opt_arg();
1139             break;
1140         case OPT_CRL_DOWNLOAD:
1141             crl_download = 1;
1142             break;
1143         case OPT_SESS_OUT:
1144             sess_out = opt_arg();
1145             break;
1146         case OPT_SESS_IN:
1147             sess_in = opt_arg();
1148             break;
1149         case OPT_CERTFORM:
1150             if (!opt_format(opt_arg(), OPT_FMT_ANY, &cert_format))
1151                 goto opthelp;
1152             break;
1153         case OPT_CRLFORM:
1154             if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &crl_format))
1155                 goto opthelp;
1156             break;
1157         case OPT_VERIFY_RET_ERROR:
1158             verify = SSL_VERIFY_PEER;
1159             verify_args.return_error = 1;
1160             break;
1161         case OPT_VERIFY_QUIET:
1162             verify_args.quiet = 1;
1163             break;
1164         case OPT_BRIEF:
1165             c_brief = verify_args.quiet = c_quiet = 1;
1166             break;
1167         case OPT_S_CASES:
1168             if (ssl_args == NULL)
1169                 ssl_args = sk_OPENSSL_STRING_new_null();
1170             if (ssl_args == NULL
1171                 || !sk_OPENSSL_STRING_push(ssl_args, opt_flag())
1172                 || !sk_OPENSSL_STRING_push(ssl_args, opt_arg())) {
1173                 BIO_printf(bio_err, "%s: Memory allocation failure\n", prog);
1174                 goto end;
1175             }
1176             break;
1177         case OPT_V_CASES:
1178             if (!opt_verify(o, vpm))
1179                 goto end;
1180             vpmtouched++;
1181             break;
1182         case OPT_X_CASES:
1183             if (!args_excert(o, &exc))
1184                 goto end;
1185             break;
1186         case OPT_IGNORE_UNEXPECTED_EOF:
1187             ignore_unexpected_eof = 1;
1188             break;
1189         case OPT_PREXIT:
1190             prexit = 1;
1191             break;
1192         case OPT_CRLF:
1193             crlf = 1;
1194             break;
1195         case OPT_QUIET:
1196             c_quiet = c_ign_eof = 1;
1197             break;
1198         case OPT_NBIO:
1199             c_nbio = 1;
1200             break;
1201         case OPT_NOCMDS:
1202             cmdletters = 0;
1203             break;
1204         case OPT_ENGINE:
1205             e = setup_engine(opt_arg(), 1);
1206             break;
1207         case OPT_SSL_CLIENT_ENGINE:
1208 #ifndef OPENSSL_NO_ENGINE
1209             ssl_client_engine = ENGINE_by_id(opt_arg());
1210             if (ssl_client_engine == NULL) {
1211                 BIO_printf(bio_err, "Error getting client auth engine\n");
1212                 goto opthelp;
1213             }
1214 #endif
1215             break;
1216         case OPT_R_CASES:
1217             if (!opt_rand(o))
1218                 goto end;
1219             break;
1220         case OPT_PROV_CASES:
1221             if (!opt_provider(o))
1222                 goto end;
1223             break;
1224         case OPT_IGN_EOF:
1225             c_ign_eof = 1;
1226             break;
1227         case OPT_NO_IGN_EOF:
1228             c_ign_eof = 0;
1229             break;
1230         case OPT_DEBUG:
1231             c_debug = 1;
1232             break;
1233         case OPT_TLSEXTDEBUG:
1234             c_tlsextdebug = 1;
1235             break;
1236         case OPT_STATUS:
1237 #ifndef OPENSSL_NO_OCSP
1238             c_status_req = 1;
1239 #endif
1240             break;
1241         case OPT_WDEBUG:
1242 #ifdef WATT32
1243             dbug_init();
1244 #endif
1245             break;
1246         case OPT_MSG:
1247             c_msg = 1;
1248             break;
1249         case OPT_MSGFILE:
1250             bio_c_msg = BIO_new_file(opt_arg(), "w");
1251             break;
1252         case OPT_TRACE:
1253 #ifndef OPENSSL_NO_SSL_TRACE
1254             c_msg = 2;
1255 #endif
1256             break;
1257         case OPT_SECURITY_DEBUG:
1258             sdebug = 1;
1259             break;
1260         case OPT_SECURITY_DEBUG_VERBOSE:
1261             sdebug = 2;
1262             break;
1263         case OPT_SHOWCERTS:
1264             c_showcerts = 1;
1265             break;
1266         case OPT_NBIO_TEST:
1267             nbio_test = 1;
1268             break;
1269         case OPT_STATE:
1270             state = 1;
1271             break;
1272         case OPT_PSK_IDENTITY:
1273             psk_identity = opt_arg();
1274             break;
1275         case OPT_PSK:
1276             for (p = psk_key = opt_arg(); *p; p++) {
1277                 if (isxdigit(_UC(*p)))
1278                     continue;
1279                 BIO_printf(bio_err, "Not a hex number '%s'\n", psk_key);
1280                 goto end;
1281             }
1282             break;
1283         case OPT_PSK_SESS:
1284             psksessf = opt_arg();
1285             break;
1286 #ifndef OPENSSL_NO_SRP
1287         case OPT_SRPUSER:
1288             srp_arg.srplogin = opt_arg();
1289             if (min_version < TLS1_VERSION)
1290                 min_version = TLS1_VERSION;
1291             break;
1292         case OPT_SRPPASS:
1293             srppass = opt_arg();
1294             if (min_version < TLS1_VERSION)
1295                 min_version = TLS1_VERSION;
1296             break;
1297         case OPT_SRP_STRENGTH:
1298             srp_arg.strength = atoi(opt_arg());
1299             BIO_printf(bio_err, "SRP minimal length for N is %d\n",
1300                        srp_arg.strength);
1301             if (min_version < TLS1_VERSION)
1302                 min_version = TLS1_VERSION;
1303             break;
1304         case OPT_SRP_LATEUSER:
1305             srp_lateuser = 1;
1306             if (min_version < TLS1_VERSION)
1307                 min_version = TLS1_VERSION;
1308             break;
1309         case OPT_SRP_MOREGROUPS:
1310             srp_arg.amp = 1;
1311             if (min_version < TLS1_VERSION)
1312                 min_version = TLS1_VERSION;
1313             break;
1314 #endif
1315         case OPT_SSL_CONFIG:
1316             ssl_config = opt_arg();
1317             break;
1318         case OPT_SSL3:
1319             min_version = SSL3_VERSION;
1320             max_version = SSL3_VERSION;
1321             break;
1322         case OPT_TLS1_3:
1323             min_version = TLS1_3_VERSION;
1324             max_version = TLS1_3_VERSION;
1325             break;
1326         case OPT_TLS1_2:
1327             min_version = TLS1_2_VERSION;
1328             max_version = TLS1_2_VERSION;
1329             break;
1330         case OPT_TLS1_1:
1331             min_version = TLS1_1_VERSION;
1332             max_version = TLS1_1_VERSION;
1333             break;
1334         case OPT_TLS1:
1335             min_version = TLS1_VERSION;
1336             max_version = TLS1_VERSION;
1337             break;
1338         case OPT_DTLS:
1339 #ifndef OPENSSL_NO_DTLS
1340             meth = DTLS_client_method();
1341             socket_type = SOCK_DGRAM;
1342             isdtls = 1;
1343 #endif
1344             break;
1345         case OPT_DTLS1:
1346 #ifndef OPENSSL_NO_DTLS1
1347             meth = DTLS_client_method();
1348             min_version = DTLS1_VERSION;
1349             max_version = DTLS1_VERSION;
1350             socket_type = SOCK_DGRAM;
1351             isdtls = 1;
1352 #endif
1353             break;
1354         case OPT_DTLS1_2:
1355 #ifndef OPENSSL_NO_DTLS1_2
1356             meth = DTLS_client_method();
1357             min_version = DTLS1_2_VERSION;
1358             max_version = DTLS1_2_VERSION;
1359             socket_type = SOCK_DGRAM;
1360             isdtls = 1;
1361 #endif
1362             break;
1363         case OPT_SCTP:
1364 #ifndef OPENSSL_NO_SCTP
1365             protocol = IPPROTO_SCTP;
1366 #endif
1367             break;
1368         case OPT_SCTP_LABEL_BUG:
1369 #ifndef OPENSSL_NO_SCTP
1370             sctp_label_bug = 1;
1371 #endif
1372             break;
1373         case OPT_TIMEOUT:
1374 #ifndef OPENSSL_NO_DTLS
1375             enable_timeouts = 1;
1376 #endif
1377             break;
1378         case OPT_MTU:
1379 #ifndef OPENSSL_NO_DTLS
1380             socket_mtu = atol(opt_arg());
1381 #endif
1382             break;
1383         case OPT_FALLBACKSCSV:
1384             fallback_scsv = 1;
1385             break;
1386         case OPT_KEYFORM:
1387             if (!opt_format(opt_arg(), OPT_FMT_ANY, &key_format))
1388                 goto opthelp;
1389             break;
1390         case OPT_PASS:
1391             passarg = opt_arg();
1392             break;
1393         case OPT_CERT_CHAIN:
1394             chain_file = opt_arg();
1395             break;
1396         case OPT_KEY:
1397             key_file = opt_arg();
1398             break;
1399         case OPT_RECONNECT:
1400             reconnect = 5;
1401             break;
1402         case OPT_CAPATH:
1403             CApath = opt_arg();
1404             break;
1405         case OPT_NOCAPATH:
1406             noCApath = 1;
1407             break;
1408         case OPT_CHAINCAPATH:
1409             chCApath = opt_arg();
1410             break;
1411         case OPT_VERIFYCAPATH:
1412             vfyCApath = opt_arg();
1413             break;
1414         case OPT_BUILD_CHAIN:
1415             build_chain = 1;
1416             break;
1417         case OPT_REQCAFILE:
1418             ReqCAfile = opt_arg();
1419             break;
1420         case OPT_CAFILE:
1421             CAfile = opt_arg();
1422             break;
1423         case OPT_NOCAFILE:
1424             noCAfile = 1;
1425             break;
1426 #ifndef OPENSSL_NO_CT
1427         case OPT_NOCT:
1428             ct_validation = 0;
1429             break;
1430         case OPT_CT:
1431             ct_validation = 1;
1432             break;
1433         case OPT_CTLOG_FILE:
1434             ctlog_file = opt_arg();
1435             break;
1436 #endif
1437         case OPT_CHAINCAFILE:
1438             chCAfile = opt_arg();
1439             break;
1440         case OPT_VERIFYCAFILE:
1441             vfyCAfile = opt_arg();
1442             break;
1443         case OPT_CASTORE:
1444             CAstore = opt_arg();
1445             break;
1446         case OPT_NOCASTORE:
1447             noCAstore = 1;
1448             break;
1449         case OPT_CHAINCASTORE:
1450             chCAstore = opt_arg();
1451             break;
1452         case OPT_VERIFYCASTORE:
1453             vfyCAstore = opt_arg();
1454             break;
1455         case OPT_DANE_TLSA_DOMAIN:
1456             dane_tlsa_domain = opt_arg();
1457             break;
1458         case OPT_DANE_TLSA_RRDATA:
1459             if (dane_tlsa_rrset == NULL)
1460                 dane_tlsa_rrset = sk_OPENSSL_STRING_new_null();
1461             if (dane_tlsa_rrset == NULL ||
1462                 !sk_OPENSSL_STRING_push(dane_tlsa_rrset, opt_arg())) {
1463                 BIO_printf(bio_err, "%s: Memory allocation failure\n", prog);
1464                 goto end;
1465             }
1466             break;
1467         case OPT_DANE_EE_NO_NAME:
1468             dane_ee_no_name = 1;
1469             break;
1470         case OPT_NEXTPROTONEG:
1471 #ifndef OPENSSL_NO_NEXTPROTONEG
1472             next_proto_neg_in = opt_arg();
1473 #endif
1474             break;
1475         case OPT_ALPN:
1476             alpn_in = opt_arg();
1477             break;
1478         case OPT_SERVERINFO:
1479             p = opt_arg();
1480             len = strlen(p);
1481             for (start = 0, i = 0; i <= len; ++i) {
1482                 if (i == len || p[i] == ',') {
1483                     serverinfo_types[serverinfo_count] = atoi(p + start);
1484                     if (++serverinfo_count == MAX_SI_TYPES)
1485                         break;
1486                     start = i + 1;
1487                 }
1488             }
1489             break;
1490         case OPT_STARTTLS:
1491             if (!opt_pair(opt_arg(), services, &starttls_proto))
1492                 goto end;
1493             break;
1494         case OPT_SERVERNAME:
1495             servername = opt_arg();
1496             break;
1497         case OPT_NOSERVERNAME:
1498             noservername = 1;
1499             break;
1500         case OPT_USE_SRTP:
1501 #ifndef OPENSSL_NO_SRTP
1502             srtp_profiles = opt_arg();
1503 #endif
1504             break;
1505         case OPT_KEYMATEXPORT:
1506             keymatexportlabel = opt_arg();
1507             break;
1508         case OPT_KEYMATEXPORTLEN:
1509             keymatexportlen = atoi(opt_arg());
1510             break;
1511         case OPT_ASYNC:
1512             async = 1;
1513             break;
1514         case OPT_MAXFRAGLEN:
1515             len = atoi(opt_arg());
1516             switch (len) {
1517             case 512:
1518                 maxfraglen = TLSEXT_max_fragment_length_512;
1519                 break;
1520             case 1024:
1521                 maxfraglen = TLSEXT_max_fragment_length_1024;
1522                 break;
1523             case 2048:
1524                 maxfraglen = TLSEXT_max_fragment_length_2048;
1525                 break;
1526             case 4096:
1527                 maxfraglen = TLSEXT_max_fragment_length_4096;
1528                 break;
1529             default:
1530                 BIO_printf(bio_err,
1531                            "%s: Max Fragment Len %u is out of permitted values",
1532                            prog, len);
1533                 goto opthelp;
1534             }
1535             break;
1536         case OPT_MAX_SEND_FRAG:
1537             max_send_fragment = atoi(opt_arg());
1538             break;
1539         case OPT_SPLIT_SEND_FRAG:
1540             split_send_fragment = atoi(opt_arg());
1541             break;
1542         case OPT_MAX_PIPELINES:
1543             max_pipelines = atoi(opt_arg());
1544             break;
1545         case OPT_READ_BUF:
1546             read_buf_len = atoi(opt_arg());
1547             break;
1548         case OPT_KEYLOG_FILE:
1549             keylog_file = opt_arg();
1550             break;
1551         case OPT_EARLY_DATA:
1552             early_data_file = opt_arg();
1553             break;
1554         case OPT_ENABLE_PHA:
1555             enable_pha = 1;
1556             break;
1557         }
1558     }
1559
1560     if (count4or6 >= 2) {
1561         BIO_printf(bio_err, "%s: Can't use both -4 and -6\n", prog);
1562         goto opthelp;
1563     }
1564     if (noservername) {
1565         if (servername != NULL) {
1566             BIO_printf(bio_err,
1567                        "%s: Can't use -servername and -noservername together\n",
1568                        prog);
1569             goto opthelp;
1570         }
1571         if (dane_tlsa_domain != NULL) {
1572             BIO_printf(bio_err,
1573                "%s: Can't use -dane_tlsa_domain and -noservername together\n",
1574                prog);
1575             goto opthelp;
1576         }
1577     }
1578     argc = opt_num_rest();
1579     if (argc == 1) {
1580         /* If there's a positional argument, it's the equivalent of
1581          * OPT_CONNECT.
1582          * Don't allow -connect and a separate argument.
1583          */
1584         if (connectstr != NULL) {
1585             BIO_printf(bio_err,
1586                        "%s: must not provide both -connect option and target parameter\n",
1587                        prog);
1588             goto opthelp;
1589         }
1590         connect_type = use_inet;
1591         freeandcopy(&connectstr, *opt_rest());
1592     } else if (argc != 0) {
1593         goto opthelp;
1594     }
1595
1596 #ifndef OPENSSL_NO_NEXTPROTONEG
1597     if (min_version == TLS1_3_VERSION && next_proto_neg_in != NULL) {
1598         BIO_printf(bio_err, "Cannot supply -nextprotoneg with TLSv1.3\n");
1599         goto opthelp;
1600     }
1601 #endif
1602     if (proxystr != NULL) {
1603         int res;
1604         char *tmp_host = host, *tmp_port = port;
1605         if (connectstr == NULL) {
1606             BIO_printf(bio_err, "%s: -proxy requires use of -connect or target parameter\n", prog);
1607             goto opthelp;
1608         }
1609         res = BIO_parse_hostserv(proxystr, &host, &port, BIO_PARSE_PRIO_HOST);
1610         if (tmp_host != host)
1611             OPENSSL_free(tmp_host);
1612         if (tmp_port != port)
1613             OPENSSL_free(tmp_port);
1614         if (!res) {
1615             BIO_printf(bio_err,
1616                        "%s: -proxy argument malformed or ambiguous\n", prog);
1617             goto end;
1618         }
1619     } else {
1620         int res = 1;
1621         char *tmp_host = host, *tmp_port = port;
1622         if (connectstr != NULL)
1623             res = BIO_parse_hostserv(connectstr, &host, &port,
1624                                      BIO_PARSE_PRIO_HOST);
1625         if (tmp_host != host)
1626             OPENSSL_free(tmp_host);
1627         if (tmp_port != port)
1628             OPENSSL_free(tmp_port);
1629         if (!res) {
1630             BIO_printf(bio_err,
1631                        "%s: -connect argument or target parameter malformed or ambiguous\n",
1632                        prog);
1633             goto end;
1634         }
1635     }
1636
1637     if (bindstr != NULL) {
1638         int res;
1639         res = BIO_parse_hostserv(bindstr, &bindhost, &bindport,
1640                                  BIO_PARSE_PRIO_HOST);
1641         if (!res) {
1642             BIO_printf(bio_err,
1643                        "%s: -bind argument parameter malformed or ambiguous\n",
1644                        prog);
1645             goto end;
1646         }
1647     }
1648
1649 #ifdef AF_UNIX
1650     if (socket_family == AF_UNIX && socket_type != SOCK_STREAM) {
1651         BIO_printf(bio_err,
1652                    "Can't use unix sockets and datagrams together\n");
1653         goto end;
1654     }
1655 #endif
1656
1657 #ifndef OPENSSL_NO_SCTP
1658     if (protocol == IPPROTO_SCTP) {
1659         if (socket_type != SOCK_DGRAM) {
1660             BIO_printf(bio_err, "Can't use -sctp without DTLS\n");
1661             goto end;
1662         }
1663         /* SCTP is unusual. It uses DTLS over a SOCK_STREAM protocol */
1664         socket_type = SOCK_STREAM;
1665     }
1666 #endif
1667
1668 #if !defined(OPENSSL_NO_NEXTPROTONEG)
1669     next_proto.status = -1;
1670     if (next_proto_neg_in) {
1671         next_proto.data =
1672             next_protos_parse(&next_proto.len, next_proto_neg_in);
1673         if (next_proto.data == NULL) {
1674             BIO_printf(bio_err, "Error parsing -nextprotoneg argument\n");
1675             goto end;
1676         }
1677     } else
1678         next_proto.data = NULL;
1679 #endif
1680
1681     if (!app_passwd(passarg, NULL, &pass, NULL)) {
1682         BIO_printf(bio_err, "Error getting private key password\n");
1683         goto end;
1684     }
1685
1686     if (!app_passwd(proxypassarg, NULL, &proxypass, NULL)) {
1687         BIO_printf(bio_err, "Error getting proxy password\n");
1688         goto end;
1689     }
1690
1691     if (proxypass != NULL && proxyuser == NULL) {
1692         BIO_printf(bio_err, "Error: Must specify proxy_user with proxy_pass\n");
1693         goto end;
1694     }
1695
1696     if (key_file == NULL)
1697         key_file = cert_file;
1698
1699     if (key_file != NULL) {
1700         key = load_key(key_file, key_format, 0, pass, e,
1701                        "client certificate private key file");
1702         if (key == NULL)
1703             goto end;
1704     }
1705
1706     if (cert_file != NULL) {
1707         cert = load_cert(cert_file, cert_format, "client certificate file");
1708         if (cert == NULL)
1709             goto end;
1710     }
1711
1712     if (chain_file != NULL) {
1713         if (!load_certs(chain_file, &chain, FORMAT_PEM, NULL,
1714                         "client certificate chain"))
1715             goto end;
1716     }
1717
1718     if (crl_file != NULL) {
1719         X509_CRL *crl;
1720         crl = load_crl(crl_file, crl_format, "CRL");
1721         if (crl == NULL)
1722             goto end;
1723         crls = sk_X509_CRL_new_null();
1724         if (crls == NULL || !sk_X509_CRL_push(crls, crl)) {
1725             BIO_puts(bio_err, "Error adding CRL\n");
1726             ERR_print_errors(bio_err);
1727             X509_CRL_free(crl);
1728             goto end;
1729         }
1730     }
1731
1732     if (!load_excert(&exc))
1733         goto end;
1734
1735     if (bio_c_out == NULL) {
1736         if (c_quiet && !c_debug) {
1737             bio_c_out = BIO_new(BIO_s_null());
1738             if (c_msg && bio_c_msg == NULL)
1739                 bio_c_msg = dup_bio_out(FORMAT_TEXT);
1740         } else if (bio_c_out == NULL)
1741             bio_c_out = dup_bio_out(FORMAT_TEXT);
1742     }
1743 #ifndef OPENSSL_NO_SRP
1744     if (!app_passwd(srppass, NULL, &srp_arg.srppassin, NULL)) {
1745         BIO_printf(bio_err, "Error getting password\n");
1746         goto end;
1747     }
1748 #endif
1749
1750     ctx = SSL_CTX_new(meth);
1751     if (ctx == NULL) {
1752         ERR_print_errors(bio_err);
1753         goto end;
1754     }
1755
1756     SSL_CTX_clear_mode(ctx, SSL_MODE_AUTO_RETRY);
1757
1758     if (sdebug)
1759         ssl_ctx_security_debug(ctx, sdebug);
1760
1761     if (!config_ctx(cctx, ssl_args, ctx))
1762         goto end;
1763
1764     if (ssl_config != NULL) {
1765         if (SSL_CTX_config(ctx, ssl_config) == 0) {
1766             BIO_printf(bio_err, "Error using configuration \"%s\"\n",
1767                        ssl_config);
1768             ERR_print_errors(bio_err);
1769             goto end;
1770         }
1771     }
1772
1773 #ifndef OPENSSL_NO_SCTP
1774     if (protocol == IPPROTO_SCTP && sctp_label_bug == 1)
1775         SSL_CTX_set_mode(ctx, SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG);
1776 #endif
1777
1778     if (min_version != 0
1779         && SSL_CTX_set_min_proto_version(ctx, min_version) == 0)
1780         goto end;
1781     if (max_version != 0
1782         && SSL_CTX_set_max_proto_version(ctx, max_version) == 0)
1783         goto end;
1784
1785     if (ignore_unexpected_eof)
1786         SSL_CTX_set_options(ctx, SSL_OP_IGNORE_UNEXPECTED_EOF);
1787
1788     if (vpmtouched && !SSL_CTX_set1_param(ctx, vpm)) {
1789         BIO_printf(bio_err, "Error setting verify params\n");
1790         ERR_print_errors(bio_err);
1791         goto end;
1792     }
1793
1794     if (async) {
1795         SSL_CTX_set_mode(ctx, SSL_MODE_ASYNC);
1796     }
1797
1798     if (max_send_fragment > 0
1799         && !SSL_CTX_set_max_send_fragment(ctx, max_send_fragment)) {
1800         BIO_printf(bio_err, "%s: Max send fragment size %u is out of permitted range\n",
1801                    prog, max_send_fragment);
1802         goto end;
1803     }
1804
1805     if (split_send_fragment > 0
1806         && !SSL_CTX_set_split_send_fragment(ctx, split_send_fragment)) {
1807         BIO_printf(bio_err, "%s: Split send fragment size %u is out of permitted range\n",
1808                    prog, split_send_fragment);
1809         goto end;
1810     }
1811
1812     if (max_pipelines > 0
1813         && !SSL_CTX_set_max_pipelines(ctx, max_pipelines)) {
1814         BIO_printf(bio_err, "%s: Max pipelines %u is out of permitted range\n",
1815                    prog, max_pipelines);
1816         goto end;
1817     }
1818
1819     if (read_buf_len > 0) {
1820         SSL_CTX_set_default_read_buffer_len(ctx, read_buf_len);
1821     }
1822
1823     if (maxfraglen > 0
1824             && !SSL_CTX_set_tlsext_max_fragment_length(ctx, maxfraglen)) {
1825         BIO_printf(bio_err,
1826                    "%s: Max Fragment Length code %u is out of permitted values"
1827                    "\n", prog, maxfraglen);
1828         goto end;
1829     }
1830
1831     if (!ssl_load_stores(ctx,
1832                          vfyCApath, vfyCAfile, vfyCAstore,
1833                          chCApath, chCAfile, chCAstore,
1834                          crls, crl_download)) {
1835         BIO_printf(bio_err, "Error loading store locations\n");
1836         ERR_print_errors(bio_err);
1837         goto end;
1838     }
1839     if (ReqCAfile != NULL) {
1840         STACK_OF(X509_NAME) *nm = sk_X509_NAME_new_null();
1841
1842         if (nm == NULL || !SSL_add_file_cert_subjects_to_stack(nm, ReqCAfile)) {
1843             sk_X509_NAME_pop_free(nm, X509_NAME_free);
1844             BIO_printf(bio_err, "Error loading CA names\n");
1845             ERR_print_errors(bio_err);
1846             goto end;
1847         }
1848         SSL_CTX_set0_CA_list(ctx, nm);
1849     }
1850 #ifndef OPENSSL_NO_ENGINE
1851     if (ssl_client_engine) {
1852         if (!SSL_CTX_set_client_cert_engine(ctx, ssl_client_engine)) {
1853             BIO_puts(bio_err, "Error setting client auth engine\n");
1854             ERR_print_errors(bio_err);
1855             ENGINE_free(ssl_client_engine);
1856             goto end;
1857         }
1858         ENGINE_free(ssl_client_engine);
1859     }
1860 #endif
1861
1862 #ifndef OPENSSL_NO_PSK
1863     if (psk_key != NULL) {
1864         if (c_debug)
1865             BIO_printf(bio_c_out, "PSK key given, setting client callback\n");
1866         SSL_CTX_set_psk_client_callback(ctx, psk_client_cb);
1867     }
1868 #endif
1869     if (psksessf != NULL) {
1870         BIO *stmp = BIO_new_file(psksessf, "r");
1871
1872         if (stmp == NULL) {
1873             BIO_printf(bio_err, "Can't open PSK session file %s\n", psksessf);
1874             ERR_print_errors(bio_err);
1875             goto end;
1876         }
1877         psksess = PEM_read_bio_SSL_SESSION(stmp, NULL, 0, NULL);
1878         BIO_free(stmp);
1879         if (psksess == NULL) {
1880             BIO_printf(bio_err, "Can't read PSK session file %s\n", psksessf);
1881             ERR_print_errors(bio_err);
1882             goto end;
1883         }
1884     }
1885     if (psk_key != NULL || psksess != NULL)
1886         SSL_CTX_set_psk_use_session_callback(ctx, psk_use_session_cb);
1887
1888 #ifndef OPENSSL_NO_SRTP
1889     if (srtp_profiles != NULL) {
1890         /* Returns 0 on success! */
1891         if (SSL_CTX_set_tlsext_use_srtp(ctx, srtp_profiles) != 0) {
1892             BIO_printf(bio_err, "Error setting SRTP profile\n");
1893             ERR_print_errors(bio_err);
1894             goto end;
1895         }
1896     }
1897 #endif
1898
1899     if (exc != NULL)
1900         ssl_ctx_set_excert(ctx, exc);
1901
1902 #if !defined(OPENSSL_NO_NEXTPROTONEG)
1903     if (next_proto.data != NULL)
1904         SSL_CTX_set_next_proto_select_cb(ctx, next_proto_cb, &next_proto);
1905 #endif
1906     if (alpn_in) {
1907         size_t alpn_len;
1908         unsigned char *alpn = next_protos_parse(&alpn_len, alpn_in);
1909
1910         if (alpn == NULL) {
1911             BIO_printf(bio_err, "Error parsing -alpn argument\n");
1912             goto end;
1913         }
1914         /* Returns 0 on success! */
1915         if (SSL_CTX_set_alpn_protos(ctx, alpn, alpn_len) != 0) {
1916             BIO_printf(bio_err, "Error setting ALPN\n");
1917             goto end;
1918         }
1919         OPENSSL_free(alpn);
1920     }
1921
1922     for (i = 0; i < serverinfo_count; i++) {
1923         if (!SSL_CTX_add_client_custom_ext(ctx,
1924                                            serverinfo_types[i],
1925                                            NULL, NULL, NULL,
1926                                            serverinfo_cli_parse_cb, NULL)) {
1927             BIO_printf(bio_err,
1928                        "Warning: Unable to add custom extension %u, skipping\n",
1929                        serverinfo_types[i]);
1930         }
1931     }
1932
1933     if (state)
1934         SSL_CTX_set_info_callback(ctx, apps_ssl_info_callback);
1935
1936 #ifndef OPENSSL_NO_CT
1937     /* Enable SCT processing, without early connection termination */
1938     if (ct_validation &&
1939         !SSL_CTX_enable_ct(ctx, SSL_CT_VALIDATION_PERMISSIVE)) {
1940         ERR_print_errors(bio_err);
1941         goto end;
1942     }
1943
1944     if (!ctx_set_ctlog_list_file(ctx, ctlog_file)) {
1945         if (ct_validation) {
1946             ERR_print_errors(bio_err);
1947             goto end;
1948         }
1949
1950         /*
1951          * If CT validation is not enabled, the log list isn't needed so don't
1952          * show errors or abort. We try to load it regardless because then we
1953          * can show the names of the logs any SCTs came from (SCTs may be seen
1954          * even with validation disabled).
1955          */
1956         ERR_clear_error();
1957     }
1958 #endif
1959
1960     SSL_CTX_set_verify(ctx, verify, verify_callback);
1961
1962     if (!ctx_set_verify_locations(ctx, CAfile, noCAfile, CApath, noCApath,
1963                                   CAstore, noCAstore)) {
1964         ERR_print_errors(bio_err);
1965         goto end;
1966     }
1967
1968     ssl_ctx_add_crls(ctx, crls, crl_download);
1969
1970     if (!set_cert_key_stuff(ctx, cert, key, chain, build_chain))
1971         goto end;
1972
1973     if (!noservername) {
1974         tlsextcbp.biodebug = bio_err;
1975         SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb);
1976         SSL_CTX_set_tlsext_servername_arg(ctx, &tlsextcbp);
1977     }
1978 # ifndef OPENSSL_NO_SRP
1979     if (srp_arg.srplogin) {
1980         if (!srp_lateuser && !SSL_CTX_set_srp_username(ctx, srp_arg.srplogin)) {
1981             BIO_printf(bio_err, "Unable to set SRP username\n");
1982             goto end;
1983         }
1984         srp_arg.msg = c_msg;
1985         srp_arg.debug = c_debug;
1986         SSL_CTX_set_srp_cb_arg(ctx, &srp_arg);
1987         SSL_CTX_set_srp_client_pwd_callback(ctx, ssl_give_srp_client_pwd_cb);
1988         SSL_CTX_set_srp_strength(ctx, srp_arg.strength);
1989         if (c_msg || c_debug || srp_arg.amp == 0)
1990             SSL_CTX_set_srp_verify_param_callback(ctx,
1991                                                   ssl_srp_verify_param_cb);
1992     }
1993 # endif
1994
1995     if (dane_tlsa_domain != NULL) {
1996         if (SSL_CTX_dane_enable(ctx) <= 0) {
1997             BIO_printf(bio_err,
1998                        "%s: Error enabling DANE TLSA authentication.\n",
1999                        prog);
2000             ERR_print_errors(bio_err);
2001             goto end;
2002         }
2003     }
2004
2005     /*
2006      * In TLSv1.3 NewSessionTicket messages arrive after the handshake and can
2007      * come at any time. Therefore we use a callback to write out the session
2008      * when we know about it. This approach works for < TLSv1.3 as well.
2009      */
2010     SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_CLIENT
2011                                         | SSL_SESS_CACHE_NO_INTERNAL_STORE);
2012     SSL_CTX_sess_set_new_cb(ctx, new_session_cb);
2013
2014     if (set_keylog_file(ctx, keylog_file))
2015         goto end;
2016
2017     con = SSL_new(ctx);
2018     if (con == NULL)
2019         goto end;
2020
2021     if (enable_pha)
2022         SSL_set_post_handshake_auth(con, 1);
2023
2024     if (sess_in != NULL) {
2025         SSL_SESSION *sess;
2026         BIO *stmp = BIO_new_file(sess_in, "r");
2027         if (stmp == NULL) {
2028             BIO_printf(bio_err, "Can't open session file %s\n", sess_in);
2029             ERR_print_errors(bio_err);
2030             goto end;
2031         }
2032         sess = PEM_read_bio_SSL_SESSION(stmp, NULL, 0, NULL);
2033         BIO_free(stmp);
2034         if (sess == NULL) {
2035             BIO_printf(bio_err, "Can't open session file %s\n", sess_in);
2036             ERR_print_errors(bio_err);
2037             goto end;
2038         }
2039         if (!SSL_set_session(con, sess)) {
2040             BIO_printf(bio_err, "Can't set session\n");
2041             ERR_print_errors(bio_err);
2042             goto end;
2043         }
2044
2045         SSL_SESSION_free(sess);
2046     }
2047
2048     if (fallback_scsv)
2049         SSL_set_mode(con, SSL_MODE_SEND_FALLBACK_SCSV);
2050
2051     if (!noservername && (servername != NULL || dane_tlsa_domain == NULL)) {
2052         if (servername == NULL) {
2053             if(host == NULL || is_dNS_name(host))
2054                 servername = (host == NULL) ? "localhost" : host;
2055         }
2056         if (servername != NULL && !SSL_set_tlsext_host_name(con, servername)) {
2057             BIO_printf(bio_err, "Unable to set TLS servername extension.\n");
2058             ERR_print_errors(bio_err);
2059             goto end;
2060         }
2061     }
2062
2063     if (dane_tlsa_domain != NULL) {
2064         if (SSL_dane_enable(con, dane_tlsa_domain) <= 0) {
2065             BIO_printf(bio_err, "%s: Error enabling DANE TLSA "
2066                        "authentication.\n", prog);
2067             ERR_print_errors(bio_err);
2068             goto end;
2069         }
2070         if (dane_tlsa_rrset == NULL) {
2071             BIO_printf(bio_err, "%s: DANE TLSA authentication requires at "
2072                        "least one -dane_tlsa_rrdata option.\n", prog);
2073             goto end;
2074         }
2075         if (tlsa_import_rrset(con, dane_tlsa_rrset) <= 0) {
2076             BIO_printf(bio_err, "%s: Failed to import any TLSA "
2077                        "records.\n", prog);
2078             goto end;
2079         }
2080         if (dane_ee_no_name)
2081             SSL_dane_set_flags(con, DANE_FLAG_NO_DANE_EE_NAMECHECKS);
2082     } else if (dane_tlsa_rrset != NULL) {
2083         BIO_printf(bio_err, "%s: DANE TLSA authentication requires the "
2084                    "-dane_tlsa_domain option.\n", prog);
2085         goto end;
2086     }
2087
2088  re_start:
2089     if (init_client(&sock, host, port, bindhost, bindport, socket_family,
2090                     socket_type, protocol) == 0) {
2091         BIO_printf(bio_err, "connect:errno=%d\n", get_last_socket_error());
2092         BIO_closesocket(sock);
2093         goto end;
2094     }
2095     BIO_printf(bio_c_out, "CONNECTED(%08X)\n", sock);
2096
2097     if (c_nbio) {
2098         if (!BIO_socket_nbio(sock, 1)) {
2099             ERR_print_errors(bio_err);
2100             goto end;
2101         }
2102         BIO_printf(bio_c_out, "Turned on non blocking io\n");
2103     }
2104 #ifndef OPENSSL_NO_DTLS
2105     if (isdtls) {
2106         union BIO_sock_info_u peer_info;
2107
2108 #ifndef OPENSSL_NO_SCTP
2109         if (protocol == IPPROTO_SCTP)
2110             sbio = BIO_new_dgram_sctp(sock, BIO_NOCLOSE);
2111         else
2112 #endif
2113             sbio = BIO_new_dgram(sock, BIO_NOCLOSE);
2114
2115         if ((peer_info.addr = BIO_ADDR_new()) == NULL) {
2116             BIO_printf(bio_err, "memory allocation failure\n");
2117             BIO_closesocket(sock);
2118             goto end;
2119         }
2120         if (!BIO_sock_info(sock, BIO_SOCK_INFO_ADDRESS, &peer_info)) {
2121             BIO_printf(bio_err, "getsockname:errno=%d\n",
2122                        get_last_socket_error());
2123             BIO_ADDR_free(peer_info.addr);
2124             BIO_closesocket(sock);
2125             goto end;
2126         }
2127
2128         (void)BIO_ctrl_set_connected(sbio, peer_info.addr);
2129         BIO_ADDR_free(peer_info.addr);
2130         peer_info.addr = NULL;
2131
2132         if (enable_timeouts) {
2133             timeout.tv_sec = 0;
2134             timeout.tv_usec = DGRAM_RCV_TIMEOUT;
2135             BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout);
2136
2137             timeout.tv_sec = 0;
2138             timeout.tv_usec = DGRAM_SND_TIMEOUT;
2139             BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_SEND_TIMEOUT, 0, &timeout);
2140         }
2141
2142         if (socket_mtu) {
2143             if (socket_mtu < DTLS_get_link_min_mtu(con)) {
2144                 BIO_printf(bio_err, "MTU too small. Must be at least %ld\n",
2145                            DTLS_get_link_min_mtu(con));
2146                 BIO_free(sbio);
2147                 goto shut;
2148             }
2149             SSL_set_options(con, SSL_OP_NO_QUERY_MTU);
2150             if (!DTLS_set_link_mtu(con, socket_mtu)) {
2151                 BIO_printf(bio_err, "Failed to set MTU\n");
2152                 BIO_free(sbio);
2153                 goto shut;
2154             }
2155         } else {
2156             /* want to do MTU discovery */
2157             BIO_ctrl(sbio, BIO_CTRL_DGRAM_MTU_DISCOVER, 0, NULL);
2158         }
2159     } else
2160 #endif /* OPENSSL_NO_DTLS */
2161         sbio = BIO_new_socket(sock, BIO_NOCLOSE);
2162
2163     if (nbio_test) {
2164         BIO *test;
2165
2166         test = BIO_new(BIO_f_nbio_test());
2167         sbio = BIO_push(test, sbio);
2168     }
2169
2170     if (c_debug) {
2171         BIO_set_callback(sbio, bio_dump_callback);
2172         BIO_set_callback_arg(sbio, (char *)bio_c_out);
2173     }
2174     if (c_msg) {
2175 #ifndef OPENSSL_NO_SSL_TRACE
2176         if (c_msg == 2)
2177             SSL_set_msg_callback(con, SSL_trace);
2178         else
2179 #endif
2180             SSL_set_msg_callback(con, msg_cb);
2181         SSL_set_msg_callback_arg(con, bio_c_msg ? bio_c_msg : bio_c_out);
2182     }
2183
2184     if (c_tlsextdebug) {
2185         SSL_set_tlsext_debug_callback(con, tlsext_cb);
2186         SSL_set_tlsext_debug_arg(con, bio_c_out);
2187     }
2188 #ifndef OPENSSL_NO_OCSP
2189     if (c_status_req) {
2190         SSL_set_tlsext_status_type(con, TLSEXT_STATUSTYPE_ocsp);
2191         SSL_CTX_set_tlsext_status_cb(ctx, ocsp_resp_cb);
2192         SSL_CTX_set_tlsext_status_arg(ctx, bio_c_out);
2193     }
2194 #endif
2195
2196     SSL_set_bio(con, sbio, sbio);
2197     SSL_set_connect_state(con);
2198
2199     /* ok, lets connect */
2200     if (fileno_stdin() > SSL_get_fd(con))
2201         width = fileno_stdin() + 1;
2202     else
2203         width = SSL_get_fd(con) + 1;
2204
2205     read_tty = 1;
2206     write_tty = 0;
2207     tty_on = 0;
2208     read_ssl = 1;
2209     write_ssl = 1;
2210
2211     cbuf_len = 0;
2212     cbuf_off = 0;
2213     sbuf_len = 0;
2214     sbuf_off = 0;
2215
2216     switch ((PROTOCOL_CHOICE) starttls_proto) {
2217     case PROTO_OFF:
2218         break;
2219     case PROTO_LMTP:
2220     case PROTO_SMTP:
2221         {
2222             /*
2223              * This is an ugly hack that does a lot of assumptions. We do
2224              * have to handle multi-line responses which may come in a single
2225              * packet or not. We therefore have to use BIO_gets() which does
2226              * need a buffering BIO. So during the initial chitchat we do
2227              * push a buffering BIO into the chain that is removed again
2228              * later on to not disturb the rest of the s_client operation.
2229              */
2230             int foundit = 0;
2231             BIO *fbio = BIO_new(BIO_f_buffer());
2232
2233             BIO_push(fbio, sbio);
2234             /* Wait for multi-line response to end from LMTP or SMTP */
2235             do {
2236                 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
2237             } while (mbuf_len > 3 && mbuf[3] == '-');
2238             if (protohost == NULL)
2239                 protohost = "mail.example.com";
2240             if (starttls_proto == (int)PROTO_LMTP)
2241                 BIO_printf(fbio, "LHLO %s\r\n", protohost);
2242             else
2243                 BIO_printf(fbio, "EHLO %s\r\n", protohost);
2244             (void)BIO_flush(fbio);
2245             /*
2246              * Wait for multi-line response to end LHLO LMTP or EHLO SMTP
2247              * response.
2248              */
2249             do {
2250                 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
2251                 if (strstr(mbuf, "STARTTLS"))
2252                     foundit = 1;
2253             } while (mbuf_len > 3 && mbuf[3] == '-');
2254             (void)BIO_flush(fbio);
2255             BIO_pop(fbio);
2256             BIO_free(fbio);
2257             if (!foundit)
2258                 BIO_printf(bio_err,
2259                            "Didn't find STARTTLS in server response,"
2260                            " trying anyway...\n");
2261             BIO_printf(sbio, "STARTTLS\r\n");
2262             BIO_read(sbio, sbuf, BUFSIZZ);
2263         }
2264         break;
2265     case PROTO_POP3:
2266         {
2267             BIO_read(sbio, mbuf, BUFSIZZ);
2268             BIO_printf(sbio, "STLS\r\n");
2269             mbuf_len = BIO_read(sbio, sbuf, BUFSIZZ);
2270             if (mbuf_len < 0) {
2271                 BIO_printf(bio_err, "BIO_read failed\n");
2272                 goto end;
2273             }
2274         }
2275         break;
2276     case PROTO_IMAP:
2277         {
2278             int foundit = 0;
2279             BIO *fbio = BIO_new(BIO_f_buffer());
2280
2281             BIO_push(fbio, sbio);
2282             BIO_gets(fbio, mbuf, BUFSIZZ);
2283             /* STARTTLS command requires CAPABILITY... */
2284             BIO_printf(fbio, ". CAPABILITY\r\n");
2285             (void)BIO_flush(fbio);
2286             /* wait for multi-line CAPABILITY response */
2287             do {
2288                 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
2289                 if (strstr(mbuf, "STARTTLS"))
2290                     foundit = 1;
2291             }
2292             while (mbuf_len > 3 && mbuf[0] != '.');
2293             (void)BIO_flush(fbio);
2294             BIO_pop(fbio);
2295             BIO_free(fbio);
2296             if (!foundit)
2297                 BIO_printf(bio_err,
2298                            "Didn't find STARTTLS in server response,"
2299                            " trying anyway...\n");
2300             BIO_printf(sbio, ". STARTTLS\r\n");
2301             BIO_read(sbio, sbuf, BUFSIZZ);
2302         }
2303         break;
2304     case PROTO_FTP:
2305         {
2306             BIO *fbio = BIO_new(BIO_f_buffer());
2307
2308             BIO_push(fbio, sbio);
2309             /* wait for multi-line response to end from FTP */
2310             do {
2311                 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
2312             }
2313             while (mbuf_len > 3 && (!isdigit(mbuf[0]) || !isdigit(mbuf[1]) || !isdigit(mbuf[2]) || mbuf[3] != ' '));
2314             (void)BIO_flush(fbio);
2315             BIO_pop(fbio);
2316             BIO_free(fbio);
2317             BIO_printf(sbio, "AUTH TLS\r\n");
2318             BIO_read(sbio, sbuf, BUFSIZZ);
2319         }
2320         break;
2321     case PROTO_XMPP:
2322     case PROTO_XMPP_SERVER:
2323         {
2324             int seen = 0;
2325             BIO_printf(sbio, "<stream:stream "
2326                        "xmlns:stream='http://etherx.jabber.org/streams' "
2327                        "xmlns='jabber:%s' to='%s' version='1.0'>",
2328                        starttls_proto == PROTO_XMPP ? "client" : "server",
2329                        protohost ? protohost : host);
2330             seen = BIO_read(sbio, mbuf, BUFSIZZ);
2331             if (seen < 0) {
2332                 BIO_printf(bio_err, "BIO_read failed\n");
2333                 goto end;
2334             }
2335             mbuf[seen] = '\0';
2336             while (!strstr
2337                    (mbuf, "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'")
2338                    && !strstr(mbuf,
2339                               "<starttls xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\""))
2340             {
2341                 seen = BIO_read(sbio, mbuf, BUFSIZZ);
2342
2343                 if (seen <= 0)
2344                     goto shut;
2345
2346                 mbuf[seen] = '\0';
2347             }
2348             BIO_printf(sbio,
2349                        "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>");
2350             seen = BIO_read(sbio, sbuf, BUFSIZZ);
2351             if (seen < 0) {
2352                 BIO_printf(bio_err, "BIO_read failed\n");
2353                 goto shut;
2354             }
2355             sbuf[seen] = '\0';
2356             if (!strstr(sbuf, "<proceed"))
2357                 goto shut;
2358             mbuf[0] = '\0';
2359         }
2360         break;
2361     case PROTO_TELNET:
2362         {
2363             static const unsigned char tls_do[] = {
2364                 /* IAC    DO   START_TLS */
2365                    255,   253, 46
2366             };
2367             static const unsigned char tls_will[] = {
2368                 /* IAC  WILL START_TLS */
2369                    255, 251, 46
2370             };
2371             static const unsigned char tls_follows[] = {
2372                 /* IAC  SB   START_TLS FOLLOWS IAC  SE */
2373                    255, 250, 46,       1,      255, 240
2374             };
2375             int bytes;
2376
2377             /* Telnet server should demand we issue START_TLS */
2378             bytes = BIO_read(sbio, mbuf, BUFSIZZ);
2379             if (bytes != 3 || memcmp(mbuf, tls_do, 3) != 0)
2380                 goto shut;
2381             /* Agree to issue START_TLS and send the FOLLOWS sub-command */
2382             BIO_write(sbio, tls_will, 3);
2383             BIO_write(sbio, tls_follows, 6);
2384             (void)BIO_flush(sbio);
2385             /* Telnet server also sent the FOLLOWS sub-command */
2386             bytes = BIO_read(sbio, mbuf, BUFSIZZ);
2387             if (bytes != 6 || memcmp(mbuf, tls_follows, 6) != 0)
2388                 goto shut;
2389         }
2390         break;
2391     case PROTO_CONNECT:
2392         if (!OSSL_HTTP_proxy_connect(sbio, host, port, proxyuser, proxypass,
2393                                      0 /* no timeout */, bio_err, prog))
2394             goto shut;
2395         break;
2396     case PROTO_IRC:
2397         {
2398             int numeric;
2399             BIO *fbio = BIO_new(BIO_f_buffer());
2400
2401             BIO_push(fbio, sbio);
2402             BIO_printf(fbio, "STARTTLS\r\n");
2403             (void)BIO_flush(fbio);
2404             width = SSL_get_fd(con) + 1;
2405
2406             do {
2407                 numeric = 0;
2408
2409                 FD_ZERO(&readfds);
2410                 openssl_fdset(SSL_get_fd(con), &readfds);
2411                 timeout.tv_sec = S_CLIENT_IRC_READ_TIMEOUT;
2412                 timeout.tv_usec = 0;
2413                 /*
2414                  * If the IRCd doesn't respond within
2415                  * S_CLIENT_IRC_READ_TIMEOUT seconds, assume
2416                  * it doesn't support STARTTLS. Many IRCds
2417                  * will not give _any_ sort of response to a
2418                  * STARTTLS command when it's not supported.
2419                  */
2420                 if (!BIO_get_buffer_num_lines(fbio)
2421                     && !BIO_pending(fbio)
2422                     && !BIO_pending(sbio)
2423                     && select(width, (void *)&readfds, NULL, NULL,
2424                               &timeout) < 1) {
2425                     BIO_printf(bio_err,
2426                                "Timeout waiting for response (%d seconds).\n",
2427                                S_CLIENT_IRC_READ_TIMEOUT);
2428                     break;
2429                 }
2430
2431                 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
2432                 if (mbuf_len < 1 || sscanf(mbuf, "%*s %d", &numeric) != 1)
2433                     break;
2434                 /* :example.net 451 STARTTLS :You have not registered */
2435                 /* :example.net 421 STARTTLS :Unknown command */
2436                 if ((numeric == 451 || numeric == 421)
2437                     && strstr(mbuf, "STARTTLS") != NULL) {
2438                     BIO_printf(bio_err, "STARTTLS not supported: %s", mbuf);
2439                     break;
2440                 }
2441                 if (numeric == 691) {
2442                     BIO_printf(bio_err, "STARTTLS negotiation failed: ");
2443                     ERR_print_errors(bio_err);
2444                     break;
2445                 }
2446             } while (numeric != 670);
2447
2448             (void)BIO_flush(fbio);
2449             BIO_pop(fbio);
2450             BIO_free(fbio);
2451             if (numeric != 670) {
2452                 BIO_printf(bio_err, "Server does not support STARTTLS.\n");
2453                 ret = 1;
2454                 goto shut;
2455             }
2456         }
2457         break;
2458     case PROTO_MYSQL:
2459         {
2460             /* SSL request packet */
2461             static const unsigned char ssl_req[] = {
2462                 /* payload_length,   sequence_id */
2463                    0x20, 0x00, 0x00, 0x01,
2464                 /* payload */
2465                 /* capability flags, CLIENT_SSL always set */
2466                    0x85, 0xae, 0x7f, 0x00,
2467                 /* max-packet size */
2468                    0x00, 0x00, 0x00, 0x01,
2469                 /* character set */
2470                    0x21,
2471                 /* string[23] reserved (all [0]) */
2472                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2473                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2474                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2475             };
2476             int bytes = 0;
2477             int ssl_flg = 0x800;
2478             int pos;
2479             const unsigned char *packet = (const unsigned char *)sbuf;
2480
2481             /* Receiving Initial Handshake packet. */
2482             bytes = BIO_read(sbio, (void *)packet, BUFSIZZ);
2483             if (bytes < 0) {
2484                 BIO_printf(bio_err, "BIO_read failed\n");
2485                 goto shut;
2486             /* Packet length[3], Packet number[1] + minimum payload[17] */
2487             } else if (bytes < 21) {
2488                 BIO_printf(bio_err, "MySQL packet too short.\n");
2489                 goto shut;
2490             } else if (bytes != (4 + packet[0] +
2491                                  (packet[1] << 8) +
2492                                  (packet[2] << 16))) {
2493                 BIO_printf(bio_err, "MySQL packet length does not match.\n");
2494                 goto shut;
2495             /* protocol version[1] */
2496             } else if (packet[4] != 0xA) {
2497                 BIO_printf(bio_err,
2498                            "Only MySQL protocol version 10 is supported.\n");
2499                 goto shut;
2500             }
2501
2502             pos = 5;
2503             /* server version[string+NULL] */
2504             for (;;) {
2505                 if (pos >= bytes) {
2506                     BIO_printf(bio_err, "Cannot confirm server version. ");
2507                     goto shut;
2508                 } else if (packet[pos++] == '\0') {
2509                     break;
2510                 }
2511             }
2512
2513             /* make sure we have at least 15 bytes left in the packet */
2514             if (pos + 15 > bytes) {
2515                 BIO_printf(bio_err,
2516                            "MySQL server handshake packet is broken.\n");
2517                 goto shut;
2518             }
2519
2520             pos += 12; /* skip over conn id[4] + SALT[8] */
2521             if (packet[pos++] != '\0') { /* verify filler */
2522                 BIO_printf(bio_err,
2523                            "MySQL packet is broken.\n");
2524                 goto shut;
2525             }
2526
2527             /* capability flags[2] */
2528             if (!((packet[pos] + (packet[pos + 1] << 8)) & ssl_flg)) {
2529                 BIO_printf(bio_err, "MySQL server does not support SSL.\n");
2530                 goto shut;
2531             }
2532
2533             /* Sending SSL Handshake packet. */
2534             BIO_write(sbio, ssl_req, sizeof(ssl_req));
2535             (void)BIO_flush(sbio);
2536         }
2537         break;
2538     case PROTO_POSTGRES:
2539         {
2540             static const unsigned char ssl_request[] = {
2541                 /* Length        SSLRequest */
2542                    0, 0, 0, 8,   4, 210, 22, 47
2543             };
2544             int bytes;
2545
2546             /* Send SSLRequest packet */
2547             BIO_write(sbio, ssl_request, 8);
2548             (void)BIO_flush(sbio);
2549
2550             /* Reply will be a single S if SSL is enabled */
2551             bytes = BIO_read(sbio, sbuf, BUFSIZZ);
2552             if (bytes != 1 || sbuf[0] != 'S')
2553                 goto shut;
2554         }
2555         break;
2556     case PROTO_NNTP:
2557         {
2558             int foundit = 0;
2559             BIO *fbio = BIO_new(BIO_f_buffer());
2560
2561             BIO_push(fbio, sbio);
2562             BIO_gets(fbio, mbuf, BUFSIZZ);
2563             /* STARTTLS command requires CAPABILITIES... */
2564             BIO_printf(fbio, "CAPABILITIES\r\n");
2565             (void)BIO_flush(fbio);
2566             BIO_gets(fbio, mbuf, BUFSIZZ);
2567             /* no point in trying to parse the CAPABILITIES response if there is none */
2568             if (strstr(mbuf, "101") != NULL) {
2569                 /* wait for multi-line CAPABILITIES response */
2570                 do {
2571                     mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
2572                     if (strstr(mbuf, "STARTTLS"))
2573                         foundit = 1;
2574                 } while (mbuf_len > 1 && mbuf[0] != '.');
2575             }
2576             (void)BIO_flush(fbio);
2577             BIO_pop(fbio);
2578             BIO_free(fbio);
2579             if (!foundit)
2580                 BIO_printf(bio_err,
2581                            "Didn't find STARTTLS in server response,"
2582                            " trying anyway...\n");
2583             BIO_printf(sbio, "STARTTLS\r\n");
2584             mbuf_len = BIO_read(sbio, mbuf, BUFSIZZ);
2585             if (mbuf_len < 0) {
2586                 BIO_printf(bio_err, "BIO_read failed\n");
2587                 goto end;
2588             }
2589             mbuf[mbuf_len] = '\0';
2590             if (strstr(mbuf, "382") == NULL) {
2591                 BIO_printf(bio_err, "STARTTLS failed: %s", mbuf);
2592                 goto shut;
2593             }
2594         }
2595         break;
2596     case PROTO_SIEVE:
2597         {
2598             int foundit = 0;
2599             BIO *fbio = BIO_new(BIO_f_buffer());
2600
2601             BIO_push(fbio, sbio);
2602             /* wait for multi-line response to end from Sieve */
2603             do {
2604                 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ);
2605                 /*
2606                  * According to RFC 5804 § 1.7, capability
2607                  * is case-insensitive, make it uppercase
2608                  */
2609                 if (mbuf_len > 1 && mbuf[0] == '"') {
2610                     make_uppercase(mbuf);
2611                     if (strncmp(mbuf, "\"STARTTLS\"", 10) == 0)
2612                         foundit = 1;
2613                 }
2614             } while (mbuf_len > 1 && mbuf[0] == '"');
2615             (void)BIO_flush(fbio);
2616             BIO_pop(fbio);
2617             BIO_free(fbio);
2618             if (!foundit)
2619                 BIO_printf(bio_err,
2620                            "Didn't find STARTTLS in server response,"
2621                            " trying anyway...\n");
2622             BIO_printf(sbio, "STARTTLS\r\n");
2623             mbuf_len = BIO_read(sbio, mbuf, BUFSIZZ);
2624             if (mbuf_len < 0) {
2625                 BIO_printf(bio_err, "BIO_read failed\n");
2626                 goto end;
2627             }
2628             mbuf[mbuf_len] = '\0';
2629             if (mbuf_len < 2) {
2630                 BIO_printf(bio_err, "STARTTLS failed: %s", mbuf);
2631                 goto shut;
2632             }
2633             /*
2634              * According to RFC 5804 § 2.2, response codes are case-
2635              * insensitive, make it uppercase but preserve the response.
2636              */
2637             strncpy(sbuf, mbuf, 2);
2638             make_uppercase(sbuf);
2639             if (strncmp(sbuf, "OK", 2) != 0) {
2640                 BIO_printf(bio_err, "STARTTLS not supported: %s", mbuf);
2641                 goto shut;
2642             }
2643         }
2644         break;
2645     case PROTO_LDAP:
2646         {
2647             /* StartTLS Operation according to RFC 4511 */
2648             static char ldap_tls_genconf[] = "asn1=SEQUENCE:LDAPMessage\n"
2649                 "[LDAPMessage]\n"
2650                 "messageID=INTEGER:1\n"
2651                 "extendedReq=EXPLICIT:23A,IMPLICIT:0C,"
2652                 "FORMAT:ASCII,OCT:1.3.6.1.4.1.1466.20037\n";
2653             long errline = -1;
2654             char *genstr = NULL;
2655             int result = -1;
2656             ASN1_TYPE *atyp = NULL;
2657             BIO *ldapbio = BIO_new(BIO_s_mem());
2658             CONF *cnf = NCONF_new(NULL);
2659
2660             if (cnf == NULL) {
2661                 BIO_free(ldapbio);
2662                 goto end;
2663             }
2664             BIO_puts(ldapbio, ldap_tls_genconf);
2665             if (NCONF_load_bio(cnf, ldapbio, &errline) <= 0) {
2666                 BIO_free(ldapbio);
2667                 NCONF_free(cnf);
2668                 if (errline <= 0) {
2669                     BIO_printf(bio_err, "NCONF_load_bio failed\n");
2670                     goto end;
2671                 } else {
2672                     BIO_printf(bio_err, "Error on line %ld\n", errline);
2673                     goto end;
2674                 }
2675             }
2676             BIO_free(ldapbio);
2677             genstr = NCONF_get_string(cnf, "default", "asn1");
2678             if (genstr == NULL) {
2679                 NCONF_free(cnf);
2680                 BIO_printf(bio_err, "NCONF_get_string failed\n");
2681                 goto end;
2682             }
2683             atyp = ASN1_generate_nconf(genstr, cnf);
2684             if (atyp == NULL) {
2685                 NCONF_free(cnf);
2686                 BIO_printf(bio_err, "ASN1_generate_nconf failed\n");
2687                 goto end;
2688             }
2689             NCONF_free(cnf);
2690
2691             /* Send SSLRequest packet */
2692             BIO_write(sbio, atyp->value.sequence->data,
2693                       atyp->value.sequence->length);
2694             (void)BIO_flush(sbio);
2695             ASN1_TYPE_free(atyp);
2696
2697             mbuf_len = BIO_read(sbio, mbuf, BUFSIZZ);
2698             if (mbuf_len < 0) {
2699                 BIO_printf(bio_err, "BIO_read failed\n");
2700                 goto end;
2701             }
2702             result = ldap_ExtendedResponse_parse(mbuf, mbuf_len);
2703             if (result < 0) {
2704                 BIO_printf(bio_err, "ldap_ExtendedResponse_parse failed\n");
2705                 goto shut;
2706             } else if (result > 0) {
2707                 BIO_printf(bio_err, "STARTTLS failed, LDAP Result Code: %i\n",
2708                            result);
2709                 goto shut;
2710             }
2711             mbuf_len = 0;
2712         }
2713         break;
2714     }
2715
2716     if (early_data_file != NULL
2717             && ((SSL_get0_session(con) != NULL
2718                  && SSL_SESSION_get_max_early_data(SSL_get0_session(con)) > 0)
2719                 || (psksess != NULL
2720                     && SSL_SESSION_get_max_early_data(psksess) > 0))) {
2721         BIO *edfile = BIO_new_file(early_data_file, "r");
2722         size_t readbytes, writtenbytes;
2723         int finish = 0;
2724
2725         if (edfile == NULL) {
2726             BIO_printf(bio_err, "Cannot open early data file\n");
2727             goto shut;
2728         }
2729
2730         while (!finish) {
2731             if (!BIO_read_ex(edfile, cbuf, BUFSIZZ, &readbytes))
2732                 finish = 1;
2733
2734             while (!SSL_write_early_data(con, cbuf, readbytes, &writtenbytes)) {
2735                 switch (SSL_get_error(con, 0)) {
2736                 case SSL_ERROR_WANT_WRITE:
2737                 case SSL_ERROR_WANT_ASYNC:
2738                 case SSL_ERROR_WANT_READ:
2739                     /* Just keep trying - busy waiting */
2740                     continue;
2741                 default:
2742                     BIO_printf(bio_err, "Error writing early data\n");
2743                     BIO_free(edfile);
2744                     ERR_print_errors(bio_err);
2745                     goto shut;
2746                 }
2747             }
2748         }
2749
2750         BIO_free(edfile);
2751     }
2752
2753     for (;;) {
2754         FD_ZERO(&readfds);
2755         FD_ZERO(&writefds);
2756
2757         if (SSL_is_dtls(con) && DTLSv1_get_timeout(con, &timeout))
2758             timeoutp = &timeout;
2759         else
2760             timeoutp = NULL;
2761
2762         if (!SSL_is_init_finished(con) && SSL_total_renegotiations(con) == 0
2763                 && SSL_get_key_update_type(con) == SSL_KEY_UPDATE_NONE) {
2764             in_init = 1;
2765             tty_on = 0;
2766         } else {
2767             tty_on = 1;
2768             if (in_init) {
2769                 in_init = 0;
2770
2771                 if (c_brief) {
2772                     BIO_puts(bio_err, "CONNECTION ESTABLISHED\n");
2773                     print_ssl_summary(con);
2774                 }
2775
2776                 print_stuff(bio_c_out, con, full_log);
2777                 if (full_log > 0)
2778                     full_log--;
2779
2780                 if (starttls_proto) {
2781                     BIO_write(bio_err, mbuf, mbuf_len);
2782                     /* We don't need to know any more */
2783                     if (!reconnect)
2784                         starttls_proto = PROTO_OFF;
2785                 }
2786
2787                 if (reconnect) {
2788                     reconnect--;
2789                     BIO_printf(bio_c_out,
2790                                "drop connection and then reconnect\n");
2791                     do_ssl_shutdown(con);
2792                     SSL_set_connect_state(con);
2793                     BIO_closesocket(SSL_get_fd(con));
2794                     goto re_start;
2795                 }
2796             }
2797         }
2798
2799         ssl_pending = read_ssl && SSL_has_pending(con);
2800
2801         if (!ssl_pending) {
2802 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS)
2803             if (tty_on) {
2804                 /*
2805                  * Note that select() returns when read _would not block_,
2806                  * and EOF satisfies that.  To avoid a CPU-hogging loop,
2807                  * set the flag so we exit.
2808                  */
2809                 if (read_tty && !at_eof)
2810                     openssl_fdset(fileno_stdin(), &readfds);
2811 #if !defined(OPENSSL_SYS_VMS)
2812                 if (write_tty)
2813                     openssl_fdset(fileno_stdout(), &writefds);
2814 #endif
2815             }
2816             if (read_ssl)
2817                 openssl_fdset(SSL_get_fd(con), &readfds);
2818             if (write_ssl)
2819                 openssl_fdset(SSL_get_fd(con), &writefds);
2820 #else
2821             if (!tty_on || !write_tty) {
2822                 if (read_ssl)
2823                     openssl_fdset(SSL_get_fd(con), &readfds);
2824                 if (write_ssl)
2825                     openssl_fdset(SSL_get_fd(con), &writefds);
2826             }
2827 #endif
2828
2829             /*
2830              * Note: under VMS with SOCKETSHR the second parameter is
2831              * currently of type (int *) whereas under other systems it is
2832              * (void *) if you don't have a cast it will choke the compiler:
2833              * if you do have a cast then you can either go for (int *) or
2834              * (void *).
2835              */
2836 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS)
2837             /*
2838              * Under Windows/DOS we make the assumption that we can always
2839              * write to the tty: therefore if we need to write to the tty we
2840              * just fall through. Otherwise we timeout the select every
2841              * second and see if there are any keypresses. Note: this is a
2842              * hack, in a proper Windows application we wouldn't do this.
2843              */
2844             i = 0;
2845             if (!write_tty) {
2846                 if (read_tty) {
2847                     tv.tv_sec = 1;
2848                     tv.tv_usec = 0;
2849                     i = select(width, (void *)&readfds, (void *)&writefds,
2850                                NULL, &tv);
2851                     if (!i && (!has_stdin_waiting() || !read_tty))
2852                         continue;
2853                 } else
2854                     i = select(width, (void *)&readfds, (void *)&writefds,
2855                                NULL, timeoutp);
2856             }
2857 #else
2858             i = select(width, (void *)&readfds, (void *)&writefds,
2859                        NULL, timeoutp);
2860 #endif
2861             if (i < 0) {
2862                 BIO_printf(bio_err, "bad select %d\n",
2863                            get_last_socket_error());
2864                 goto shut;
2865             }
2866         }
2867
2868         if (SSL_is_dtls(con) && DTLSv1_handle_timeout(con) > 0)
2869             BIO_printf(bio_err, "TIMEOUT occurred\n");
2870
2871         if (!ssl_pending && FD_ISSET(SSL_get_fd(con), &writefds)) {
2872             k = SSL_write(con, &(cbuf[cbuf_off]), (unsigned int)cbuf_len);
2873             switch (SSL_get_error(con, k)) {
2874             case SSL_ERROR_NONE:
2875                 cbuf_off += k;
2876                 cbuf_len -= k;
2877                 if (k <= 0)
2878                     goto end;
2879                 /* we have done a  write(con,NULL,0); */
2880                 if (cbuf_len <= 0) {
2881                     read_tty = 1;
2882                     write_ssl = 0;
2883                 } else {        /* if (cbuf_len > 0) */
2884
2885                     read_tty = 0;
2886                     write_ssl = 1;
2887                 }
2888                 break;
2889             case SSL_ERROR_WANT_WRITE:
2890                 BIO_printf(bio_c_out, "write W BLOCK\n");
2891                 write_ssl = 1;
2892                 read_tty = 0;
2893                 break;
2894             case SSL_ERROR_WANT_ASYNC:
2895                 BIO_printf(bio_c_out, "write A BLOCK\n");
2896                 wait_for_async(con);
2897                 write_ssl = 1;
2898                 read_tty = 0;
2899                 break;
2900             case SSL_ERROR_WANT_READ:
2901                 BIO_printf(bio_c_out, "write R BLOCK\n");
2902                 write_tty = 0;
2903                 read_ssl = 1;
2904                 write_ssl = 0;
2905                 break;
2906             case SSL_ERROR_WANT_X509_LOOKUP:
2907                 BIO_printf(bio_c_out, "write X BLOCK\n");
2908                 break;
2909             case SSL_ERROR_ZERO_RETURN:
2910                 if (cbuf_len != 0) {
2911                     BIO_printf(bio_c_out, "shutdown\n");
2912                     ret = 0;
2913                     goto shut;
2914                 } else {
2915                     read_tty = 1;
2916                     write_ssl = 0;
2917                     break;
2918                 }
2919
2920             case SSL_ERROR_SYSCALL:
2921                 if ((k != 0) || (cbuf_len != 0)) {
2922                     BIO_printf(bio_err, "write:errno=%d\n",
2923                                get_last_socket_error());
2924                     goto shut;
2925                 } else {
2926                     read_tty = 1;
2927                     write_ssl = 0;
2928                 }
2929                 break;
2930             case SSL_ERROR_WANT_ASYNC_JOB:
2931                 /* This shouldn't ever happen in s_client - treat as an error */
2932             case SSL_ERROR_SSL:
2933                 ERR_print_errors(bio_err);
2934                 goto shut;
2935             }
2936         }
2937 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_VMS)
2938         /* Assume Windows/DOS/BeOS can always write */
2939         else if (!ssl_pending && write_tty)
2940 #else
2941         else if (!ssl_pending && FD_ISSET(fileno_stdout(), &writefds))
2942 #endif
2943         {
2944 #ifdef CHARSET_EBCDIC
2945             ascii2ebcdic(&(sbuf[sbuf_off]), &(sbuf[sbuf_off]), sbuf_len);
2946 #endif
2947             i = raw_write_stdout(&(sbuf[sbuf_off]), sbuf_len);
2948
2949             if (i <= 0) {
2950                 BIO_printf(bio_c_out, "DONE\n");
2951                 ret = 0;
2952                 goto shut;
2953             }
2954
2955             sbuf_len -= i;
2956             sbuf_off += i;
2957             if (sbuf_len <= 0) {
2958                 read_ssl = 1;
2959                 write_tty = 0;
2960             }
2961         } else if (ssl_pending || FD_ISSET(SSL_get_fd(con), &readfds)) {
2962 #ifdef RENEG
2963             {
2964                 static int iiii;
2965                 if (++iiii == 52) {
2966                     SSL_renegotiate(con);
2967                     iiii = 0;
2968                 }
2969             }
2970 #endif
2971             k = SSL_read(con, sbuf, 1024 /* BUFSIZZ */ );
2972
2973             switch (SSL_get_error(con, k)) {
2974             case SSL_ERROR_NONE:
2975                 if (k <= 0)
2976                     goto end;
2977                 sbuf_off = 0;
2978                 sbuf_len = k;
2979
2980                 read_ssl = 0;
2981                 write_tty = 1;
2982                 break;
2983             case SSL_ERROR_WANT_ASYNC:
2984                 BIO_printf(bio_c_out, "read A BLOCK\n");
2985                 wait_for_async(con);
2986                 write_tty = 0;
2987                 read_ssl = 1;
2988                 if ((read_tty == 0) && (write_ssl == 0))
2989                     write_ssl = 1;
2990                 break;
2991             case SSL_ERROR_WANT_WRITE:
2992                 BIO_printf(bio_c_out, "read W BLOCK\n");
2993                 write_ssl = 1;
2994                 read_tty = 0;
2995                 break;
2996             case SSL_ERROR_WANT_READ:
2997                 BIO_printf(bio_c_out, "read R BLOCK\n");
2998                 write_tty = 0;
2999                 read_ssl = 1;
3000                 if ((read_tty == 0) && (write_ssl == 0))
3001                     write_ssl = 1;
3002                 break;
3003             case SSL_ERROR_WANT_X509_LOOKUP:
3004                 BIO_printf(bio_c_out, "read X BLOCK\n");
3005                 break;
3006             case SSL_ERROR_SYSCALL:
3007                 ret = get_last_socket_error();
3008                 if (c_brief)
3009                     BIO_puts(bio_err, "CONNECTION CLOSED BY SERVER\n");
3010                 else
3011                     BIO_printf(bio_err, "read:errno=%d\n", ret);
3012                 goto shut;
3013             case SSL_ERROR_ZERO_RETURN:
3014                 BIO_printf(bio_c_out, "closed\n");
3015                 ret = 0;
3016                 goto shut;
3017             case SSL_ERROR_WANT_ASYNC_JOB:
3018                 /* This shouldn't ever happen in s_client. Treat as an error */
3019             case SSL_ERROR_SSL:
3020                 ERR_print_errors(bio_err);
3021                 goto shut;
3022             }
3023         }
3024 /* OPENSSL_SYS_MSDOS includes OPENSSL_SYS_WINDOWS */
3025 #if defined(OPENSSL_SYS_MSDOS)
3026         else if (has_stdin_waiting())
3027 #else
3028         else if (FD_ISSET(fileno_stdin(), &readfds))
3029 #endif
3030         {
3031             if (crlf) {
3032                 int j, lf_num;
3033
3034                 i = raw_read_stdin(cbuf, BUFSIZZ / 2);
3035                 lf_num = 0;
3036                 /* both loops are skipped when i <= 0 */
3037                 for (j = 0; j < i; j++)
3038                     if (cbuf[j] == '\n')
3039                         lf_num++;
3040                 for (j = i - 1; j >= 0; j--) {
3041                     cbuf[j + lf_num] = cbuf[j];
3042                     if (cbuf[j] == '\n') {
3043                         lf_num--;
3044                         i++;
3045                         cbuf[j + lf_num] = '\r';
3046                     }
3047                 }
3048                 assert(lf_num == 0);
3049             } else
3050                 i = raw_read_stdin(cbuf, BUFSIZZ);
3051 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS)
3052             if (i == 0)
3053                 at_eof = 1;
3054 #endif
3055
3056             if ((!c_ign_eof) && ((i <= 0) || (cbuf[0] == 'Q' && cmdletters))) {
3057                 BIO_printf(bio_err, "DONE\n");
3058                 ret = 0;
3059                 goto shut;
3060             }
3061
3062             if ((!c_ign_eof) && (cbuf[0] == 'R' && cmdletters)) {
3063                 BIO_printf(bio_err, "RENEGOTIATING\n");
3064                 SSL_renegotiate(con);
3065                 cbuf_len = 0;
3066             } else if (!c_ign_eof && (cbuf[0] == 'K' || cbuf[0] == 'k' )
3067                     && cmdletters) {
3068                 BIO_printf(bio_err, "KEYUPDATE\n");
3069                 SSL_key_update(con,
3070                                cbuf[0] == 'K' ? SSL_KEY_UPDATE_REQUESTED
3071                                               : SSL_KEY_UPDATE_NOT_REQUESTED);
3072                 cbuf_len = 0;
3073             } else {
3074                 cbuf_len = i;
3075                 cbuf_off = 0;
3076 #ifdef CHARSET_EBCDIC
3077                 ebcdic2ascii(cbuf, cbuf, i);
3078 #endif
3079             }
3080
3081             write_ssl = 1;
3082             read_tty = 0;
3083         }
3084     }
3085
3086     ret = 0;
3087  shut:
3088     if (in_init)
3089         print_stuff(bio_c_out, con, full_log);
3090     do_ssl_shutdown(con);
3091
3092     /*
3093      * If we ended with an alert being sent, but still with data in the
3094      * network buffer to be read, then calling BIO_closesocket() will
3095      * result in a TCP-RST being sent. On some platforms (notably
3096      * Windows) then this will result in the peer immediately abandoning
3097      * the connection including any buffered alert data before it has
3098      * had a chance to be read. Shutting down the sending side first,
3099      * and then closing the socket sends TCP-FIN first followed by
3100      * TCP-RST. This seems to allow the peer to read the alert data.
3101      */
3102     shutdown(SSL_get_fd(con), 1); /* SHUT_WR */
3103     /*
3104      * We just said we have nothing else to say, but it doesn't mean that
3105      * the other side has nothing. It's even recommended to consume incoming
3106      * data. [In testing context this ensures that alerts are passed on...]
3107      */
3108     timeout.tv_sec = 0;
3109     timeout.tv_usec = 500000;  /* some extreme round-trip */
3110     do {
3111         FD_ZERO(&readfds);
3112         openssl_fdset(sock, &readfds);
3113     } while (select(sock + 1, &readfds, NULL, NULL, &timeout) > 0
3114              && BIO_read(sbio, sbuf, BUFSIZZ) > 0);
3115
3116     BIO_closesocket(SSL_get_fd(con));
3117  end:
3118     if (con != NULL) {
3119         if (prexit != 0)
3120             print_stuff(bio_c_out, con, 1);
3121         SSL_free(con);
3122     }
3123     SSL_SESSION_free(psksess);
3124 #if !defined(OPENSSL_NO_NEXTPROTONEG)
3125     OPENSSL_free(next_proto.data);
3126 #endif
3127     SSL_CTX_free(ctx);
3128     set_keylog_file(NULL, NULL);
3129     X509_free(cert);
3130     sk_X509_CRL_pop_free(crls, X509_CRL_free);
3131     EVP_PKEY_free(key);
3132     sk_X509_pop_free(chain, X509_free);
3133     OPENSSL_free(pass);
3134 #ifndef OPENSSL_NO_SRP
3135     OPENSSL_free(srp_arg.srppassin);
3136 #endif
3137     OPENSSL_free(connectstr);
3138     OPENSSL_free(bindstr);
3139     OPENSSL_free(host);
3140     OPENSSL_free(port);
3141     X509_VERIFY_PARAM_free(vpm);
3142     ssl_excert_free(exc);
3143     sk_OPENSSL_STRING_free(ssl_args);
3144     sk_OPENSSL_STRING_free(dane_tlsa_rrset);
3145     SSL_CONF_CTX_free(cctx);
3146     OPENSSL_clear_free(cbuf, BUFSIZZ);
3147     OPENSSL_clear_free(sbuf, BUFSIZZ);
3148     OPENSSL_clear_free(mbuf, BUFSIZZ);
3149     clear_free(proxypass);
3150     release_engine(e);
3151     BIO_free(bio_c_out);
3152     bio_c_out = NULL;
3153     BIO_free(bio_c_msg);
3154     bio_c_msg = NULL;
3155     return ret;
3156 }
3157
3158 static void print_stuff(BIO *bio, SSL *s, int full)
3159 {
3160     X509 *peer = NULL;
3161     STACK_OF(X509) *sk;
3162     const SSL_CIPHER *c;
3163     EVP_PKEY *public_key;
3164     int i, istls13 = (SSL_version(s) == TLS1_3_VERSION);
3165     long verify_result;
3166 #ifndef OPENSSL_NO_COMP
3167     const COMP_METHOD *comp, *expansion;
3168 #endif
3169     unsigned char *exportedkeymat;
3170 #ifndef OPENSSL_NO_CT
3171     const SSL_CTX *ctx = SSL_get_SSL_CTX(s);
3172 #endif
3173
3174     if (full) {
3175         int got_a_chain = 0;
3176
3177         sk = SSL_get_peer_cert_chain(s);
3178         if (sk != NULL) {
3179             got_a_chain = 1;
3180
3181             BIO_printf(bio, "---\nCertificate chain\n");
3182             for (i = 0; i < sk_X509_num(sk); i++) {
3183                 BIO_printf(bio, "%2d s:", i);
3184                 X509_NAME_print_ex(bio, X509_get_subject_name(sk_X509_value(sk, i)), 0, get_nameopt());
3185                 BIO_puts(bio, "\n");
3186                 BIO_printf(bio, "   i:");
3187                 X509_NAME_print_ex(bio, X509_get_issuer_name(sk_X509_value(sk, i)), 0, get_nameopt());
3188                 BIO_puts(bio, "\n");
3189                 public_key = X509_get_pubkey(sk_X509_value(sk, i));
3190                 if (public_key != NULL) {
3191                     BIO_printf(bio, "   a:PKEY: %s, %d (bit); sigalg: %s\n",
3192                                OBJ_nid2sn(EVP_PKEY_base_id(public_key)),
3193                                EVP_PKEY_bits(public_key),
3194                                OBJ_nid2sn(X509_get_signature_nid(sk_X509_value(sk, i))));
3195                     EVP_PKEY_free(public_key);
3196                 }
3197                 BIO_printf(bio, "   v:NotBefore: ");
3198                 ASN1_TIME_print(bio, X509_get0_notBefore(sk_X509_value(sk, i)));
3199                 BIO_printf(bio, "; NotAfter: ");
3200                 ASN1_TIME_print(bio, X509_get0_notAfter(sk_X509_value(sk, i)));
3201                 BIO_puts(bio, "\n");
3202                 if (c_showcerts)
3203                     PEM_write_bio_X509(bio, sk_X509_value(sk, i));
3204             }
3205         }
3206
3207         BIO_printf(bio, "---\n");
3208         peer = SSL_get_peer_certificate(s);
3209         if (peer != NULL) {
3210             BIO_printf(bio, "Server certificate\n");
3211
3212             /* Redundant if we showed the whole chain */
3213             if (!(c_showcerts && got_a_chain))
3214                 PEM_write_bio_X509(bio, peer);
3215             dump_cert_text(bio, peer);
3216         } else {
3217             BIO_printf(bio, "no peer certificate available\n");
3218         }
3219         print_ca_names(bio, s);
3220
3221         ssl_print_sigalgs(bio, s);
3222         ssl_print_tmp_key(bio, s);
3223
3224 #ifndef OPENSSL_NO_CT
3225         /*
3226          * When the SSL session is anonymous, or resumed via an abbreviated
3227          * handshake, no SCTs are provided as part of the handshake.  While in
3228          * a resumed session SCTs may be present in the session's certificate,
3229          * no callbacks are invoked to revalidate these, and in any case that
3230          * set of SCTs may be incomplete.  Thus it makes little sense to
3231          * attempt to display SCTs from a resumed session's certificate, and of
3232          * course none are associated with an anonymous peer.
3233          */
3234         if (peer != NULL && !SSL_session_reused(s) && SSL_ct_is_enabled(s)) {
3235             const STACK_OF(SCT) *scts = SSL_get0_peer_scts(s);
3236             int sct_count = scts != NULL ? sk_SCT_num(scts) : 0;
3237
3238             BIO_printf(bio, "---\nSCTs present (%i)\n", sct_count);
3239             if (sct_count > 0) {
3240                 const CTLOG_STORE *log_store = SSL_CTX_get0_ctlog_store(ctx);
3241
3242                 BIO_printf(bio, "---\n");
3243                 for (i = 0; i < sct_count; ++i) {
3244                     SCT *sct = sk_SCT_value(scts, i);
3245
3246                     BIO_printf(bio, "SCT validation status: %s\n",
3247                                SCT_validation_status_string(sct));
3248                     SCT_print(sct, bio, 0, log_store);
3249                     if (i < sct_count - 1)
3250                         BIO_printf(bio, "\n---\n");
3251                 }
3252                 BIO_printf(bio, "\n");
3253             }
3254         }
3255 #endif
3256
3257         BIO_printf(bio,
3258                    "---\nSSL handshake has read %ju bytes "
3259                    "and written %ju bytes\n",
3260                    BIO_number_read(SSL_get_rbio(s)),
3261                    BIO_number_written(SSL_get_wbio(s)));
3262     }
3263     print_verify_detail(s, bio);
3264     BIO_printf(bio, (SSL_session_reused(s) ? "---\nReused, " : "---\nNew, "));
3265     c = SSL_get_current_cipher(s);
3266     BIO_printf(bio, "%s, Cipher is %s\n",
3267                SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c));
3268     if (peer != NULL) {
3269         EVP_PKEY *pktmp;
3270
3271         pktmp = X509_get0_pubkey(peer);
3272         BIO_printf(bio, "Server public key is %d bit\n",
3273                    EVP_PKEY_bits(pktmp));
3274     }
3275     BIO_printf(bio, "Secure Renegotiation IS%s supported\n",
3276                SSL_get_secure_renegotiation_support(s) ? "" : " NOT");
3277 #ifndef OPENSSL_NO_COMP
3278     comp = SSL_get_current_compression(s);
3279     expansion = SSL_get_current_expansion(s);
3280     BIO_printf(bio, "Compression: %s\n",
3281                comp ? SSL_COMP_get_name(comp) : "NONE");
3282     BIO_printf(bio, "Expansion: %s\n",
3283                expansion ? SSL_COMP_get_name(expansion) : "NONE");
3284 #endif
3285 #ifndef OPENSSL_NO_KTLS
3286     if (BIO_get_ktls_send(SSL_get_wbio(s)))
3287         BIO_printf(bio_err, "Using Kernel TLS for sending\n");
3288     if (BIO_get_ktls_recv(SSL_get_rbio(s)))
3289         BIO_printf(bio_err, "Using Kernel TLS for receiving\n");
3290 #endif
3291
3292     if (OSSL_TRACE_ENABLED(TLS)) {
3293         /* Print out local port of connection: useful for debugging */
3294         int sock;
3295         union BIO_sock_info_u info;
3296
3297         sock = SSL_get_fd(s);
3298         if ((info.addr = BIO_ADDR_new()) != NULL
3299             && BIO_sock_info(sock, BIO_SOCK_INFO_ADDRESS, &info)) {
3300             BIO_printf(bio_c_out, "LOCAL PORT is %u\n",
3301                        ntohs(BIO_ADDR_rawport(info.addr)));
3302         }
3303         BIO_ADDR_free(info.addr);
3304     }
3305
3306 #if !defined(OPENSSL_NO_NEXTPROTONEG)
3307     if (next_proto.status != -1) {
3308         const unsigned char *proto;
3309         unsigned int proto_len;
3310         SSL_get0_next_proto_negotiated(s, &proto, &proto_len);
3311         BIO_printf(bio, "Next protocol: (%d) ", next_proto.status);
3312         BIO_write(bio, proto, proto_len);
3313         BIO_write(bio, "\n", 1);
3314     }
3315 #endif
3316     {
3317         const unsigned char *proto;
3318         unsigned int proto_len;
3319         SSL_get0_alpn_selected(s, &proto, &proto_len);
3320         if (proto_len > 0) {
3321             BIO_printf(bio, "ALPN protocol: ");
3322             BIO_write(bio, proto, proto_len);
3323             BIO_write(bio, "\n", 1);
3324         } else
3325             BIO_printf(bio, "No ALPN negotiated\n");
3326     }
3327
3328 #ifndef OPENSSL_NO_SRTP
3329     {
3330         SRTP_PROTECTION_PROFILE *srtp_profile =
3331             SSL_get_selected_srtp_profile(s);
3332
3333         if (srtp_profile)
3334             BIO_printf(bio, "SRTP Extension negotiated, profile=%s\n",
3335                        srtp_profile->name);
3336     }
3337 #endif
3338
3339     if (istls13) {
3340         switch (SSL_get_early_data_status(s)) {
3341         case SSL_EARLY_DATA_NOT_SENT:
3342             BIO_printf(bio, "Early data was not sent\n");
3343             break;
3344
3345         case SSL_EARLY_DATA_REJECTED:
3346             BIO_printf(bio, "Early data was rejected\n");
3347             break;
3348
3349         case SSL_EARLY_DATA_ACCEPTED:
3350             BIO_printf(bio, "Early data was accepted\n");
3351             break;
3352
3353         }
3354
3355         /*
3356          * We also print the verify results when we dump session information,
3357          * but in TLSv1.3 we may not get that right away (or at all) depending
3358          * on when we get a NewSessionTicket. Therefore we print it now as well.
3359          */
3360         verify_result = SSL_get_verify_result(s);
3361         BIO_printf(bio, "Verify return code: %ld (%s)\n", verify_result,
3362                    X509_verify_cert_error_string(verify_result));
3363     } else {
3364         /* In TLSv1.3 we do this on arrival of a NewSessionTicket */
3365         SSL_SESSION_print(bio, SSL_get_session(s));
3366     }
3367
3368     if (SSL_get_session(s) != NULL && keymatexportlabel != NULL) {
3369         BIO_printf(bio, "Keying material exporter:\n");
3370         BIO_printf(bio, "    Label: '%s'\n", keymatexportlabel);
3371         BIO_printf(bio, "    Length: %i bytes\n", keymatexportlen);
3372         exportedkeymat = app_malloc(keymatexportlen, "export key");
3373         if (!SSL_export_keying_material(s, exportedkeymat,
3374                                         keymatexportlen,
3375                                         keymatexportlabel,
3376                                         strlen(keymatexportlabel),
3377                                         NULL, 0, 0)) {
3378             BIO_printf(bio, "    Error\n");
3379         } else {
3380             BIO_printf(bio, "    Keying material: ");
3381             for (i = 0; i < keymatexportlen; i++)
3382                 BIO_printf(bio, "%02X", exportedkeymat[i]);
3383             BIO_printf(bio, "\n");
3384         }
3385         OPENSSL_free(exportedkeymat);
3386     }
3387     BIO_printf(bio, "---\n");
3388     X509_free(peer);
3389     /* flush, or debugging output gets mixed with http response */
3390     (void)BIO_flush(bio);
3391 }
3392
3393 # ifndef OPENSSL_NO_OCSP
3394 static int ocsp_resp_cb(SSL *s, void *arg)
3395 {
3396     const unsigned char *p;
3397     int len;
3398     OCSP_RESPONSE *rsp;
3399     len = SSL_get_tlsext_status_ocsp_resp(s, &p);
3400     BIO_puts(arg, "OCSP response: ");
3401     if (p == NULL) {
3402         BIO_puts(arg, "no response sent\n");
3403         return 1;
3404     }
3405     rsp = d2i_OCSP_RESPONSE(NULL, &p, len);
3406     if (rsp == NULL) {
3407         BIO_puts(arg, "response parse error\n");
3408         BIO_dump_indent(arg, (char *)p, len, 4);
3409         return 0;
3410     }
3411     BIO_puts(arg, "\n======================================\n");
3412     OCSP_RESPONSE_print(arg, rsp, 0);
3413     BIO_puts(arg, "======================================\n");
3414     OCSP_RESPONSE_free(rsp);
3415     return 1;
3416 }
3417 # endif
3418
3419 static int ldap_ExtendedResponse_parse(const char *buf, long rem)
3420 {
3421     const unsigned char *cur, *end;
3422     long len;
3423     int tag, xclass, inf, ret = -1;
3424
3425     cur = (const unsigned char *)buf;
3426     end = cur + rem;
3427
3428     /*
3429      * From RFC 4511:
3430      *
3431      *    LDAPMessage ::= SEQUENCE {
3432      *         messageID       MessageID,
3433      *         protocolOp      CHOICE {
3434      *              ...
3435      *              extendedResp          ExtendedResponse,
3436      *              ... },
3437      *         controls       [0] Controls OPTIONAL }
3438      *
3439      *    ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
3440      *         COMPONENTS OF LDAPResult,
3441      *         responseName     [10] LDAPOID OPTIONAL,
3442      *         responseValue    [11] OCTET STRING OPTIONAL }
3443      *
3444      *    LDAPResult ::= SEQUENCE {
3445      *         resultCode         ENUMERATED {
3446      *              success                      (0),
3447      *              ...
3448      *              other                        (80),
3449      *              ...  },
3450      *         matchedDN          LDAPDN,
3451      *         diagnosticMessage  LDAPString,
3452      *         referral           [3] Referral OPTIONAL }
3453      */
3454
3455     /* pull SEQUENCE */
3456     inf = ASN1_get_object(&cur, &len, &tag, &xclass, rem);
3457     if (inf != V_ASN1_CONSTRUCTED || tag != V_ASN1_SEQUENCE ||
3458         (rem = end - cur, len > rem)) {
3459         BIO_printf(bio_err, "Unexpected LDAP response\n");
3460         goto end;
3461     }
3462
3463     rem = len;  /* ensure that we don't overstep the SEQUENCE */
3464
3465     /* pull MessageID */
3466     inf = ASN1_get_object(&cur, &len, &tag, &xclass, rem);
3467     if (inf != V_ASN1_UNIVERSAL || tag != V_ASN1_INTEGER ||
3468         (rem = end - cur, len > rem)) {
3469         BIO_printf(bio_err, "No MessageID\n");
3470         goto end;
3471     }
3472
3473     cur += len; /* shall we check for MessageId match or just skip? */
3474
3475     /* pull [APPLICATION 24] */
3476     rem = end - cur;
3477     inf = ASN1_get_object(&cur, &len, &tag, &xclass, rem);
3478     if (inf != V_ASN1_CONSTRUCTED || xclass != V_ASN1_APPLICATION ||
3479         tag != 24) {
3480         BIO_printf(bio_err, "Not ExtendedResponse\n");
3481         goto end;
3482     }
3483
3484     /* pull resultCode */
3485     rem = end - cur;
3486     inf = ASN1_get_object(&cur, &len, &tag, &xclass, rem);
3487     if (inf != V_ASN1_UNIVERSAL || tag != V_ASN1_ENUMERATED || len == 0 ||
3488         (rem = end - cur, len > rem)) {
3489         BIO_printf(bio_err, "Not LDAPResult\n");
3490         goto end;
3491     }
3492
3493     /* len should always be one, but just in case... */
3494     for (ret = 0, inf = 0; inf < len; inf++) {
3495         ret <<= 8;
3496         ret |= cur[inf];
3497     }
3498     /* There is more data, but we don't care... */
3499  end:
3500     return ret;
3501 }
3502
3503 /*
3504  * Host dNS Name verifier: used for checking that the hostname is in dNS format
3505  * before setting it as SNI
3506  */
3507 static int is_dNS_name(const char *host)
3508 {
3509     const size_t MAX_LABEL_LENGTH = 63;
3510     size_t i;
3511     int isdnsname = 0;