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