s_client.c revision 1.14.2.1
1 /* 2 * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the OpenSSL license (the "License"). You may not use 5 * this file except in compliance with the License. You can obtain a copy 6 * in the file LICENSE in the source distribution or at 7 * https://www.openssl.org/source/license.html 8 */ 9 10 /* ==================================================================== 11 * Copyright 2005 Nokia. All rights reserved. 12 * 13 * The portions of the attached software ("Contribution") is developed by 14 * Nokia Corporation and is licensed pursuant to the OpenSSL open source 15 * license. 16 * 17 * The Contribution, originally written by Mika Kousa and Pasi Eronen of 18 * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites 19 * support (see RFC 4279) to OpenSSL. 20 * 21 * No patent licenses or other rights except those expressly stated in 22 * the OpenSSL open source license shall be deemed granted or received 23 * expressly, by implication, estoppel, or otherwise. 24 * 25 * No assurances are provided by Nokia that the Contribution does not 26 * infringe the patent or other intellectual property rights of any third 27 * party or that the license provides you with all the necessary rights 28 * to make use of the Contribution. 29 * 30 * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN 31 * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA 32 * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY 33 * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR 34 * OTHERWISE. 35 */ 36 37 #include <ctype.h> 38 #include <stdio.h> 39 #include <stdlib.h> 40 #include <string.h> 41 #include <errno.h> 42 #include <openssl/e_os2.h> 43 44 #ifndef OPENSSL_NO_SOCK 45 46 /* 47 * With IPv6, it looks like Digital has mixed up the proper order of 48 * recursive header file inclusion, resulting in the compiler complaining 49 * that u_int isn't defined, but only if _POSIX_C_SOURCE is defined, which is 50 * needed to have fileno() declared correctly... So let's define u_int 51 */ 52 #if defined(OPENSSL_SYS_VMS_DECC) && !defined(__U_INT) 53 # define __U_INT 54 typedef unsigned int u_int; 55 #endif 56 57 #define USE_SOCKETS 58 #include "apps.h" 59 #include <openssl/x509.h> 60 #include <openssl/ssl.h> 61 #include <openssl/err.h> 62 #include <openssl/pem.h> 63 #include <openssl/rand.h> 64 #include <openssl/ocsp.h> 65 #include <openssl/bn.h> 66 #include <openssl/async.h> 67 #ifndef OPENSSL_NO_SRP 68 # include <openssl/srp.h> 69 #endif 70 #ifndef OPENSSL_NO_CT 71 # include <openssl/ct.h> 72 #endif 73 #include "s_apps.h" 74 #include "timeouts.h" 75 76 #if defined(__has_feature) 77 # if __has_feature(memory_sanitizer) 78 # include <sanitizer/msan_interface.h> 79 # endif 80 #endif 81 82 #undef BUFSIZZ 83 #define BUFSIZZ 1024*8 84 #define S_CLIENT_IRC_READ_TIMEOUT 8 85 86 static char *prog; 87 static int c_debug = 0; 88 static int c_showcerts = 0; 89 static char *keymatexportlabel = NULL; 90 static int keymatexportlen = 20; 91 static BIO *bio_c_out = NULL; 92 static int c_quiet = 0; 93 94 static void print_stuff(BIO *berr, SSL *con, int full); 95 #ifndef OPENSSL_NO_OCSP 96 static int ocsp_resp_cb(SSL *s, void *arg); 97 #endif 98 99 static int saved_errno; 100 101 static void save_errno(void) 102 { 103 saved_errno = errno; 104 errno = 0; 105 } 106 107 static int restore_errno(void) 108 { 109 int ret = errno; 110 errno = saved_errno; 111 return ret; 112 } 113 114 static void do_ssl_shutdown(SSL *ssl) 115 { 116 int ret; 117 118 do { 119 /* We only do unidirectional shutdown */ 120 ret = SSL_shutdown(ssl); 121 if (ret < 0) { 122 switch (SSL_get_error(ssl, ret)) { 123 case SSL_ERROR_WANT_READ: 124 case SSL_ERROR_WANT_WRITE: 125 case SSL_ERROR_WANT_ASYNC: 126 case SSL_ERROR_WANT_ASYNC_JOB: 127 /* We just do busy waiting. Nothing clever */ 128 continue; 129 } 130 ret = 0; 131 } 132 } while (ret < 0); 133 } 134 135 #ifndef OPENSSL_NO_PSK 136 /* Default PSK identity and key */ 137 static char *psk_identity = "Client_identity"; 138 /* 139 * char *psk_key=NULL; by default PSK is not used 140 */ 141 142 static unsigned int psk_client_cb(SSL *ssl, const char *hint, char *identity, 143 unsigned int max_identity_len, 144 unsigned char *psk, 145 unsigned int max_psk_len) 146 { 147 int ret; 148 long key_len; 149 unsigned char *key; 150 151 if (c_debug) 152 BIO_printf(bio_c_out, "psk_client_cb\n"); 153 if (!hint) { 154 /* no ServerKeyExchange message */ 155 if (c_debug) 156 BIO_printf(bio_c_out, 157 "NULL received PSK identity hint, continuing anyway\n"); 158 } else if (c_debug) 159 BIO_printf(bio_c_out, "Received PSK identity hint '%s'\n", hint); 160 161 /* 162 * lookup PSK identity and PSK key based on the given identity hint here 163 */ 164 ret = BIO_snprintf(identity, max_identity_len, "%s", psk_identity); 165 if (ret < 0 || (unsigned int)ret > max_identity_len) 166 goto out_err; 167 if (c_debug) 168 BIO_printf(bio_c_out, "created identity '%s' len=%d\n", identity, 169 ret); 170 171 /* convert the PSK key to binary */ 172 key = OPENSSL_hexstr2buf(psk_key, &key_len); 173 if (key == NULL) { 174 BIO_printf(bio_err, "Could not convert PSK key '%s' to buffer\n", 175 psk_key); 176 return 0; 177 } 178 if (max_psk_len > INT_MAX || key_len > (long)max_psk_len) { 179 BIO_printf(bio_err, 180 "psk buffer of callback is too small (%d) for key (%ld)\n", 181 max_psk_len, key_len); 182 OPENSSL_free(key); 183 return 0; 184 } 185 186 memcpy(psk, key, key_len); 187 OPENSSL_free(key); 188 189 if (c_debug) 190 BIO_printf(bio_c_out, "created PSK len=%ld\n", key_len); 191 192 return key_len; 193 out_err: 194 if (c_debug) 195 BIO_printf(bio_err, "Error in PSK client callback\n"); 196 return 0; 197 } 198 #endif 199 200 /* This is a context that we pass to callbacks */ 201 typedef struct tlsextctx_st { 202 BIO *biodebug; 203 int ack; 204 } tlsextctx; 205 206 static int ssl_servername_cb(SSL *s, int *ad, void *arg) 207 { 208 tlsextctx *p = (tlsextctx *) arg; 209 const char *hn = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name); 210 if (SSL_get_servername_type(s) != -1) 211 p->ack = !SSL_session_reused(s) && hn != NULL; 212 else 213 BIO_printf(bio_err, "Can't use SSL_get_servername\n"); 214 215 return SSL_TLSEXT_ERR_OK; 216 } 217 218 #ifndef OPENSSL_NO_SRP 219 220 /* This is a context that we pass to all callbacks */ 221 typedef struct srp_arg_st { 222 char *srppassin; 223 char *srplogin; 224 int msg; /* copy from c_msg */ 225 int debug; /* copy from c_debug */ 226 int amp; /* allow more groups */ 227 int strength; /* minimal size for N */ 228 } SRP_ARG; 229 230 # define SRP_NUMBER_ITERATIONS_FOR_PRIME 64 231 232 static int srp_Verify_N_and_g(const BIGNUM *N, const BIGNUM *g) 233 { 234 BN_CTX *bn_ctx = BN_CTX_new(); 235 BIGNUM *p = BN_new(); 236 BIGNUM *r = BN_new(); 237 int ret = 238 g != NULL && N != NULL && bn_ctx != NULL && BN_is_odd(N) && 239 BN_is_prime_ex(N, SRP_NUMBER_ITERATIONS_FOR_PRIME, bn_ctx, NULL) == 1 && 240 p != NULL && BN_rshift1(p, N) && 241 /* p = (N-1)/2 */ 242 BN_is_prime_ex(p, SRP_NUMBER_ITERATIONS_FOR_PRIME, bn_ctx, NULL) == 1 && 243 r != NULL && 244 /* verify g^((N-1)/2) == -1 (mod N) */ 245 BN_mod_exp(r, g, p, N, bn_ctx) && 246 BN_add_word(r, 1) && BN_cmp(r, N) == 0; 247 248 BN_free(r); 249 BN_free(p); 250 BN_CTX_free(bn_ctx); 251 return ret; 252 } 253 254 /*- 255 * This callback is used here for two purposes: 256 * - extended debugging 257 * - making some primality tests for unknown groups 258 * The callback is only called for a non default group. 259 * 260 * An application does not need the call back at all if 261 * only the standard groups are used. In real life situations, 262 * client and server already share well known groups, 263 * thus there is no need to verify them. 264 * Furthermore, in case that a server actually proposes a group that 265 * is not one of those defined in RFC 5054, it is more appropriate 266 * to add the group to a static list and then compare since 267 * primality tests are rather cpu consuming. 268 */ 269 270 static int ssl_srp_verify_param_cb(SSL *s, void *arg) 271 { 272 SRP_ARG *srp_arg = (SRP_ARG *)arg; 273 BIGNUM *N = NULL, *g = NULL; 274 275 if (((N = SSL_get_srp_N(s)) == NULL) || ((g = SSL_get_srp_g(s)) == NULL)) 276 return 0; 277 if (srp_arg->debug || srp_arg->msg || srp_arg->amp == 1) { 278 BIO_printf(bio_err, "SRP parameters:\n"); 279 BIO_printf(bio_err, "\tN="); 280 BN_print(bio_err, N); 281 BIO_printf(bio_err, "\n\tg="); 282 BN_print(bio_err, g); 283 BIO_printf(bio_err, "\n"); 284 } 285 286 if (SRP_check_known_gN_param(g, N)) 287 return 1; 288 289 if (srp_arg->amp == 1) { 290 if (srp_arg->debug) 291 BIO_printf(bio_err, 292 "SRP param N and g are not known params, going to check deeper.\n"); 293 294 /* 295 * The srp_moregroups is a real debugging feature. Implementors 296 * should rather add the value to the known ones. The minimal size 297 * has already been tested. 298 */ 299 if (BN_num_bits(g) <= BN_BITS && srp_Verify_N_and_g(N, g)) 300 return 1; 301 } 302 BIO_printf(bio_err, "SRP param N and g rejected.\n"); 303 return 0; 304 } 305 306 # define PWD_STRLEN 1024 307 308 static char *ssl_give_srp_client_pwd_cb(SSL *s, void *arg) 309 { 310 SRP_ARG *srp_arg = (SRP_ARG *)arg; 311 char *pass = app_malloc(PWD_STRLEN + 1, "SRP password buffer"); 312 PW_CB_DATA cb_tmp; 313 int l; 314 315 cb_tmp.password = (char *)srp_arg->srppassin; 316 cb_tmp.prompt_info = "SRP user"; 317 if ((l = password_callback(pass, PWD_STRLEN, 0, &cb_tmp)) < 0) { 318 BIO_printf(bio_err, "Can't read Password\n"); 319 OPENSSL_free(pass); 320 return NULL; 321 } 322 *(pass + l) = '\0'; 323 324 return pass; 325 } 326 327 #endif 328 329 static char *srtp_profiles = NULL; 330 331 #ifndef OPENSSL_NO_NEXTPROTONEG 332 /* This the context that we pass to next_proto_cb */ 333 typedef struct tlsextnextprotoctx_st { 334 unsigned char *data; 335 size_t len; 336 int status; 337 } tlsextnextprotoctx; 338 339 static tlsextnextprotoctx next_proto; 340 341 static int next_proto_cb(SSL *s, unsigned char **out, unsigned char *outlen, 342 const unsigned char *in, unsigned int inlen, 343 void *arg) 344 { 345 tlsextnextprotoctx *ctx = arg; 346 347 if (!c_quiet) { 348 /* We can assume that |in| is syntactically valid. */ 349 unsigned i; 350 BIO_printf(bio_c_out, "Protocols advertised by server: "); 351 for (i = 0; i < inlen;) { 352 if (i) 353 BIO_write(bio_c_out, ", ", 2); 354 BIO_write(bio_c_out, &in[i + 1], in[i]); 355 i += in[i] + 1; 356 } 357 BIO_write(bio_c_out, "\n", 1); 358 } 359 360 ctx->status = 361 SSL_select_next_proto(out, outlen, in, inlen, ctx->data, ctx->len); 362 return SSL_TLSEXT_ERR_OK; 363 } 364 #endif /* ndef OPENSSL_NO_NEXTPROTONEG */ 365 366 static int serverinfo_cli_parse_cb(SSL *s, unsigned int ext_type, 367 const unsigned char *in, size_t inlen, 368 int *al, void *arg) 369 { 370 char pem_name[100]; 371 unsigned char ext_buf[4 + 65536]; 372 373 /* Reconstruct the type/len fields prior to extension data */ 374 ext_buf[0] = ext_type >> 8; 375 ext_buf[1] = ext_type & 0xFF; 376 ext_buf[2] = inlen >> 8; 377 ext_buf[3] = inlen & 0xFF; 378 memcpy(ext_buf + 4, in, inlen); 379 380 BIO_snprintf(pem_name, sizeof(pem_name), "SERVERINFO FOR EXTENSION %d", 381 ext_type); 382 PEM_write_bio(bio_c_out, pem_name, "", ext_buf, 4 + inlen); 383 return 1; 384 } 385 386 /* 387 * Hex decoder that tolerates optional whitespace. Returns number of bytes 388 * produced, advances inptr to end of input string. 389 */ 390 static ossl_ssize_t hexdecode(const char **inptr, void *result) 391 { 392 unsigned char **out = (unsigned char **)result; 393 const char *in = *inptr; 394 unsigned char *ret = app_malloc(strlen(in) / 2, "hexdecode"); 395 unsigned char *cp = ret; 396 uint8_t byte; 397 int nibble = 0; 398 399 if (ret == NULL) 400 return -1; 401 402 for (byte = 0; *in; ++in) { 403 int x; 404 405 if (isspace(_UC(*in))) 406 continue; 407 x = OPENSSL_hexchar2int(*in); 408 if (x < 0) { 409 OPENSSL_free(ret); 410 return 0; 411 } 412 byte |= (char)x; 413 if ((nibble ^= 1) == 0) { 414 *cp++ = byte; 415 byte = 0; 416 } else { 417 byte <<= 4; 418 } 419 } 420 if (nibble != 0) { 421 OPENSSL_free(ret); 422 return 0; 423 } 424 *inptr = in; 425 426 return cp - (*out = ret); 427 } 428 429 /* 430 * Decode unsigned 0..255, returns 1 on success, <= 0 on failure. Advances 431 * inptr to next field skipping leading whitespace. 432 */ 433 static ossl_ssize_t checked_uint8(const char **inptr, void *out) 434 { 435 uint8_t *result = (uint8_t *)out; 436 const char *in = *inptr; 437 char *endp; 438 long v; 439 int e; 440 441 save_errno(); 442 v = strtol(in, &endp, 10); 443 e = restore_errno(); 444 445 if (((v == LONG_MIN || v == LONG_MAX) && e == ERANGE) || 446 endp == in || !isspace(_UC(*endp)) || 447 v != (*result = (uint8_t) v)) { 448 return -1; 449 } 450 for (in = endp; isspace(_UC(*in)); ++in) 451 continue; 452 453 *inptr = in; 454 return 1; 455 } 456 457 struct tlsa_field { 458 void *var; 459 const char *name; 460 ossl_ssize_t (*parser)(const char **, void *); 461 }; 462 463 static int tlsa_import_rr(SSL *con, const char *rrdata) 464 { 465 /* Not necessary to re-init these values; the "parsers" do that. */ 466 static uint8_t usage; 467 static uint8_t selector; 468 static uint8_t mtype; 469 static unsigned char *data; 470 static struct tlsa_field tlsa_fields[] = { 471 { &usage, "usage", checked_uint8 }, 472 { &selector, "selector", checked_uint8 }, 473 { &mtype, "mtype", checked_uint8 }, 474 { &data, "data", hexdecode }, 475 { NULL, } 476 }; 477 struct tlsa_field *f; 478 int ret; 479 const char *cp = rrdata; 480 ossl_ssize_t len = 0; 481 482 for (f = tlsa_fields; f->var; ++f) { 483 /* Returns number of bytes produced, advances cp to next field */ 484 if ((len = f->parser(&cp, f->var)) <= 0) { 485 BIO_printf(bio_err, "%s: warning: bad TLSA %s field in: %s\n", 486 prog, f->name, rrdata); 487 return 0; 488 } 489 } 490 /* The data field is last, so len is its length */ 491 ret = SSL_dane_tlsa_add(con, usage, selector, mtype, data, len); 492 OPENSSL_free(data); 493 494 if (ret == 0) { 495 ERR_print_errors(bio_err); 496 BIO_printf(bio_err, "%s: warning: unusable TLSA rrdata: %s\n", 497 prog, rrdata); 498 return 0; 499 } 500 if (ret < 0) { 501 ERR_print_errors(bio_err); 502 BIO_printf(bio_err, "%s: warning: error loading TLSA rrdata: %s\n", 503 prog, rrdata); 504 return 0; 505 } 506 return ret; 507 } 508 509 static int tlsa_import_rrset(SSL *con, STACK_OF(OPENSSL_STRING) *rrset) 510 { 511 int num = sk_OPENSSL_STRING_num(rrset); 512 int count = 0; 513 int i; 514 515 for (i = 0; i < num; ++i) { 516 char *rrdata = sk_OPENSSL_STRING_value(rrset, i); 517 if (tlsa_import_rr(con, rrdata) > 0) 518 ++count; 519 } 520 return count > 0; 521 } 522 523 typedef enum OPTION_choice { 524 OPT_ERR = -1, OPT_EOF = 0, OPT_HELP, 525 OPT_4, OPT_6, OPT_HOST, OPT_PORT, OPT_CONNECT, OPT_UNIX, 526 OPT_XMPPHOST, OPT_VERIFY, 527 OPT_CERT, OPT_CRL, OPT_CRL_DOWNLOAD, OPT_SESS_OUT, OPT_SESS_IN, 528 OPT_CERTFORM, OPT_CRLFORM, OPT_VERIFY_RET_ERROR, OPT_VERIFY_QUIET, 529 OPT_BRIEF, OPT_PREXIT, OPT_CRLF, OPT_QUIET, OPT_NBIO, 530 OPT_SSL_CLIENT_ENGINE, OPT_RAND, OPT_IGN_EOF, OPT_NO_IGN_EOF, 531 OPT_DEBUG, OPT_TLSEXTDEBUG, OPT_STATUS, OPT_WDEBUG, 532 OPT_MSG, OPT_MSGFILE, OPT_ENGINE, OPT_TRACE, OPT_SECURITY_DEBUG, 533 OPT_SECURITY_DEBUG_VERBOSE, OPT_SHOWCERTS, OPT_NBIO_TEST, OPT_STATE, 534 #ifndef OPENSSL_NO_PSK 535 OPT_PSK_IDENTITY, OPT_PSK, 536 #endif 537 #ifndef OPENSSL_NO_SRP 538 OPT_SRPUSER, OPT_SRPPASS, OPT_SRP_STRENGTH, OPT_SRP_LATEUSER, 539 OPT_SRP_MOREGROUPS, 540 #endif 541 OPT_SSL3, OPT_SSL_CONFIG, 542 OPT_TLS1_2, OPT_TLS1_1, OPT_TLS1, OPT_DTLS, OPT_DTLS1, 543 OPT_DTLS1_2, OPT_TIMEOUT, OPT_MTU, OPT_KEYFORM, OPT_PASS, 544 OPT_CERT_CHAIN, OPT_CAPATH, OPT_NOCAPATH, OPT_CHAINCAPATH, 545 OPT_VERIFYCAPATH, 546 OPT_KEY, OPT_RECONNECT, OPT_BUILD_CHAIN, OPT_CAFILE, OPT_NOCAFILE, 547 OPT_CHAINCAFILE, OPT_VERIFYCAFILE, OPT_NEXTPROTONEG, OPT_ALPN, 548 OPT_SERVERINFO, OPT_STARTTLS, OPT_SERVERNAME, 549 OPT_USE_SRTP, OPT_KEYMATEXPORT, OPT_KEYMATEXPORTLEN, OPT_SMTPHOST, 550 OPT_ASYNC, OPT_SPLIT_SEND_FRAG, OPT_MAX_PIPELINES, OPT_READ_BUF, 551 OPT_V_ENUM, 552 OPT_X_ENUM, 553 OPT_S_ENUM, 554 OPT_FALLBACKSCSV, OPT_NOCMDS, OPT_PROXY, OPT_DANE_TLSA_DOMAIN, 555 #ifndef OPENSSL_NO_CT 556 OPT_CT, OPT_NOCT, OPT_CTLOG_FILE, 557 #endif 558 OPT_DANE_TLSA_RRDATA, OPT_DANE_EE_NO_NAME 559 } OPTION_CHOICE; 560 561 OPTIONS s_client_options[] = { 562 {"help", OPT_HELP, '-', "Display this summary"}, 563 {"host", OPT_HOST, 's', "Use -connect instead"}, 564 {"port", OPT_PORT, 'p', "Use -connect instead"}, 565 {"connect", OPT_CONNECT, 's', 566 "TCP/IP where to connect (default is :" PORT ")"}, 567 {"proxy", OPT_PROXY, 's', 568 "Connect to via specified proxy to the real server"}, 569 #ifdef AF_UNIX 570 {"unix", OPT_UNIX, 's', "Connect over the specified Unix-domain socket"}, 571 #endif 572 {"4", OPT_4, '-', "Use IPv4 only"}, 573 #ifdef AF_INET6 574 {"6", OPT_6, '-', "Use IPv6 only"}, 575 #endif 576 {"verify", OPT_VERIFY, 'p', "Turn on peer certificate verification"}, 577 {"cert", OPT_CERT, '<', "Certificate file to use, PEM format assumed"}, 578 {"certform", OPT_CERTFORM, 'F', 579 "Certificate format (PEM or DER) PEM default"}, 580 {"key", OPT_KEY, 's', "Private key file to use, if not in -cert file"}, 581 {"keyform", OPT_KEYFORM, 'E', "Key format (PEM, DER or engine) PEM default"}, 582 {"pass", OPT_PASS, 's', "Private key file pass phrase source"}, 583 {"CApath", OPT_CAPATH, '/', "PEM format directory of CA's"}, 584 {"CAfile", OPT_CAFILE, '<', "PEM format file of CA's"}, 585 {"no-CAfile", OPT_NOCAFILE, '-', 586 "Do not load the default certificates file"}, 587 {"no-CApath", OPT_NOCAPATH, '-', 588 "Do not load certificates from the default certificates directory"}, 589 {"dane_tlsa_domain", OPT_DANE_TLSA_DOMAIN, 's', "DANE TLSA base domain"}, 590 {"dane_tlsa_rrdata", OPT_DANE_TLSA_RRDATA, 's', 591 "DANE TLSA rrdata presentation form"}, 592 {"dane_ee_no_namechecks", OPT_DANE_EE_NO_NAME, '-', 593 "Disable name checks when matching DANE-EE(3) TLSA records"}, 594 {"reconnect", OPT_RECONNECT, '-', 595 "Drop and re-make the connection with the same Session-ID"}, 596 {"showcerts", OPT_SHOWCERTS, '-', "Show all certificates in the chain"}, 597 {"debug", OPT_DEBUG, '-', "Extra output"}, 598 {"msg", OPT_MSG, '-', "Show protocol messages"}, 599 {"msgfile", OPT_MSGFILE, '>', 600 "File to send output of -msg or -trace, instead of stdout"}, 601 {"nbio_test", OPT_NBIO_TEST, '-', "More ssl protocol testing"}, 602 {"state", OPT_STATE, '-', "Print the ssl states"}, 603 {"crlf", OPT_CRLF, '-', "Convert LF from terminal into CRLF"}, 604 {"quiet", OPT_QUIET, '-', "No s_client output"}, 605 {"ign_eof", OPT_IGN_EOF, '-', "Ignore input eof (default when -quiet)"}, 606 {"no_ign_eof", OPT_NO_IGN_EOF, '-', "Don't ignore input eof"}, 607 {"starttls", OPT_STARTTLS, 's', 608 "Use the appropriate STARTTLS command before starting TLS"}, 609 {"xmpphost", OPT_XMPPHOST, 's', 610 "Host to use with \"-starttls xmpp[-server]\""}, 611 {"rand", OPT_RAND, 's', 612 "Load the file(s) into the random number generator"}, 613 {"sess_out", OPT_SESS_OUT, '>', "File to write SSL session to"}, 614 {"sess_in", OPT_SESS_IN, '<', "File to read SSL session from"}, 615 {"use_srtp", OPT_USE_SRTP, 's', 616 "Offer SRTP key management with a colon-separated profile list"}, 617 {"keymatexport", OPT_KEYMATEXPORT, 's', 618 "Export keying material using label"}, 619 {"keymatexportlen", OPT_KEYMATEXPORTLEN, 'p', 620 "Export len bytes of keying material (default 20)"}, 621 {"fallback_scsv", OPT_FALLBACKSCSV, '-', "Send the fallback SCSV"}, 622 {"name", OPT_SMTPHOST, 's', "Hostname to use for \"-starttls smtp\""}, 623 {"CRL", OPT_CRL, '<', "CRL file to use"}, 624 {"crl_download", OPT_CRL_DOWNLOAD, '-', "Download CRL from distribution points"}, 625 {"CRLform", OPT_CRLFORM, 'F', "CRL format (PEM or DER) PEM is default"}, 626 {"verify_return_error", OPT_VERIFY_RET_ERROR, '-', 627 "Close connection on verification error"}, 628 {"verify_quiet", OPT_VERIFY_QUIET, '-', "Restrict verify output to errors"}, 629 {"brief", OPT_BRIEF, '-', 630 "Restrict output to brief summary of connection parameters"}, 631 {"prexit", OPT_PREXIT, '-', 632 "Print session information when the program exits"}, 633 {"security_debug", OPT_SECURITY_DEBUG, '-', 634 "Enable security debug messages"}, 635 {"security_debug_verbose", OPT_SECURITY_DEBUG_VERBOSE, '-', 636 "Output more security debug output"}, 637 {"cert_chain", OPT_CERT_CHAIN, '<', 638 "Certificate chain file (in PEM format)"}, 639 {"chainCApath", OPT_CHAINCAPATH, '/', 640 "Use dir as certificate store path to build CA certificate chain"}, 641 {"verifyCApath", OPT_VERIFYCAPATH, '/', 642 "Use dir as certificate store path to verify CA certificate"}, 643 {"build_chain", OPT_BUILD_CHAIN, '-', "Build certificate chain"}, 644 {"chainCAfile", OPT_CHAINCAFILE, '<', 645 "CA file for certificate chain (PEM format)"}, 646 {"verifyCAfile", OPT_VERIFYCAFILE, '<', 647 "CA file for certificate verification (PEM format)"}, 648 {"nocommands", OPT_NOCMDS, '-', "Do not use interactive command letters"}, 649 {"servername", OPT_SERVERNAME, 's', 650 "Set TLS extension servername in ClientHello"}, 651 {"tlsextdebug", OPT_TLSEXTDEBUG, '-', 652 "Hex dump of all TLS extensions received"}, 653 #ifndef OPENSSL_NO_OCSP 654 {"status", OPT_STATUS, '-', "Request certificate status from server"}, 655 #endif 656 {"serverinfo", OPT_SERVERINFO, 's', 657 "types Send empty ClientHello extensions (comma-separated numbers)"}, 658 {"alpn", OPT_ALPN, 's', 659 "Enable ALPN extension, considering named protocols supported (comma-separated list)"}, 660 {"async", OPT_ASYNC, '-', "Support asynchronous operation"}, 661 {"ssl_config", OPT_SSL_CONFIG, 's', "Use specified configuration file"}, 662 {"split_send_frag", OPT_SPLIT_SEND_FRAG, 'n', 663 "Size used to split data for encrypt pipelines"}, 664 {"max_pipelines", OPT_MAX_PIPELINES, 'n', 665 "Maximum number of encrypt/decrypt pipelines to be used"}, 666 {"read_buf", OPT_READ_BUF, 'n', 667 "Default read buffer size to be used for connections"}, 668 OPT_S_OPTIONS, 669 OPT_V_OPTIONS, 670 OPT_X_OPTIONS, 671 #ifndef OPENSSL_NO_SSL3 672 {"ssl3", OPT_SSL3, '-', "Just use SSLv3"}, 673 #endif 674 #ifndef OPENSSL_NO_TLS1 675 {"tls1", OPT_TLS1, '-', "Just use TLSv1"}, 676 #endif 677 #ifndef OPENSSL_NO_TLS1_1 678 {"tls1_1", OPT_TLS1_1, '-', "Just use TLSv1.1"}, 679 #endif 680 #ifndef OPENSSL_NO_TLS1_2 681 {"tls1_2", OPT_TLS1_2, '-', "Just use TLSv1.2"}, 682 #endif 683 #ifndef OPENSSL_NO_DTLS 684 {"dtls", OPT_DTLS, '-', "Use any version of DTLS"}, 685 {"timeout", OPT_TIMEOUT, '-', 686 "Enable send/receive timeout on DTLS connections"}, 687 {"mtu", OPT_MTU, 'p', "Set the link layer MTU"}, 688 #endif 689 #ifndef OPENSSL_NO_DTLS1 690 {"dtls1", OPT_DTLS1, '-', "Just use DTLSv1"}, 691 #endif 692 #ifndef OPENSSL_NO_DTLS1_2 693 {"dtls1_2", OPT_DTLS1_2, '-', "Just use DTLSv1.2"}, 694 #endif 695 #ifndef OPENSSL_NO_SSL_TRACE 696 {"trace", OPT_TRACE, '-', "Show trace output of protocol messages"}, 697 #endif 698 #ifdef WATT32 699 {"wdebug", OPT_WDEBUG, '-', "WATT-32 tcp debugging"}, 700 #endif 701 {"nbio", OPT_NBIO, '-', "Use non-blocking IO"}, 702 #ifndef OPENSSL_NO_PSK 703 {"psk_identity", OPT_PSK_IDENTITY, 's', "PSK identity"}, 704 {"psk", OPT_PSK, 's', "PSK in hex (without 0x)"}, 705 #endif 706 #ifndef OPENSSL_NO_SRP 707 {"srpuser", OPT_SRPUSER, 's', "SRP authentication for 'user'"}, 708 {"srppass", OPT_SRPPASS, 's', "Password for 'user'"}, 709 {"srp_lateuser", OPT_SRP_LATEUSER, '-', 710 "SRP username into second ClientHello message"}, 711 {"srp_moregroups", OPT_SRP_MOREGROUPS, '-', 712 "Tolerate other than the known g N values."}, 713 {"srp_strength", OPT_SRP_STRENGTH, 'p', "Minimal length in bits for N"}, 714 #endif 715 #ifndef OPENSSL_NO_NEXTPROTONEG 716 {"nextprotoneg", OPT_NEXTPROTONEG, 's', 717 "Enable NPN extension, considering named protocols supported (comma-separated list)"}, 718 #endif 719 #ifndef OPENSSL_NO_ENGINE 720 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"}, 721 {"ssl_client_engine", OPT_SSL_CLIENT_ENGINE, 's', 722 "Specify engine to be used for client certificate operations"}, 723 #endif 724 #ifndef OPENSSL_NO_CT 725 {"ct", OPT_CT, '-', "Request and parse SCTs (also enables OCSP stapling)"}, 726 {"noct", OPT_NOCT, '-', "Do not request or parse SCTs (default)"}, 727 {"ctlogfile", OPT_CTLOG_FILE, '<', "CT log list CONF file"}, 728 #endif 729 {NULL, OPT_EOF, 0x00, NULL} 730 }; 731 732 typedef enum PROTOCOL_choice { 733 PROTO_OFF, 734 PROTO_SMTP, 735 PROTO_POP3, 736 PROTO_IMAP, 737 PROTO_FTP, 738 PROTO_TELNET, 739 PROTO_XMPP, 740 PROTO_XMPP_SERVER, 741 PROTO_CONNECT, 742 PROTO_IRC 743 } PROTOCOL_CHOICE; 744 745 static const OPT_PAIR services[] = { 746 {"smtp", PROTO_SMTP}, 747 {"pop3", PROTO_POP3}, 748 {"imap", PROTO_IMAP}, 749 {"ftp", PROTO_FTP}, 750 {"xmpp", PROTO_XMPP}, 751 {"xmpp-server", PROTO_XMPP_SERVER}, 752 {"telnet", PROTO_TELNET}, 753 {"irc", PROTO_IRC}, 754 {NULL, 0} 755 }; 756 757 #define IS_INET_FLAG(o) \ 758 (o == OPT_4 || o == OPT_6 || o == OPT_HOST || o == OPT_PORT || o == OPT_CONNECT) 759 #define IS_UNIX_FLAG(o) (o == OPT_UNIX) 760 761 #define IS_PROT_FLAG(o) \ 762 (o == OPT_SSL3 || o == OPT_TLS1 || o == OPT_TLS1_1 || o == OPT_TLS1_2 \ 763 || o == OPT_DTLS || o == OPT_DTLS1 || o == OPT_DTLS1_2) 764 765 /* Free |*dest| and optionally set it to a copy of |source|. */ 766 static void freeandcopy(char **dest, const char *source) 767 { 768 OPENSSL_free(*dest); 769 *dest = NULL; 770 if (source != NULL) 771 *dest = OPENSSL_strdup(source); 772 } 773 774 int s_client_main(int argc, char **argv) 775 { 776 BIO *sbio; 777 EVP_PKEY *key = NULL; 778 SSL *con = NULL; 779 SSL_CTX *ctx = NULL; 780 STACK_OF(X509) *chain = NULL; 781 X509 *cert = NULL; 782 X509_VERIFY_PARAM *vpm = NULL; 783 SSL_EXCERT *exc = NULL; 784 SSL_CONF_CTX *cctx = NULL; 785 STACK_OF(OPENSSL_STRING) *ssl_args = NULL; 786 char *dane_tlsa_domain = NULL; 787 STACK_OF(OPENSSL_STRING) *dane_tlsa_rrset = NULL; 788 int dane_ee_no_name = 0; 789 STACK_OF(X509_CRL) *crls = NULL; 790 const SSL_METHOD *meth = TLS_client_method(); 791 const char *CApath = NULL, *CAfile = NULL; 792 char *cbuf = NULL, *sbuf = NULL; 793 char *mbuf = NULL, *proxystr = NULL, *connectstr = NULL; 794 char *cert_file = NULL, *key_file = NULL, *chain_file = NULL; 795 char *chCApath = NULL, *chCAfile = NULL, *host = NULL; 796 char *port = OPENSSL_strdup(PORT); 797 char *inrand = NULL; 798 char *passarg = NULL, *pass = NULL, *vfyCApath = NULL, *vfyCAfile = NULL; 799 char *sess_in = NULL, *sess_out = NULL, *crl_file = NULL, *p; 800 char *xmpphost = NULL; 801 const char *ehlo = "mail.example.com"; 802 struct timeval timeout, *timeoutp; 803 fd_set readfds, writefds; 804 int noCApath = 0, noCAfile = 0; 805 int build_chain = 0, cbuf_len, cbuf_off, cert_format = FORMAT_PEM; 806 int key_format = FORMAT_PEM, crlf = 0, full_log = 1, mbuf_len = 0; 807 int prexit = 0; 808 int sdebug = 0; 809 int reconnect = 0, verify = SSL_VERIFY_NONE, vpmtouched = 0; 810 int ret = 1, in_init = 1, i, nbio_test = 0, s = -1, k, width, state = 0; 811 int sbuf_len, sbuf_off, cmdletters = 1; 812 int socket_family = AF_UNSPEC, socket_type = SOCK_STREAM; 813 int starttls_proto = PROTO_OFF, crl_format = FORMAT_PEM, crl_download = 0; 814 int write_tty, read_tty, write_ssl, read_ssl, tty_on, ssl_pending; 815 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) 816 int at_eof = 0; 817 #endif 818 int read_buf_len = 0; 819 int fallback_scsv = 0; 820 long randamt = 0; 821 OPTION_CHOICE o; 822 #ifndef OPENSSL_NO_DTLS 823 int enable_timeouts = 0; 824 long socket_mtu = 0; 825 #endif 826 #ifndef OPENSSL_NO_ENGINE 827 ENGINE *ssl_client_engine = NULL; 828 #endif 829 ENGINE *e = NULL; 830 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) 831 struct timeval tv; 832 #endif 833 char *servername = NULL; 834 const char *alpn_in = NULL; 835 tlsextctx tlsextcbp = { NULL, 0 }; 836 const char *ssl_config = NULL; 837 #define MAX_SI_TYPES 100 838 unsigned short serverinfo_types[MAX_SI_TYPES]; 839 int serverinfo_count = 0, start = 0, len; 840 #ifndef OPENSSL_NO_NEXTPROTONEG 841 const char *next_proto_neg_in = NULL; 842 #endif 843 #ifndef OPENSSL_NO_SRP 844 char *srppass = NULL; 845 int srp_lateuser = 0; 846 SRP_ARG srp_arg = { NULL, NULL, 0, 0, 0, 1024 }; 847 #endif 848 #ifndef OPENSSL_NO_CT 849 char *ctlog_file = NULL; 850 int ct_validation = 0; 851 #endif 852 int min_version = 0, max_version = 0, prot_opt = 0, no_prot_opt = 0; 853 int async = 0; 854 unsigned int split_send_fragment = 0; 855 unsigned int max_pipelines = 0; 856 enum { use_inet, use_unix, use_unknown } connect_type = use_unknown; 857 int count4or6 = 0; 858 int c_nbio = 0, c_msg = 0, c_ign_eof = 0, c_brief = 0; 859 int c_tlsextdebug = 0; 860 #ifndef OPENSSL_NO_OCSP 861 int c_status_req = 0; 862 #endif 863 BIO *bio_c_msg = NULL; 864 865 FD_ZERO(&readfds); 866 FD_ZERO(&writefds); 867 /* Known false-positive of MemorySanitizer. */ 868 #if defined(__has_feature) 869 # if __has_feature(memory_sanitizer) 870 __msan_unpoison(&readfds, sizeof(readfds)); 871 __msan_unpoison(&writefds, sizeof(writefds)); 872 # endif 873 #endif 874 875 prog = opt_progname(argv[0]); 876 c_quiet = 0; 877 c_debug = 0; 878 c_showcerts = 0; 879 c_nbio = 0; 880 vpm = X509_VERIFY_PARAM_new(); 881 cctx = SSL_CONF_CTX_new(); 882 883 if (vpm == NULL || cctx == NULL) { 884 BIO_printf(bio_err, "%s: out of memory\n", prog); 885 goto end; 886 } 887 888 cbuf = app_malloc(BUFSIZZ, "cbuf"); 889 sbuf = app_malloc(BUFSIZZ, "sbuf"); 890 mbuf = app_malloc(BUFSIZZ, "mbuf"); 891 892 SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CLIENT | SSL_CONF_FLAG_CMDLINE); 893 894 prog = opt_init(argc, argv, s_client_options); 895 while ((o = opt_next()) != OPT_EOF) { 896 /* Check for intermixing flags. */ 897 if (connect_type == use_unix && IS_INET_FLAG(o)) { 898 BIO_printf(bio_err, 899 "%s: Intermixed protocol flags (unix and internet domains)\n", 900 prog); 901 goto end; 902 } 903 if (connect_type == use_inet && IS_UNIX_FLAG(o)) { 904 BIO_printf(bio_err, 905 "%s: Intermixed protocol flags (internet and unix domains)\n", 906 prog); 907 goto end; 908 } 909 910 if (IS_PROT_FLAG(o) && ++prot_opt > 1) { 911 BIO_printf(bio_err, "Cannot supply multiple protocol flags\n"); 912 goto end; 913 } 914 if (IS_NO_PROT_FLAG(o)) 915 no_prot_opt++; 916 if (prot_opt == 1 && no_prot_opt) { 917 BIO_printf(bio_err, 918 "Cannot supply both a protocol flag and '-no_<prot>'\n"); 919 goto end; 920 } 921 922 switch (o) { 923 case OPT_EOF: 924 case OPT_ERR: 925 opthelp: 926 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog); 927 goto end; 928 case OPT_HELP: 929 opt_help(s_client_options); 930 ret = 0; 931 goto end; 932 case OPT_4: 933 connect_type = use_inet; 934 socket_family = AF_INET; 935 count4or6++; 936 break; 937 #ifdef AF_INET6 938 case OPT_6: 939 connect_type = use_inet; 940 socket_family = AF_INET6; 941 count4or6++; 942 break; 943 #endif 944 case OPT_HOST: 945 connect_type = use_inet; 946 freeandcopy(&host, opt_arg()); 947 break; 948 case OPT_PORT: 949 connect_type = use_inet; 950 freeandcopy(&port, opt_arg()); 951 break; 952 case OPT_CONNECT: 953 connect_type = use_inet; 954 freeandcopy(&connectstr, opt_arg()); 955 break; 956 case OPT_PROXY: 957 proxystr = opt_arg(); 958 starttls_proto = PROTO_CONNECT; 959 break; 960 #ifdef AF_UNIX 961 case OPT_UNIX: 962 connect_type = use_unix; 963 socket_family = AF_UNIX; 964 freeandcopy(&host, opt_arg()); 965 break; 966 #endif 967 case OPT_XMPPHOST: 968 xmpphost = opt_arg(); 969 break; 970 case OPT_SMTPHOST: 971 ehlo = opt_arg(); 972 break; 973 case OPT_VERIFY: 974 verify = SSL_VERIFY_PEER; 975 verify_args.depth = atoi(opt_arg()); 976 if (!c_quiet) 977 BIO_printf(bio_err, "verify depth is %d\n", verify_args.depth); 978 break; 979 case OPT_CERT: 980 cert_file = opt_arg(); 981 break; 982 case OPT_CRL: 983 crl_file = opt_arg(); 984 break; 985 case OPT_CRL_DOWNLOAD: 986 crl_download = 1; 987 break; 988 case OPT_SESS_OUT: 989 sess_out = opt_arg(); 990 break; 991 case OPT_SESS_IN: 992 sess_in = opt_arg(); 993 break; 994 case OPT_CERTFORM: 995 if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &cert_format)) 996 goto opthelp; 997 break; 998 case OPT_CRLFORM: 999 if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &crl_format)) 1000 goto opthelp; 1001 break; 1002 case OPT_VERIFY_RET_ERROR: 1003 verify_args.return_error = 1; 1004 break; 1005 case OPT_VERIFY_QUIET: 1006 verify_args.quiet = 1; 1007 break; 1008 case OPT_BRIEF: 1009 c_brief = verify_args.quiet = c_quiet = 1; 1010 break; 1011 case OPT_S_CASES: 1012 if (ssl_args == NULL) 1013 ssl_args = sk_OPENSSL_STRING_new_null(); 1014 if (ssl_args == NULL 1015 || !sk_OPENSSL_STRING_push(ssl_args, opt_flag()) 1016 || !sk_OPENSSL_STRING_push(ssl_args, opt_arg())) { 1017 BIO_printf(bio_err, "%s: Memory allocation failure\n", prog); 1018 goto end; 1019 } 1020 break; 1021 case OPT_V_CASES: 1022 if (!opt_verify(o, vpm)) 1023 goto end; 1024 vpmtouched++; 1025 break; 1026 case OPT_X_CASES: 1027 if (!args_excert(o, &exc)) 1028 goto end; 1029 break; 1030 case OPT_PREXIT: 1031 prexit = 1; 1032 break; 1033 case OPT_CRLF: 1034 crlf = 1; 1035 break; 1036 case OPT_QUIET: 1037 c_quiet = c_ign_eof = 1; 1038 break; 1039 case OPT_NBIO: 1040 c_nbio = 1; 1041 break; 1042 case OPT_NOCMDS: 1043 cmdletters = 0; 1044 break; 1045 case OPT_ENGINE: 1046 e = setup_engine(opt_arg(), 1); 1047 break; 1048 case OPT_SSL_CLIENT_ENGINE: 1049 #ifndef OPENSSL_NO_ENGINE 1050 ssl_client_engine = ENGINE_by_id(opt_arg()); 1051 if (ssl_client_engine == NULL) { 1052 BIO_printf(bio_err, "Error getting client auth engine\n"); 1053 goto opthelp; 1054 } 1055 #endif 1056 break; 1057 case OPT_RAND: 1058 inrand = opt_arg(); 1059 break; 1060 case OPT_IGN_EOF: 1061 c_ign_eof = 1; 1062 break; 1063 case OPT_NO_IGN_EOF: 1064 c_ign_eof = 0; 1065 break; 1066 case OPT_DEBUG: 1067 c_debug = 1; 1068 break; 1069 case OPT_TLSEXTDEBUG: 1070 c_tlsextdebug = 1; 1071 break; 1072 case OPT_STATUS: 1073 #ifndef OPENSSL_NO_OCSP 1074 c_status_req = 1; 1075 #endif 1076 break; 1077 case OPT_WDEBUG: 1078 #ifdef WATT32 1079 dbug_init(); 1080 #endif 1081 break; 1082 case OPT_MSG: 1083 c_msg = 1; 1084 break; 1085 case OPT_MSGFILE: 1086 bio_c_msg = BIO_new_file(opt_arg(), "w"); 1087 break; 1088 case OPT_TRACE: 1089 #ifndef OPENSSL_NO_SSL_TRACE 1090 c_msg = 2; 1091 #endif 1092 break; 1093 case OPT_SECURITY_DEBUG: 1094 sdebug = 1; 1095 break; 1096 case OPT_SECURITY_DEBUG_VERBOSE: 1097 sdebug = 2; 1098 break; 1099 case OPT_SHOWCERTS: 1100 c_showcerts = 1; 1101 break; 1102 case OPT_NBIO_TEST: 1103 nbio_test = 1; 1104 break; 1105 case OPT_STATE: 1106 state = 1; 1107 break; 1108 #ifndef OPENSSL_NO_PSK 1109 case OPT_PSK_IDENTITY: 1110 psk_identity = opt_arg(); 1111 break; 1112 case OPT_PSK: 1113 for (p = psk_key = opt_arg(); *p; p++) { 1114 if (isxdigit(_UC(*p))) 1115 continue; 1116 BIO_printf(bio_err, "Not a hex number '%s'\n", psk_key); 1117 goto end; 1118 } 1119 break; 1120 #endif 1121 #ifndef OPENSSL_NO_SRP 1122 case OPT_SRPUSER: 1123 srp_arg.srplogin = opt_arg(); 1124 if (min_version < TLS1_VERSION) 1125 min_version = TLS1_VERSION; 1126 break; 1127 case OPT_SRPPASS: 1128 srppass = opt_arg(); 1129 if (min_version < TLS1_VERSION) 1130 min_version = TLS1_VERSION; 1131 break; 1132 case OPT_SRP_STRENGTH: 1133 srp_arg.strength = atoi(opt_arg()); 1134 BIO_printf(bio_err, "SRP minimal length for N is %d\n", 1135 srp_arg.strength); 1136 if (min_version < TLS1_VERSION) 1137 min_version = TLS1_VERSION; 1138 break; 1139 case OPT_SRP_LATEUSER: 1140 srp_lateuser = 1; 1141 if (min_version < TLS1_VERSION) 1142 min_version = TLS1_VERSION; 1143 break; 1144 case OPT_SRP_MOREGROUPS: 1145 srp_arg.amp = 1; 1146 if (min_version < TLS1_VERSION) 1147 min_version = TLS1_VERSION; 1148 break; 1149 #endif 1150 case OPT_SSL_CONFIG: 1151 ssl_config = opt_arg(); 1152 break; 1153 case OPT_SSL3: 1154 min_version = SSL3_VERSION; 1155 max_version = SSL3_VERSION; 1156 break; 1157 case OPT_TLS1_2: 1158 min_version = TLS1_2_VERSION; 1159 max_version = TLS1_2_VERSION; 1160 break; 1161 case OPT_TLS1_1: 1162 min_version = TLS1_1_VERSION; 1163 max_version = TLS1_1_VERSION; 1164 break; 1165 case OPT_TLS1: 1166 min_version = TLS1_VERSION; 1167 max_version = TLS1_VERSION; 1168 break; 1169 case OPT_DTLS: 1170 #ifndef OPENSSL_NO_DTLS 1171 meth = DTLS_client_method(); 1172 socket_type = SOCK_DGRAM; 1173 #endif 1174 break; 1175 case OPT_DTLS1: 1176 #ifndef OPENSSL_NO_DTLS1 1177 meth = DTLS_client_method(); 1178 min_version = DTLS1_VERSION; 1179 max_version = DTLS1_VERSION; 1180 socket_type = SOCK_DGRAM; 1181 #endif 1182 break; 1183 case OPT_DTLS1_2: 1184 #ifndef OPENSSL_NO_DTLS1_2 1185 meth = DTLS_client_method(); 1186 min_version = DTLS1_2_VERSION; 1187 max_version = DTLS1_2_VERSION; 1188 socket_type = SOCK_DGRAM; 1189 #endif 1190 break; 1191 case OPT_TIMEOUT: 1192 #ifndef OPENSSL_NO_DTLS 1193 enable_timeouts = 1; 1194 #endif 1195 break; 1196 case OPT_MTU: 1197 #ifndef OPENSSL_NO_DTLS 1198 socket_mtu = atol(opt_arg()); 1199 #endif 1200 break; 1201 case OPT_FALLBACKSCSV: 1202 fallback_scsv = 1; 1203 break; 1204 case OPT_KEYFORM: 1205 if (!opt_format(opt_arg(), OPT_FMT_PDE, &key_format)) 1206 goto opthelp; 1207 break; 1208 case OPT_PASS: 1209 passarg = opt_arg(); 1210 break; 1211 case OPT_CERT_CHAIN: 1212 chain_file = opt_arg(); 1213 break; 1214 case OPT_KEY: 1215 key_file = opt_arg(); 1216 break; 1217 case OPT_RECONNECT: 1218 reconnect = 5; 1219 break; 1220 case OPT_CAPATH: 1221 CApath = opt_arg(); 1222 break; 1223 case OPT_NOCAPATH: 1224 noCApath = 1; 1225 break; 1226 case OPT_CHAINCAPATH: 1227 chCApath = opt_arg(); 1228 break; 1229 case OPT_VERIFYCAPATH: 1230 vfyCApath = opt_arg(); 1231 break; 1232 case OPT_BUILD_CHAIN: 1233 build_chain = 1; 1234 break; 1235 case OPT_CAFILE: 1236 CAfile = opt_arg(); 1237 break; 1238 case OPT_NOCAFILE: 1239 noCAfile = 1; 1240 break; 1241 #ifndef OPENSSL_NO_CT 1242 case OPT_NOCT: 1243 ct_validation = 0; 1244 break; 1245 case OPT_CT: 1246 ct_validation = 1; 1247 break; 1248 case OPT_CTLOG_FILE: 1249 ctlog_file = opt_arg(); 1250 break; 1251 #endif 1252 case OPT_CHAINCAFILE: 1253 chCAfile = opt_arg(); 1254 break; 1255 case OPT_VERIFYCAFILE: 1256 vfyCAfile = opt_arg(); 1257 break; 1258 case OPT_DANE_TLSA_DOMAIN: 1259 dane_tlsa_domain = opt_arg(); 1260 break; 1261 case OPT_DANE_TLSA_RRDATA: 1262 if (dane_tlsa_rrset == NULL) 1263 dane_tlsa_rrset = sk_OPENSSL_STRING_new_null(); 1264 if (dane_tlsa_rrset == NULL || 1265 !sk_OPENSSL_STRING_push(dane_tlsa_rrset, opt_arg())) { 1266 BIO_printf(bio_err, "%s: Memory allocation failure\n", prog); 1267 goto end; 1268 } 1269 break; 1270 case OPT_DANE_EE_NO_NAME: 1271 dane_ee_no_name = 1; 1272 break; 1273 case OPT_NEXTPROTONEG: 1274 #ifndef OPENSSL_NO_NEXTPROTONEG 1275 next_proto_neg_in = opt_arg(); 1276 #endif 1277 break; 1278 case OPT_ALPN: 1279 alpn_in = opt_arg(); 1280 break; 1281 case OPT_SERVERINFO: 1282 p = opt_arg(); 1283 len = strlen(p); 1284 for (start = 0, i = 0; i <= len; ++i) { 1285 if (i == len || p[i] == ',') { 1286 serverinfo_types[serverinfo_count] = atoi(p + start); 1287 if (++serverinfo_count == MAX_SI_TYPES) 1288 break; 1289 start = i + 1; 1290 } 1291 } 1292 break; 1293 case OPT_STARTTLS: 1294 if (!opt_pair(opt_arg(), services, &starttls_proto)) 1295 goto end; 1296 break; 1297 case OPT_SERVERNAME: 1298 servername = opt_arg(); 1299 break; 1300 case OPT_USE_SRTP: 1301 srtp_profiles = opt_arg(); 1302 break; 1303 case OPT_KEYMATEXPORT: 1304 keymatexportlabel = opt_arg(); 1305 break; 1306 case OPT_KEYMATEXPORTLEN: 1307 keymatexportlen = atoi(opt_arg()); 1308 break; 1309 case OPT_ASYNC: 1310 async = 1; 1311 break; 1312 case OPT_SPLIT_SEND_FRAG: 1313 split_send_fragment = atoi(opt_arg()); 1314 if (split_send_fragment == 0) { 1315 /* 1316 * Not allowed - set to a deliberately bad value so we get an 1317 * error message below 1318 */ 1319 split_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH + 1; 1320 } 1321 break; 1322 case OPT_MAX_PIPELINES: 1323 max_pipelines = atoi(opt_arg()); 1324 break; 1325 case OPT_READ_BUF: 1326 read_buf_len = atoi(opt_arg()); 1327 break; 1328 } 1329 } 1330 if (count4or6 >= 2) { 1331 BIO_printf(bio_err, "%s: Can't use both -4 and -6\n", prog); 1332 goto opthelp; 1333 } 1334 argc = opt_num_rest(); 1335 if (argc != 0) 1336 goto opthelp; 1337 1338 if (proxystr) { 1339 int res; 1340 char *tmp_host = host, *tmp_port = port; 1341 if (connectstr == NULL) { 1342 BIO_printf(bio_err, "%s: -proxy requires use of -connect\n", prog); 1343 goto opthelp; 1344 } 1345 res = BIO_parse_hostserv(proxystr, &host, &port, BIO_PARSE_PRIO_HOST); 1346 if (tmp_host != host) 1347 OPENSSL_free(tmp_host); 1348 if (tmp_port != port) 1349 OPENSSL_free(tmp_port); 1350 if (!res) { 1351 BIO_printf(bio_err, 1352 "%s: -proxy argument malformed or ambiguous\n", prog); 1353 goto end; 1354 } 1355 } else { 1356 int res = 1; 1357 char *tmp_host = host, *tmp_port = port; 1358 if (connectstr != NULL) 1359 res = BIO_parse_hostserv(connectstr, &host, &port, 1360 BIO_PARSE_PRIO_HOST); 1361 if (tmp_host != host) 1362 OPENSSL_free(tmp_host); 1363 if (tmp_port != port) 1364 OPENSSL_free(tmp_port); 1365 if (!res) { 1366 BIO_printf(bio_err, 1367 "%s: -connect argument malformed or ambiguous\n", 1368 prog); 1369 goto end; 1370 } 1371 } 1372 1373 #ifdef AF_UNIX 1374 if (socket_family == AF_UNIX && socket_type != SOCK_STREAM) { 1375 BIO_printf(bio_err, 1376 "Can't use unix sockets and datagrams together\n"); 1377 goto end; 1378 } 1379 #endif 1380 1381 if (split_send_fragment > SSL3_RT_MAX_PLAIN_LENGTH) { 1382 BIO_printf(bio_err, "Bad split send fragment size\n"); 1383 goto end; 1384 } 1385 1386 if (max_pipelines > SSL_MAX_PIPELINES) { 1387 BIO_printf(bio_err, "Bad max pipelines value\n"); 1388 goto end; 1389 } 1390 1391 #if !defined(OPENSSL_NO_NEXTPROTONEG) 1392 next_proto.status = -1; 1393 if (next_proto_neg_in) { 1394 next_proto.data = 1395 next_protos_parse(&next_proto.len, next_proto_neg_in); 1396 if (next_proto.data == NULL) { 1397 BIO_printf(bio_err, "Error parsing -nextprotoneg argument\n"); 1398 goto end; 1399 } 1400 } else 1401 next_proto.data = NULL; 1402 #endif 1403 1404 if (!app_passwd(passarg, NULL, &pass, NULL)) { 1405 BIO_printf(bio_err, "Error getting password\n"); 1406 goto end; 1407 } 1408 1409 if (key_file == NULL) 1410 key_file = cert_file; 1411 1412 if (key_file) { 1413 key = load_key(key_file, key_format, 0, pass, e, 1414 "client certificate private key file"); 1415 if (key == NULL) { 1416 ERR_print_errors(bio_err); 1417 goto end; 1418 } 1419 } 1420 1421 if (cert_file) { 1422 cert = load_cert(cert_file, cert_format, "client certificate file"); 1423 if (cert == NULL) { 1424 ERR_print_errors(bio_err); 1425 goto end; 1426 } 1427 } 1428 1429 if (chain_file) { 1430 if (!load_certs(chain_file, &chain, FORMAT_PEM, NULL, 1431 "client certificate chain")) 1432 goto end; 1433 } 1434 1435 if (crl_file) { 1436 X509_CRL *crl; 1437 crl = load_crl(crl_file, crl_format); 1438 if (crl == NULL) { 1439 BIO_puts(bio_err, "Error loading CRL\n"); 1440 ERR_print_errors(bio_err); 1441 goto end; 1442 } 1443 crls = sk_X509_CRL_new_null(); 1444 if (crls == NULL || !sk_X509_CRL_push(crls, crl)) { 1445 BIO_puts(bio_err, "Error adding CRL\n"); 1446 ERR_print_errors(bio_err); 1447 X509_CRL_free(crl); 1448 goto end; 1449 } 1450 } 1451 1452 if (!load_excert(&exc)) 1453 goto end; 1454 1455 if (!app_RAND_load_file(NULL, 1) && inrand == NULL 1456 && !RAND_status()) { 1457 BIO_printf(bio_err, 1458 "warning, not much extra random data, consider using the -rand option\n"); 1459 } 1460 if (inrand != NULL) { 1461 randamt = app_RAND_load_files(inrand); 1462 BIO_printf(bio_err, "%ld semi-random bytes loaded\n", randamt); 1463 } 1464 1465 if (bio_c_out == NULL) { 1466 if (c_quiet && !c_debug) { 1467 bio_c_out = BIO_new(BIO_s_null()); 1468 if (c_msg && !bio_c_msg) 1469 bio_c_msg = dup_bio_out(FORMAT_TEXT); 1470 } else if (bio_c_out == NULL) 1471 bio_c_out = dup_bio_out(FORMAT_TEXT); 1472 } 1473 #ifndef OPENSSL_NO_SRP 1474 if (!app_passwd(srppass, NULL, &srp_arg.srppassin, NULL)) { 1475 BIO_printf(bio_err, "Error getting password\n"); 1476 goto end; 1477 } 1478 #endif 1479 1480 ctx = SSL_CTX_new(meth); 1481 if (ctx == NULL) { 1482 ERR_print_errors(bio_err); 1483 goto end; 1484 } 1485 1486 if (sdebug) 1487 ssl_ctx_security_debug(ctx, sdebug); 1488 1489 if (!config_ctx(cctx, ssl_args, ctx)) 1490 goto end; 1491 1492 if (ssl_config) { 1493 if (SSL_CTX_config(ctx, ssl_config) == 0) { 1494 BIO_printf(bio_err, "Error using configuration \"%s\"\n", 1495 ssl_config); 1496 ERR_print_errors(bio_err); 1497 goto end; 1498 } 1499 } 1500 1501 if (min_version != 0 1502 && SSL_CTX_set_min_proto_version(ctx, min_version) == 0) 1503 goto end; 1504 if (max_version != 0 1505 && SSL_CTX_set_max_proto_version(ctx, max_version) == 0) 1506 goto end; 1507 1508 if (vpmtouched && !SSL_CTX_set1_param(ctx, vpm)) { 1509 BIO_printf(bio_err, "Error setting verify params\n"); 1510 ERR_print_errors(bio_err); 1511 goto end; 1512 } 1513 1514 if (async) { 1515 SSL_CTX_set_mode(ctx, SSL_MODE_ASYNC); 1516 } 1517 if (split_send_fragment > 0) { 1518 SSL_CTX_set_split_send_fragment(ctx, split_send_fragment); 1519 } 1520 if (max_pipelines > 0) { 1521 SSL_CTX_set_max_pipelines(ctx, max_pipelines); 1522 } 1523 1524 if (read_buf_len > 0) { 1525 SSL_CTX_set_default_read_buffer_len(ctx, read_buf_len); 1526 } 1527 1528 if (!ssl_load_stores(ctx, vfyCApath, vfyCAfile, chCApath, chCAfile, 1529 crls, crl_download)) { 1530 BIO_printf(bio_err, "Error loading store locations\n"); 1531 ERR_print_errors(bio_err); 1532 goto end; 1533 } 1534 #ifndef OPENSSL_NO_ENGINE 1535 if (ssl_client_engine) { 1536 if (!SSL_CTX_set_client_cert_engine(ctx, ssl_client_engine)) { 1537 BIO_puts(bio_err, "Error setting client auth engine\n"); 1538 ERR_print_errors(bio_err); 1539 ENGINE_free(ssl_client_engine); 1540 goto end; 1541 } 1542 ENGINE_free(ssl_client_engine); 1543 } 1544 #endif 1545 1546 #ifndef OPENSSL_NO_PSK 1547 if (psk_key != NULL) { 1548 if (c_debug) 1549 BIO_printf(bio_c_out, "PSK key given, setting client callback\n"); 1550 SSL_CTX_set_psk_client_callback(ctx, psk_client_cb); 1551 } 1552 #endif 1553 #ifndef OPENSSL_NO_SRTP 1554 if (srtp_profiles != NULL) { 1555 /* Returns 0 on success! */ 1556 if (SSL_CTX_set_tlsext_use_srtp(ctx, srtp_profiles) != 0) { 1557 BIO_printf(bio_err, "Error setting SRTP profile\n"); 1558 ERR_print_errors(bio_err); 1559 goto end; 1560 } 1561 } 1562 #endif 1563 1564 if (exc) 1565 ssl_ctx_set_excert(ctx, exc); 1566 1567 #if !defined(OPENSSL_NO_NEXTPROTONEG) 1568 if (next_proto.data) 1569 SSL_CTX_set_next_proto_select_cb(ctx, next_proto_cb, &next_proto); 1570 #endif 1571 if (alpn_in) { 1572 size_t alpn_len; 1573 unsigned char *alpn = next_protos_parse(&alpn_len, alpn_in); 1574 1575 if (alpn == NULL) { 1576 BIO_printf(bio_err, "Error parsing -alpn argument\n"); 1577 goto end; 1578 } 1579 /* Returns 0 on success! */ 1580 if (SSL_CTX_set_alpn_protos(ctx, alpn, alpn_len) != 0) { 1581 BIO_printf(bio_err, "Error setting ALPN\n"); 1582 goto end; 1583 } 1584 OPENSSL_free(alpn); 1585 } 1586 1587 for (i = 0; i < serverinfo_count; i++) { 1588 if (!SSL_CTX_add_client_custom_ext(ctx, 1589 serverinfo_types[i], 1590 NULL, NULL, NULL, 1591 serverinfo_cli_parse_cb, NULL)) { 1592 BIO_printf(bio_err, 1593 "Warning: Unable to add custom extension %u, skipping\n", 1594 serverinfo_types[i]); 1595 } 1596 } 1597 1598 if (state) 1599 SSL_CTX_set_info_callback(ctx, apps_ssl_info_callback); 1600 1601 #ifndef OPENSSL_NO_CT 1602 /* Enable SCT processing, without early connection termination */ 1603 if (ct_validation && 1604 !SSL_CTX_enable_ct(ctx, SSL_CT_VALIDATION_PERMISSIVE)) { 1605 ERR_print_errors(bio_err); 1606 goto end; 1607 } 1608 1609 if (!ctx_set_ctlog_list_file(ctx, ctlog_file)) { 1610 if (ct_validation) { 1611 ERR_print_errors(bio_err); 1612 goto end; 1613 } 1614 1615 /* 1616 * If CT validation is not enabled, the log list isn't needed so don't 1617 * show errors or abort. We try to load it regardless because then we 1618 * can show the names of the logs any SCTs came from (SCTs may be seen 1619 * even with validation disabled). 1620 */ 1621 ERR_clear_error(); 1622 } 1623 #endif 1624 1625 SSL_CTX_set_verify(ctx, verify, verify_callback); 1626 1627 if (!ctx_set_verify_locations(ctx, CAfile, CApath, noCAfile, noCApath)) { 1628 ERR_print_errors(bio_err); 1629 goto end; 1630 } 1631 1632 ssl_ctx_add_crls(ctx, crls, crl_download); 1633 1634 if (!set_cert_key_stuff(ctx, cert, key, chain, build_chain)) 1635 goto end; 1636 1637 if (servername != NULL) { 1638 tlsextcbp.biodebug = bio_err; 1639 SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb); 1640 SSL_CTX_set_tlsext_servername_arg(ctx, &tlsextcbp); 1641 } 1642 # ifndef OPENSSL_NO_SRP 1643 if (srp_arg.srplogin) { 1644 if (!srp_lateuser && !SSL_CTX_set_srp_username(ctx, srp_arg.srplogin)) { 1645 BIO_printf(bio_err, "Unable to set SRP username\n"); 1646 goto end; 1647 } 1648 srp_arg.msg = c_msg; 1649 srp_arg.debug = c_debug; 1650 SSL_CTX_set_srp_cb_arg(ctx, &srp_arg); 1651 SSL_CTX_set_srp_client_pwd_callback(ctx, ssl_give_srp_client_pwd_cb); 1652 SSL_CTX_set_srp_strength(ctx, srp_arg.strength); 1653 if (c_msg || c_debug || srp_arg.amp == 0) 1654 SSL_CTX_set_srp_verify_param_callback(ctx, 1655 ssl_srp_verify_param_cb); 1656 } 1657 # endif 1658 1659 if (dane_tlsa_domain != NULL) { 1660 if (SSL_CTX_dane_enable(ctx) <= 0) { 1661 BIO_printf(bio_err, 1662 "%s: Error enabling DANE TLSA authentication.\n", 1663 prog); 1664 ERR_print_errors(bio_err); 1665 goto end; 1666 } 1667 } 1668 1669 con = SSL_new(ctx); 1670 if (sess_in) { 1671 SSL_SESSION *sess; 1672 BIO *stmp = BIO_new_file(sess_in, "r"); 1673 if (!stmp) { 1674 BIO_printf(bio_err, "Can't open session file %s\n", sess_in); 1675 ERR_print_errors(bio_err); 1676 goto end; 1677 } 1678 sess = PEM_read_bio_SSL_SESSION(stmp, NULL, 0, NULL); 1679 BIO_free(stmp); 1680 if (!sess) { 1681 BIO_printf(bio_err, "Can't open session file %s\n", sess_in); 1682 ERR_print_errors(bio_err); 1683 goto end; 1684 } 1685 if (!SSL_set_session(con, sess)) { 1686 BIO_printf(bio_err, "Can't set session\n"); 1687 ERR_print_errors(bio_err); 1688 goto end; 1689 } 1690 SSL_SESSION_free(sess); 1691 } 1692 1693 if (fallback_scsv) 1694 SSL_set_mode(con, SSL_MODE_SEND_FALLBACK_SCSV); 1695 1696 if (servername != NULL) { 1697 if (!SSL_set_tlsext_host_name(con, servername)) { 1698 BIO_printf(bio_err, "Unable to set TLS servername extension.\n"); 1699 ERR_print_errors(bio_err); 1700 goto end; 1701 } 1702 } 1703 1704 if (dane_tlsa_domain != NULL) { 1705 if (SSL_dane_enable(con, dane_tlsa_domain) <= 0) { 1706 BIO_printf(bio_err, "%s: Error enabling DANE TLSA " 1707 "authentication.\n", prog); 1708 ERR_print_errors(bio_err); 1709 goto end; 1710 } 1711 if (dane_tlsa_rrset == NULL) { 1712 BIO_printf(bio_err, "%s: DANE TLSA authentication requires at " 1713 "least one -dane_tlsa_rrdata option.\n", prog); 1714 goto end; 1715 } 1716 if (tlsa_import_rrset(con, dane_tlsa_rrset) <= 0) { 1717 BIO_printf(bio_err, "%s: Failed to import any TLSA " 1718 "records.\n", prog); 1719 goto end; 1720 } 1721 if (dane_ee_no_name) 1722 SSL_dane_set_flags(con, DANE_FLAG_NO_DANE_EE_NAMECHECKS); 1723 } else if (dane_tlsa_rrset != NULL) { 1724 BIO_printf(bio_err, "%s: DANE TLSA authentication requires the " 1725 "-dane_tlsa_domain option.\n", prog); 1726 goto end; 1727 } 1728 1729 re_start: 1730 if (init_client(&s, host, port, socket_family, socket_type) == 0) { 1731 BIO_printf(bio_err, "connect:errno=%d\n", get_last_socket_error()); 1732 BIO_closesocket(s); 1733 goto end; 1734 } 1735 BIO_printf(bio_c_out, "CONNECTED(%08X)\n", s); 1736 1737 if (c_nbio) { 1738 if (!BIO_socket_nbio(s, 1)) { 1739 ERR_print_errors(bio_err); 1740 goto end; 1741 } 1742 BIO_printf(bio_c_out, "Turned on non blocking io\n"); 1743 } 1744 #ifndef OPENSSL_NO_DTLS 1745 if (socket_type == SOCK_DGRAM) { 1746 union BIO_sock_info_u peer_info; 1747 1748 sbio = BIO_new_dgram(s, BIO_NOCLOSE); 1749 if ((peer_info.addr = BIO_ADDR_new()) == NULL) { 1750 BIO_printf(bio_err, "memory allocation failure\n"); 1751 BIO_closesocket(s); 1752 goto end; 1753 } 1754 if (!BIO_sock_info(s, BIO_SOCK_INFO_ADDRESS, &peer_info)) { 1755 BIO_printf(bio_err, "getsockname:errno=%d\n", 1756 get_last_socket_error()); 1757 BIO_ADDR_free(peer_info.addr); 1758 BIO_closesocket(s); 1759 goto end; 1760 } 1761 1762 (void)BIO_ctrl_set_connected(sbio, peer_info.addr); 1763 BIO_ADDR_free(peer_info.addr); 1764 peer_info.addr = NULL; 1765 1766 if (enable_timeouts) { 1767 timeout.tv_sec = 0; 1768 timeout.tv_usec = DGRAM_RCV_TIMEOUT; 1769 BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout); 1770 1771 timeout.tv_sec = 0; 1772 timeout.tv_usec = DGRAM_SND_TIMEOUT; 1773 BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_SEND_TIMEOUT, 0, &timeout); 1774 } 1775 1776 if (socket_mtu) { 1777 if (socket_mtu < DTLS_get_link_min_mtu(con)) { 1778 BIO_printf(bio_err, "MTU too small. Must be at least %ld\n", 1779 DTLS_get_link_min_mtu(con)); 1780 BIO_free(sbio); 1781 goto shut; 1782 } 1783 SSL_set_options(con, SSL_OP_NO_QUERY_MTU); 1784 if (!DTLS_set_link_mtu(con, socket_mtu)) { 1785 BIO_printf(bio_err, "Failed to set MTU\n"); 1786 BIO_free(sbio); 1787 goto shut; 1788 } 1789 } else 1790 /* want to do MTU discovery */ 1791 BIO_ctrl(sbio, BIO_CTRL_DGRAM_MTU_DISCOVER, 0, NULL); 1792 } else 1793 #endif /* OPENSSL_NO_DTLS */ 1794 sbio = BIO_new_socket(s, BIO_NOCLOSE); 1795 1796 if (nbio_test) { 1797 BIO *test; 1798 1799 test = BIO_new(BIO_f_nbio_test()); 1800 sbio = BIO_push(test, sbio); 1801 } 1802 1803 if (c_debug) { 1804 BIO_set_callback(sbio, bio_dump_callback); 1805 BIO_set_callback_arg(sbio, (char *)bio_c_out); 1806 } 1807 if (c_msg) { 1808 #ifndef OPENSSL_NO_SSL_TRACE 1809 if (c_msg == 2) 1810 SSL_set_msg_callback(con, SSL_trace); 1811 else 1812 #endif 1813 SSL_set_msg_callback(con, msg_cb); 1814 SSL_set_msg_callback_arg(con, bio_c_msg ? bio_c_msg : bio_c_out); 1815 } 1816 1817 if (c_tlsextdebug) { 1818 SSL_set_tlsext_debug_callback(con, tlsext_cb); 1819 SSL_set_tlsext_debug_arg(con, bio_c_out); 1820 } 1821 #ifndef OPENSSL_NO_OCSP 1822 if (c_status_req) { 1823 SSL_set_tlsext_status_type(con, TLSEXT_STATUSTYPE_ocsp); 1824 SSL_CTX_set_tlsext_status_cb(ctx, ocsp_resp_cb); 1825 SSL_CTX_set_tlsext_status_arg(ctx, bio_c_out); 1826 } 1827 #endif 1828 1829 SSL_set_bio(con, sbio, sbio); 1830 SSL_set_connect_state(con); 1831 1832 /* ok, lets connect */ 1833 if (fileno_stdin() > SSL_get_fd(con)) 1834 width = fileno_stdin() + 1; 1835 else 1836 width = SSL_get_fd(con) + 1; 1837 1838 read_tty = 1; 1839 write_tty = 0; 1840 tty_on = 0; 1841 read_ssl = 1; 1842 write_ssl = 1; 1843 1844 cbuf_len = 0; 1845 cbuf_off = 0; 1846 sbuf_len = 0; 1847 sbuf_off = 0; 1848 1849 switch ((PROTOCOL_CHOICE) starttls_proto) { 1850 case PROTO_OFF: 1851 break; 1852 case PROTO_SMTP: 1853 { 1854 /* 1855 * This is an ugly hack that does a lot of assumptions. We do 1856 * have to handle multi-line responses which may come in a single 1857 * packet or not. We therefore have to use BIO_gets() which does 1858 * need a buffering BIO. So during the initial chitchat we do 1859 * push a buffering BIO into the chain that is removed again 1860 * later on to not disturb the rest of the s_client operation. 1861 */ 1862 int foundit = 0; 1863 BIO *fbio = BIO_new(BIO_f_buffer()); 1864 BIO_push(fbio, sbio); 1865 /* wait for multi-line response to end from SMTP */ 1866 do { 1867 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ); 1868 } 1869 while (mbuf_len > 3 && mbuf[3] == '-'); 1870 BIO_printf(fbio, "EHLO %s\r\n", ehlo); 1871 (void)BIO_flush(fbio); 1872 /* wait for multi-line response to end EHLO SMTP response */ 1873 do { 1874 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ); 1875 if (strstr(mbuf, "STARTTLS")) 1876 foundit = 1; 1877 } 1878 while (mbuf_len > 3 && mbuf[3] == '-'); 1879 (void)BIO_flush(fbio); 1880 BIO_pop(fbio); 1881 BIO_free(fbio); 1882 if (!foundit) 1883 BIO_printf(bio_err, 1884 "didn't find starttls in server response," 1885 " trying anyway...\n"); 1886 BIO_printf(sbio, "STARTTLS\r\n"); 1887 BIO_read(sbio, sbuf, BUFSIZZ); 1888 } 1889 break; 1890 case PROTO_POP3: 1891 { 1892 BIO_read(sbio, mbuf, BUFSIZZ); 1893 BIO_printf(sbio, "STLS\r\n"); 1894 mbuf_len = BIO_read(sbio, sbuf, BUFSIZZ); 1895 if (mbuf_len < 0) { 1896 BIO_printf(bio_err, "BIO_read failed\n"); 1897 goto end; 1898 } 1899 } 1900 break; 1901 case PROTO_IMAP: 1902 { 1903 int foundit = 0; 1904 BIO *fbio = BIO_new(BIO_f_buffer()); 1905 BIO_push(fbio, sbio); 1906 BIO_gets(fbio, mbuf, BUFSIZZ); 1907 /* STARTTLS command requires CAPABILITY... */ 1908 BIO_printf(fbio, ". CAPABILITY\r\n"); 1909 (void)BIO_flush(fbio); 1910 /* wait for multi-line CAPABILITY response */ 1911 do { 1912 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ); 1913 if (strstr(mbuf, "STARTTLS")) 1914 foundit = 1; 1915 } 1916 while (mbuf_len > 3 && mbuf[0] != '.'); 1917 (void)BIO_flush(fbio); 1918 BIO_pop(fbio); 1919 BIO_free(fbio); 1920 if (!foundit) 1921 BIO_printf(bio_err, 1922 "didn't find STARTTLS in server response," 1923 " trying anyway...\n"); 1924 BIO_printf(sbio, ". STARTTLS\r\n"); 1925 BIO_read(sbio, sbuf, BUFSIZZ); 1926 } 1927 break; 1928 case PROTO_FTP: 1929 { 1930 BIO *fbio = BIO_new(BIO_f_buffer()); 1931 BIO_push(fbio, sbio); 1932 /* wait for multi-line response to end from FTP */ 1933 do { 1934 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ); 1935 } 1936 while (mbuf_len > 3 && mbuf[3] == '-'); 1937 (void)BIO_flush(fbio); 1938 BIO_pop(fbio); 1939 BIO_free(fbio); 1940 BIO_printf(sbio, "AUTH TLS\r\n"); 1941 BIO_read(sbio, sbuf, BUFSIZZ); 1942 } 1943 break; 1944 case PROTO_XMPP: 1945 case PROTO_XMPP_SERVER: 1946 { 1947 int seen = 0; 1948 BIO_printf(sbio, "<stream:stream " 1949 "xmlns:stream='http://etherx.jabber.org/streams' " 1950 "xmlns='jabber:%s' to='%s' version='1.0'>", 1951 starttls_proto == PROTO_XMPP ? "client" : "server", 1952 xmpphost ? xmpphost : host); 1953 seen = BIO_read(sbio, mbuf, BUFSIZZ); 1954 mbuf[seen] = 0; 1955 while (!strstr 1956 (mbuf, "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'") 1957 && !strstr(mbuf, 1958 "<starttls xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\"")) 1959 { 1960 seen = BIO_read(sbio, mbuf, BUFSIZZ); 1961 1962 if (seen <= 0) 1963 goto shut; 1964 1965 mbuf[seen] = 0; 1966 } 1967 BIO_printf(sbio, 1968 "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>"); 1969 seen = BIO_read(sbio, sbuf, BUFSIZZ); 1970 sbuf[seen] = 0; 1971 if (!strstr(sbuf, "<proceed")) 1972 goto shut; 1973 mbuf[0] = 0; 1974 } 1975 break; 1976 case PROTO_TELNET: 1977 { 1978 static const unsigned char tls_do[] = { 1979 /* IAC DO START_TLS */ 1980 255, 253, 46 1981 }; 1982 static const unsigned char tls_will[] = { 1983 /* IAC WILL START_TLS */ 1984 255, 251, 46 1985 }; 1986 static const unsigned char tls_follows[] = { 1987 /* IAC SB START_TLS FOLLOWS IAC SE */ 1988 255, 250, 46, 1, 255, 240 1989 }; 1990 int bytes; 1991 1992 /* Telnet server should demand we issue START_TLS */ 1993 bytes = BIO_read(sbio, mbuf, BUFSIZZ); 1994 if (bytes != 3 || memcmp(mbuf, tls_do, 3) != 0) 1995 goto shut; 1996 /* Agree to issue START_TLS and send the FOLLOWS sub-command */ 1997 BIO_write(sbio, tls_will, 3); 1998 BIO_write(sbio, tls_follows, 6); 1999 (void)BIO_flush(sbio); 2000 /* Telnet server also sent the FOLLOWS sub-command */ 2001 bytes = BIO_read(sbio, mbuf, BUFSIZZ); 2002 if (bytes != 6 || memcmp(mbuf, tls_follows, 6) != 0) 2003 goto shut; 2004 } 2005 break; 2006 case PROTO_CONNECT: 2007 { 2008 enum { 2009 error_proto, /* Wrong protocol, not even HTTP */ 2010 error_connect, /* CONNECT failed */ 2011 success 2012 } foundit = error_connect; 2013 BIO *fbio = BIO_new(BIO_f_buffer()); 2014 2015 BIO_push(fbio, sbio); 2016 BIO_printf(fbio, "CONNECT %s HTTP/1.0\r\n\r\n", connectstr); 2017 (void)BIO_flush(fbio); 2018 /* 2019 * The first line is the HTTP response. According to RFC 7230, 2020 * it's formated exactly like this: 2021 * 2022 * HTTP/d.d ddd Reason text\r\n 2023 */ 2024 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ); 2025 if (mbuf[8] != ' ') { 2026 BIO_printf(bio_err, 2027 "%s: HTTP CONNECT failed, incorrect response " 2028 "from proxy\n", prog); 2029 foundit = error_proto; 2030 } else if (mbuf[9] != '2') { 2031 BIO_printf(bio_err, "%s: HTTP CONNECT failed: %s ", prog, 2032 &mbuf[9]); 2033 } else { 2034 foundit = success; 2035 } 2036 if (foundit != error_proto) { 2037 /* Read past all following headers */ 2038 do { 2039 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ); 2040 } while (mbuf_len > 2); 2041 } 2042 (void)BIO_flush(fbio); 2043 BIO_pop(fbio); 2044 BIO_free(fbio); 2045 if (foundit != success) { 2046 goto shut; 2047 } 2048 } 2049 break; 2050 case PROTO_IRC: 2051 { 2052 int numeric; 2053 BIO *fbio = BIO_new(BIO_f_buffer()); 2054 2055 BIO_push(fbio, sbio); 2056 BIO_printf(fbio, "STARTTLS\r\n"); 2057 (void)BIO_flush(fbio); 2058 width = SSL_get_fd(con) + 1; 2059 2060 do { 2061 numeric = 0; 2062 2063 FD_ZERO(&readfds); 2064 openssl_fdset(SSL_get_fd(con), &readfds); 2065 timeout.tv_sec = S_CLIENT_IRC_READ_TIMEOUT; 2066 timeout.tv_usec = 0; 2067 /* 2068 * If the IRCd doesn't respond within 2069 * S_CLIENT_IRC_READ_TIMEOUT seconds, assume 2070 * it doesn't support STARTTLS. Many IRCds 2071 * will not give _any_ sort of response to a 2072 * STARTTLS command when it's not supported. 2073 */ 2074 if (!BIO_get_buffer_num_lines(fbio) 2075 && !BIO_pending(fbio) 2076 && !BIO_pending(sbio) 2077 && select(width, (void *)&readfds, NULL, NULL, 2078 &timeout) < 1) { 2079 BIO_printf(bio_err, 2080 "Timeout waiting for response (%d seconds).\n", 2081 S_CLIENT_IRC_READ_TIMEOUT); 2082 break; 2083 } 2084 2085 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ); 2086 if (mbuf_len < 1 || sscanf(mbuf, "%*s %d", &numeric) != 1) 2087 break; 2088 /* :example.net 451 STARTTLS :You have not registered */ 2089 /* :example.net 421 STARTTLS :Unknown command */ 2090 if ((numeric == 451 || numeric == 421) 2091 && strstr(mbuf, "STARTTLS") != NULL) { 2092 BIO_printf(bio_err, "STARTTLS not supported: %s", mbuf); 2093 break; 2094 } 2095 if (numeric == 691) { 2096 BIO_printf(bio_err, "STARTTLS negotiation failed: "); 2097 ERR_print_errors(bio_err); 2098 break; 2099 } 2100 } while (numeric != 670); 2101 2102 (void)BIO_flush(fbio); 2103 BIO_pop(fbio); 2104 BIO_free(fbio); 2105 if (numeric != 670) { 2106 BIO_printf(bio_err, "Server does not support STARTTLS.\n"); 2107 ret = 1; 2108 goto shut; 2109 } 2110 } 2111 } 2112 2113 for (;;) { 2114 FD_ZERO(&readfds); 2115 FD_ZERO(&writefds); 2116 int fdin = fileno_stdin(); 2117 if (fdin < 0) { 2118 BIO_printf(bio_err,"bad fileno for stdin\n"); 2119 goto shut; 2120 } 2121 int fdout = fileno_stdout(); 2122 if (fdout < 0) { 2123 BIO_printf(bio_err,"bad fileno for stdout\n"); 2124 goto shut; 2125 } 2126 2127 if ((SSL_version(con) == DTLS1_VERSION) && 2128 DTLSv1_get_timeout(con, &timeout)) 2129 timeoutp = &timeout; 2130 else 2131 timeoutp = NULL; 2132 2133 if (SSL_in_init(con) && !SSL_total_renegotiations(con)) { 2134 in_init = 1; 2135 tty_on = 0; 2136 } else { 2137 tty_on = 1; 2138 if (in_init) { 2139 in_init = 0; 2140 2141 if (sess_out) { 2142 BIO *stmp = BIO_new_file(sess_out, "w"); 2143 if (stmp) { 2144 PEM_write_bio_SSL_SESSION(stmp, SSL_get_session(con)); 2145 BIO_free(stmp); 2146 } else 2147 BIO_printf(bio_err, "Error writing session file %s\n", 2148 sess_out); 2149 } 2150 if (c_brief) { 2151 BIO_puts(bio_err, "CONNECTION ESTABLISHED\n"); 2152 print_ssl_summary(con); 2153 } 2154 2155 print_stuff(bio_c_out, con, full_log); 2156 if (full_log > 0) 2157 full_log--; 2158 2159 if (starttls_proto) { 2160 BIO_write(bio_err, mbuf, mbuf_len); 2161 /* We don't need to know any more */ 2162 if (!reconnect) 2163 starttls_proto = PROTO_OFF; 2164 } 2165 2166 if (reconnect) { 2167 reconnect--; 2168 BIO_printf(bio_c_out, 2169 "drop connection and then reconnect\n"); 2170 do_ssl_shutdown(con); 2171 SSL_set_connect_state(con); 2172 BIO_closesocket(SSL_get_fd(con)); 2173 goto re_start; 2174 } 2175 } 2176 } 2177 2178 ssl_pending = read_ssl && SSL_has_pending(con); 2179 2180 if (!ssl_pending) { 2181 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) 2182 if (tty_on) { 2183 /* 2184 * Note that select() returns when read _would not block_, 2185 * and EOF satisfies that. To avoid a CPU-hogging loop, 2186 * set the flag so we exit. 2187 */ 2188 if (read_tty && !at_eof) 2189 openssl_fdset(fileno_stdin(), &readfds); 2190 #if !defined(OPENSSL_SYS_VMS) 2191 if (write_tty) 2192 openssl_fdset(fdout, &writefds); 2193 #endif 2194 } 2195 if (read_ssl) 2196 openssl_fdset(SSL_get_fd(con), &readfds); 2197 if (write_ssl) 2198 openssl_fdset(SSL_get_fd(con), &writefds); 2199 #else 2200 if (!tty_on || !write_tty) { 2201 if (read_ssl) 2202 openssl_fdset(SSL_get_fd(con), &readfds); 2203 if (write_ssl) 2204 openssl_fdset(SSL_get_fd(con), &writefds); 2205 } 2206 #endif 2207 2208 /* 2209 * Note: under VMS with SOCKETSHR the second parameter is 2210 * currently of type (int *) whereas under other systems it is 2211 * (void *) if you don't have a cast it will choke the compiler: 2212 * if you do have a cast then you can either go for (int *) or 2213 * (void *). 2214 */ 2215 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) 2216 /* 2217 * Under Windows/DOS we make the assumption that we can always 2218 * write to the tty: therefore if we need to write to the tty we 2219 * just fall through. Otherwise we timeout the select every 2220 * second and see if there are any keypresses. Note: this is a 2221 * hack, in a proper Windows application we wouldn't do this. 2222 */ 2223 i = 0; 2224 if (!write_tty) { 2225 if (read_tty) { 2226 tv.tv_sec = 1; 2227 tv.tv_usec = 0; 2228 i = select(width, (void *)&readfds, (void *)&writefds, 2229 NULL, &tv); 2230 if (!i && (!has_stdin_waiting() || !read_tty)) 2231 continue; 2232 } else 2233 i = select(width, (void *)&readfds, (void *)&writefds, 2234 NULL, timeoutp); 2235 } 2236 #else 2237 i = select(width, (void *)&readfds, (void *)&writefds, 2238 NULL, timeoutp); 2239 #endif 2240 if (i < 0) { 2241 BIO_printf(bio_err, "bad select %d\n", 2242 get_last_socket_error()); 2243 goto shut; 2244 /* goto end; */ 2245 } 2246 } 2247 2248 if ((SSL_version(con) == DTLS1_VERSION) 2249 && DTLSv1_handle_timeout(con) > 0) { 2250 BIO_printf(bio_err, "TIMEOUT occurred\n"); 2251 } 2252 2253 if (!ssl_pending && FD_ISSET(SSL_get_fd(con), &writefds)) { 2254 k = SSL_write(con, &(cbuf[cbuf_off]), (unsigned int)cbuf_len); 2255 switch (SSL_get_error(con, k)) { 2256 case SSL_ERROR_NONE: 2257 cbuf_off += k; 2258 cbuf_len -= k; 2259 if (k <= 0) 2260 goto end; 2261 /* we have done a write(con,NULL,0); */ 2262 if (cbuf_len <= 0) { 2263 read_tty = 1; 2264 write_ssl = 0; 2265 } else { /* if (cbuf_len > 0) */ 2266 2267 read_tty = 0; 2268 write_ssl = 1; 2269 } 2270 break; 2271 case SSL_ERROR_WANT_WRITE: 2272 BIO_printf(bio_c_out, "write W BLOCK\n"); 2273 write_ssl = 1; 2274 read_tty = 0; 2275 break; 2276 case SSL_ERROR_WANT_ASYNC: 2277 BIO_printf(bio_c_out, "write A BLOCK\n"); 2278 wait_for_async(con); 2279 write_ssl = 1; 2280 read_tty = 0; 2281 break; 2282 case SSL_ERROR_WANT_READ: 2283 BIO_printf(bio_c_out, "write R BLOCK\n"); 2284 write_tty = 0; 2285 read_ssl = 1; 2286 write_ssl = 0; 2287 break; 2288 case SSL_ERROR_WANT_X509_LOOKUP: 2289 BIO_printf(bio_c_out, "write X BLOCK\n"); 2290 break; 2291 case SSL_ERROR_ZERO_RETURN: 2292 if (cbuf_len != 0) { 2293 BIO_printf(bio_c_out, "shutdown\n"); 2294 ret = 0; 2295 goto shut; 2296 } else { 2297 read_tty = 1; 2298 write_ssl = 0; 2299 break; 2300 } 2301 2302 case SSL_ERROR_SYSCALL: 2303 if ((k != 0) || (cbuf_len != 0)) { 2304 BIO_printf(bio_err, "write:errno=%d\n", 2305 get_last_socket_error()); 2306 goto shut; 2307 } else { 2308 read_tty = 1; 2309 write_ssl = 0; 2310 } 2311 break; 2312 case SSL_ERROR_WANT_ASYNC_JOB: 2313 /* This shouldn't ever happen in s_client - treat as an error */ 2314 case SSL_ERROR_SSL: 2315 ERR_print_errors(bio_err); 2316 goto shut; 2317 } 2318 } 2319 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_VMS) 2320 /* Assume Windows/DOS/BeOS can always write */ 2321 else if (!ssl_pending && write_tty) 2322 #else 2323 else if (!ssl_pending && FD_ISSET(fdout, &writefds)) 2324 #endif 2325 { 2326 #ifdef CHARSET_EBCDIC 2327 ascii2ebcdic(&(sbuf[sbuf_off]), &(sbuf[sbuf_off]), sbuf_len); 2328 #endif 2329 i = raw_write_stdout(&(sbuf[sbuf_off]), sbuf_len); 2330 2331 if (i <= 0) { 2332 BIO_printf(bio_c_out, "DONE\n"); 2333 ret = 0; 2334 goto shut; 2335 /* goto end; */ 2336 } 2337 2338 sbuf_len -= i;; 2339 sbuf_off += i; 2340 if (sbuf_len <= 0) { 2341 read_ssl = 1; 2342 write_tty = 0; 2343 } 2344 } else if (ssl_pending || FD_ISSET(SSL_get_fd(con), &readfds)) { 2345 #ifdef RENEG 2346 { 2347 static int iiii; 2348 if (++iiii == 52) { 2349 SSL_renegotiate(con); 2350 iiii = 0; 2351 } 2352 } 2353 #endif 2354 k = SSL_read(con, sbuf, 1024 /* BUFSIZZ */ ); 2355 2356 switch (SSL_get_error(con, k)) { 2357 case SSL_ERROR_NONE: 2358 if (k <= 0) 2359 goto end; 2360 sbuf_off = 0; 2361 sbuf_len = k; 2362 2363 read_ssl = 0; 2364 write_tty = 1; 2365 break; 2366 case SSL_ERROR_WANT_ASYNC: 2367 BIO_printf(bio_c_out, "read A BLOCK\n"); 2368 wait_for_async(con); 2369 write_tty = 0; 2370 read_ssl = 1; 2371 if ((read_tty == 0) && (write_ssl == 0)) 2372 write_ssl = 1; 2373 break; 2374 case SSL_ERROR_WANT_WRITE: 2375 BIO_printf(bio_c_out, "read W BLOCK\n"); 2376 write_ssl = 1; 2377 read_tty = 0; 2378 break; 2379 case SSL_ERROR_WANT_READ: 2380 BIO_printf(bio_c_out, "read R BLOCK\n"); 2381 write_tty = 0; 2382 read_ssl = 1; 2383 if ((read_tty == 0) && (write_ssl == 0)) 2384 write_ssl = 1; 2385 break; 2386 case SSL_ERROR_WANT_X509_LOOKUP: 2387 BIO_printf(bio_c_out, "read X BLOCK\n"); 2388 break; 2389 case SSL_ERROR_SYSCALL: 2390 ret = get_last_socket_error(); 2391 if (c_brief) 2392 BIO_puts(bio_err, "CONNECTION CLOSED BY SERVER\n"); 2393 else 2394 BIO_printf(bio_err, "read:errno=%d\n", ret); 2395 goto shut; 2396 case SSL_ERROR_ZERO_RETURN: 2397 BIO_printf(bio_c_out, "closed\n"); 2398 ret = 0; 2399 goto shut; 2400 case SSL_ERROR_WANT_ASYNC_JOB: 2401 /* This shouldn't ever happen in s_client. Treat as an error */ 2402 case SSL_ERROR_SSL: 2403 ERR_print_errors(bio_err); 2404 goto shut; 2405 /* break; */ 2406 } 2407 } 2408 /* OPENSSL_SYS_MSDOS includes OPENSSL_SYS_WINDOWS */ 2409 #if defined(OPENSSL_SYS_MSDOS) 2410 else if (has_stdin_waiting()) 2411 #else 2412 else if (FD_ISSET(fdin, &readfds)) 2413 #endif 2414 { 2415 if (crlf) { 2416 int j, lf_num; 2417 2418 i = raw_read_stdin(cbuf, BUFSIZZ / 2); 2419 lf_num = 0; 2420 /* both loops are skipped when i <= 0 */ 2421 for (j = 0; j < i; j++) 2422 if (cbuf[j] == '\n') 2423 lf_num++; 2424 for (j = i - 1; j >= 0; j--) { 2425 cbuf[j + lf_num] = cbuf[j]; 2426 if (cbuf[j] == '\n') { 2427 lf_num--; 2428 i++; 2429 cbuf[j + lf_num] = '\r'; 2430 } 2431 } 2432 assert(lf_num == 0); 2433 } else 2434 i = raw_read_stdin(cbuf, BUFSIZZ); 2435 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) 2436 if (i == 0) 2437 at_eof = 1; 2438 #endif 2439 2440 if ((!c_ign_eof) && ((i <= 0) || (cbuf[0] == 'Q' && cmdletters))) { 2441 BIO_printf(bio_err, "DONE\n"); 2442 ret = 0; 2443 goto shut; 2444 } 2445 2446 if ((!c_ign_eof) && (cbuf[0] == 'R' && cmdletters)) { 2447 BIO_printf(bio_err, "RENEGOTIATING\n"); 2448 SSL_renegotiate(con); 2449 cbuf_len = 0; 2450 } 2451 #ifndef OPENSSL_NO_HEARTBEATS 2452 else if ((!c_ign_eof) && (cbuf[0] == 'B' && cmdletters)) { 2453 BIO_printf(bio_err, "HEARTBEATING\n"); 2454 SSL_heartbeat(con); 2455 cbuf_len = 0; 2456 } 2457 #endif 2458 else { 2459 cbuf_len = i; 2460 cbuf_off = 0; 2461 #ifdef CHARSET_EBCDIC 2462 ebcdic2ascii(cbuf, cbuf, i); 2463 #endif 2464 } 2465 2466 write_ssl = 1; 2467 read_tty = 0; 2468 } 2469 } 2470 2471 ret = 0; 2472 shut: 2473 if (in_init) 2474 print_stuff(bio_c_out, con, full_log); 2475 do_ssl_shutdown(con); 2476 2477 /* 2478 * Give the socket time to send its last data before we close it. 2479 * No amount of setting SO_LINGER etc on the socket seems to persuade 2480 * Windows to send the data before closing the socket...but sleeping 2481 * for a short time seems to do it (units in ms) 2482 * TODO: Find a better way to do this 2483 */ 2484 #if defined(OPENSSL_SYS_WINDOWS) 2485 Sleep(50); 2486 #elif defined(OPENSSL_SYS_CYGWIN) 2487 usleep(50000); 2488 #endif 2489 2490 /* 2491 * If we ended with an alert being sent, but still with data in the 2492 * network buffer to be read, then calling BIO_closesocket() will 2493 * result in a TCP-RST being sent. On some platforms (notably 2494 * Windows) then this will result in the peer immediately abandoning 2495 * the connection including any buffered alert data before it has 2496 * had a chance to be read. Shutting down the sending side first, 2497 * and then closing the socket sends TCP-FIN first followed by 2498 * TCP-RST. This seems to allow the peer to read the alert data. 2499 */ 2500 shutdown(SSL_get_fd(con), 1); /* SHUT_WR */ 2501 BIO_closesocket(SSL_get_fd(con)); 2502 end: 2503 if (con != NULL) { 2504 if (prexit != 0) 2505 print_stuff(bio_c_out, con, 1); 2506 SSL_free(con); 2507 } 2508 #if !defined(OPENSSL_NO_NEXTPROTONEG) 2509 OPENSSL_free(next_proto.data); 2510 #endif 2511 SSL_CTX_free(ctx); 2512 X509_free(cert); 2513 sk_X509_CRL_pop_free(crls, X509_CRL_free); 2514 EVP_PKEY_free(key); 2515 sk_X509_pop_free(chain, X509_free); 2516 OPENSSL_free(pass); 2517 #ifndef OPENSSL_NO_SRP 2518 OPENSSL_free(srp_arg.srppassin); 2519 #endif 2520 OPENSSL_free(connectstr); 2521 OPENSSL_free(host); 2522 OPENSSL_free(port); 2523 X509_VERIFY_PARAM_free(vpm); 2524 ssl_excert_free(exc); 2525 sk_OPENSSL_STRING_free(ssl_args); 2526 sk_OPENSSL_STRING_free(dane_tlsa_rrset); 2527 SSL_CONF_CTX_free(cctx); 2528 OPENSSL_clear_free(cbuf, BUFSIZZ); 2529 OPENSSL_clear_free(sbuf, BUFSIZZ); 2530 OPENSSL_clear_free(mbuf, BUFSIZZ); 2531 release_engine(e); 2532 BIO_free(bio_c_out); 2533 bio_c_out = NULL; 2534 BIO_free(bio_c_msg); 2535 bio_c_msg = NULL; 2536 return (ret); 2537 } 2538 2539 static void print_stuff(BIO *bio, SSL *s, int full) 2540 { 2541 X509 *peer = NULL; 2542 char buf[BUFSIZ]; 2543 STACK_OF(X509) *sk; 2544 STACK_OF(X509_NAME) *sk2; 2545 const SSL_CIPHER *c; 2546 X509_NAME *xn; 2547 int i; 2548 #ifndef OPENSSL_NO_COMP 2549 const COMP_METHOD *comp, *expansion; 2550 #endif 2551 unsigned char *exportedkeymat; 2552 #ifndef OPENSSL_NO_CT 2553 const SSL_CTX *ctx = SSL_get_SSL_CTX(s); 2554 #endif 2555 2556 if (full) { 2557 int got_a_chain = 0; 2558 2559 sk = SSL_get_peer_cert_chain(s); 2560 if (sk != NULL) { 2561 got_a_chain = 1; 2562 2563 BIO_printf(bio, "---\nCertificate chain\n"); 2564 for (i = 0; i < sk_X509_num(sk); i++) { 2565 X509_NAME_oneline(X509_get_subject_name(sk_X509_value(sk, i)), 2566 buf, sizeof(buf)); 2567 BIO_printf(bio, "%2d s:%s\n", i, buf); 2568 X509_NAME_oneline(X509_get_issuer_name(sk_X509_value(sk, i)), 2569 buf, sizeof(buf)); 2570 BIO_printf(bio, " i:%s\n", buf); 2571 if (c_showcerts) 2572 PEM_write_bio_X509(bio, sk_X509_value(sk, i)); 2573 } 2574 } 2575 2576 BIO_printf(bio, "---\n"); 2577 peer = SSL_get_peer_certificate(s); 2578 if (peer != NULL) { 2579 BIO_printf(bio, "Server certificate\n"); 2580 2581 /* Redundant if we showed the whole chain */ 2582 if (!(c_showcerts && got_a_chain)) 2583 PEM_write_bio_X509(bio, peer); 2584 X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof(buf)); 2585 BIO_printf(bio, "subject=%s\n", buf); 2586 X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof(buf)); 2587 BIO_printf(bio, "issuer=%s\n", buf); 2588 } else 2589 BIO_printf(bio, "no peer certificate available\n"); 2590 2591 sk2 = SSL_get_client_CA_list(s); 2592 if ((sk2 != NULL) && (sk_X509_NAME_num(sk2) > 0)) { 2593 BIO_printf(bio, "---\nAcceptable client certificate CA names\n"); 2594 for (i = 0; i < sk_X509_NAME_num(sk2); i++) { 2595 xn = sk_X509_NAME_value(sk2, i); 2596 X509_NAME_oneline(xn, buf, sizeof(buf)); 2597 BIO_write(bio, buf, strlen(buf)); 2598 BIO_write(bio, "\n", 1); 2599 } 2600 } else { 2601 BIO_printf(bio, "---\nNo client certificate CA names sent\n"); 2602 } 2603 2604 ssl_print_sigalgs(bio, s); 2605 ssl_print_tmp_key(bio, s); 2606 2607 #ifndef OPENSSL_NO_CT 2608 /* 2609 * When the SSL session is anonymous, or resumed via an abbreviated 2610 * handshake, no SCTs are provided as part of the handshake. While in 2611 * a resumed session SCTs may be present in the session's certificate, 2612 * no callbacks are invoked to revalidate these, and in any case that 2613 * set of SCTs may be incomplete. Thus it makes little sense to 2614 * attempt to display SCTs from a resumed session's certificate, and of 2615 * course none are associated with an anonymous peer. 2616 */ 2617 if (peer != NULL && !SSL_session_reused(s) && SSL_ct_is_enabled(s)) { 2618 const STACK_OF(SCT) *scts = SSL_get0_peer_scts(s); 2619 int sct_count = scts != NULL ? sk_SCT_num(scts) : 0; 2620 2621 BIO_printf(bio, "---\nSCTs present (%i)\n", sct_count); 2622 if (sct_count > 0) { 2623 const CTLOG_STORE *log_store = SSL_CTX_get0_ctlog_store(ctx); 2624 2625 BIO_printf(bio, "---\n"); 2626 for (i = 0; i < sct_count; ++i) { 2627 SCT *sct = sk_SCT_value(scts, i); 2628 2629 BIO_printf(bio, "SCT validation status: %s\n", 2630 SCT_validation_status_string(sct)); 2631 SCT_print(sct, bio, 0, log_store); 2632 if (i < sct_count - 1) 2633 BIO_printf(bio, "\n---\n"); 2634 } 2635 BIO_printf(bio, "\n"); 2636 } 2637 } 2638 #endif 2639 2640 BIO_printf(bio, 2641 "---\nSSL handshake has read %"BIO_PRI64"u" 2642 " bytes and written %"BIO_PRI64"u bytes\n", 2643 BIO_number_read(SSL_get_rbio(s)), 2644 BIO_number_written(SSL_get_wbio(s))); 2645 } 2646 print_verify_detail(s, bio); 2647 BIO_printf(bio, (SSL_session_reused(s) ? "---\nReused, " : "---\nNew, ")); 2648 c = SSL_get_current_cipher(s); 2649 BIO_printf(bio, "%s, Cipher is %s\n", 2650 SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c)); 2651 if (peer != NULL) { 2652 EVP_PKEY *pktmp; 2653 2654 pktmp = X509_get0_pubkey(peer); 2655 BIO_printf(bio, "Server public key is %d bit\n", 2656 EVP_PKEY_bits(pktmp)); 2657 } 2658 BIO_printf(bio, "Secure Renegotiation IS%s supported\n", 2659 SSL_get_secure_renegotiation_support(s) ? "" : " NOT"); 2660 #ifndef OPENSSL_NO_COMP 2661 comp = SSL_get_current_compression(s); 2662 expansion = SSL_get_current_expansion(s); 2663 BIO_printf(bio, "Compression: %s\n", 2664 comp ? SSL_COMP_get_name(comp) : "NONE"); 2665 BIO_printf(bio, "Expansion: %s\n", 2666 expansion ? SSL_COMP_get_name(expansion) : "NONE"); 2667 #endif 2668 2669 #ifdef SSL_DEBUG 2670 { 2671 /* Print out local port of connection: useful for debugging */ 2672 int sock; 2673 union BIO_sock_info_u info; 2674 2675 sock = SSL_get_fd(s); 2676 if ((info.addr = BIO_ADDR_new()) != NULL 2677 && BIO_sock_info(sock, BIO_SOCK_INFO_ADDRESS, &info)) { 2678 BIO_printf(bio_c_out, "LOCAL PORT is %u\n", 2679 ntohs(BIO_ADDR_rawport(info.addr))); 2680 } 2681 BIO_ADDR_free(info.addr); 2682 } 2683 #endif 2684 2685 #if !defined(OPENSSL_NO_NEXTPROTONEG) 2686 if (next_proto.status != -1) { 2687 const unsigned char *proto; 2688 unsigned int proto_len; 2689 SSL_get0_next_proto_negotiated(s, &proto, &proto_len); 2690 BIO_printf(bio, "Next protocol: (%d) ", next_proto.status); 2691 BIO_write(bio, proto, proto_len); 2692 BIO_write(bio, "\n", 1); 2693 } 2694 #endif 2695 { 2696 const unsigned char *proto; 2697 unsigned int proto_len; 2698 SSL_get0_alpn_selected(s, &proto, &proto_len); 2699 if (proto_len > 0) { 2700 BIO_printf(bio, "ALPN protocol: "); 2701 BIO_write(bio, proto, proto_len); 2702 BIO_write(bio, "\n", 1); 2703 } else 2704 BIO_printf(bio, "No ALPN negotiated\n"); 2705 } 2706 2707 #ifndef OPENSSL_NO_SRTP 2708 { 2709 SRTP_PROTECTION_PROFILE *srtp_profile = 2710 SSL_get_selected_srtp_profile(s); 2711 2712 if (srtp_profile) 2713 BIO_printf(bio, "SRTP Extension negotiated, profile=%s\n", 2714 srtp_profile->name); 2715 } 2716 #endif 2717 2718 SSL_SESSION_print(bio, SSL_get_session(s)); 2719 if (SSL_get_session(s) != NULL && keymatexportlabel != NULL) { 2720 BIO_printf(bio, "Keying material exporter:\n"); 2721 BIO_printf(bio, " Label: '%s'\n", keymatexportlabel); 2722 BIO_printf(bio, " Length: %i bytes\n", keymatexportlen); 2723 exportedkeymat = app_malloc(keymatexportlen, "export key"); 2724 if (!SSL_export_keying_material(s, exportedkeymat, 2725 keymatexportlen, 2726 keymatexportlabel, 2727 strlen(keymatexportlabel), 2728 NULL, 0, 0)) { 2729 BIO_printf(bio, " Error\n"); 2730 } else { 2731 BIO_printf(bio, " Keying material: "); 2732 for (i = 0; i < keymatexportlen; i++) 2733 BIO_printf(bio, "%02X", exportedkeymat[i]); 2734 BIO_printf(bio, "\n"); 2735 } 2736 OPENSSL_free(exportedkeymat); 2737 } 2738 BIO_printf(bio, "---\n"); 2739 X509_free(peer); 2740 /* flush, or debugging output gets mixed with http response */ 2741 (void)BIO_flush(bio); 2742 } 2743 2744 # ifndef OPENSSL_NO_OCSP 2745 static int ocsp_resp_cb(SSL *s, void *arg) 2746 { 2747 const unsigned char *p; 2748 int len; 2749 OCSP_RESPONSE *rsp; 2750 len = SSL_get_tlsext_status_ocsp_resp(s, &p); 2751 BIO_puts(arg, "OCSP response: "); 2752 if (!p) { 2753 BIO_puts(arg, "no response sent\n"); 2754 return 1; 2755 } 2756 rsp = d2i_OCSP_RESPONSE(NULL, &p, len); 2757 if (!rsp) { 2758 BIO_puts(arg, "response parse error\n"); 2759 BIO_dump_indent(arg, (char *)p, len, 4); 2760 return 0; 2761 } 2762 BIO_puts(arg, "\n======================================\n"); 2763 OCSP_RESPONSE_print(arg, rsp, 0); 2764 BIO_puts(arg, "======================================\n"); 2765 OCSP_RESPONSE_free(rsp); 2766 return 1; 2767 } 2768 # endif 2769 2770 #endif /* OPENSSL_NO_SOCK */ 2771
Indexes created Sat Feb 28 05:31:39 UTC 2026