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