s_client.c revision 1.14
1 /* 2 * Copyright 1995-2016 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 (ssl_config) { 1490 if (SSL_CTX_config(ctx, ssl_config) == 0) { 1491 BIO_printf(bio_err, "Error using configuration \"%s\"\n", 1492 ssl_config); 1493 ERR_print_errors(bio_err); 1494 goto end; 1495 } 1496 } 1497 1498 if (SSL_CTX_set_min_proto_version(ctx, min_version) == 0) 1499 goto end; 1500 if (SSL_CTX_set_max_proto_version(ctx, max_version) == 0) 1501 goto end; 1502 1503 if (vpmtouched && !SSL_CTX_set1_param(ctx, vpm)) { 1504 BIO_printf(bio_err, "Error setting verify params\n"); 1505 ERR_print_errors(bio_err); 1506 goto end; 1507 } 1508 1509 if (async) { 1510 SSL_CTX_set_mode(ctx, SSL_MODE_ASYNC); 1511 } 1512 if (split_send_fragment > 0) { 1513 SSL_CTX_set_split_send_fragment(ctx, split_send_fragment); 1514 } 1515 if (max_pipelines > 0) { 1516 SSL_CTX_set_max_pipelines(ctx, max_pipelines); 1517 } 1518 1519 if (read_buf_len > 0) { 1520 SSL_CTX_set_default_read_buffer_len(ctx, read_buf_len); 1521 } 1522 1523 if (!config_ctx(cctx, ssl_args, ctx)) 1524 goto end; 1525 1526 if (!ssl_load_stores(ctx, vfyCApath, vfyCAfile, chCApath, chCAfile, 1527 crls, crl_download)) { 1528 BIO_printf(bio_err, "Error loading store locations\n"); 1529 ERR_print_errors(bio_err); 1530 goto end; 1531 } 1532 #ifndef OPENSSL_NO_ENGINE 1533 if (ssl_client_engine) { 1534 if (!SSL_CTX_set_client_cert_engine(ctx, ssl_client_engine)) { 1535 BIO_puts(bio_err, "Error setting client auth engine\n"); 1536 ERR_print_errors(bio_err); 1537 ENGINE_free(ssl_client_engine); 1538 goto end; 1539 } 1540 ENGINE_free(ssl_client_engine); 1541 } 1542 #endif 1543 1544 #ifndef OPENSSL_NO_PSK 1545 if (psk_key != NULL) { 1546 if (c_debug) 1547 BIO_printf(bio_c_out, "PSK key given, setting client callback\n"); 1548 SSL_CTX_set_psk_client_callback(ctx, psk_client_cb); 1549 } 1550 #endif 1551 #ifndef OPENSSL_NO_SRTP 1552 if (srtp_profiles != NULL) { 1553 /* Returns 0 on success! */ 1554 if (SSL_CTX_set_tlsext_use_srtp(ctx, srtp_profiles) != 0) { 1555 BIO_printf(bio_err, "Error setting SRTP profile\n"); 1556 ERR_print_errors(bio_err); 1557 goto end; 1558 } 1559 } 1560 #endif 1561 1562 if (exc) 1563 ssl_ctx_set_excert(ctx, exc); 1564 1565 #if !defined(OPENSSL_NO_NEXTPROTONEG) 1566 if (next_proto.data) 1567 SSL_CTX_set_next_proto_select_cb(ctx, next_proto_cb, &next_proto); 1568 #endif 1569 if (alpn_in) { 1570 size_t alpn_len; 1571 unsigned char *alpn = next_protos_parse(&alpn_len, alpn_in); 1572 1573 if (alpn == NULL) { 1574 BIO_printf(bio_err, "Error parsing -alpn argument\n"); 1575 goto end; 1576 } 1577 /* Returns 0 on success! */ 1578 if (SSL_CTX_set_alpn_protos(ctx, alpn, alpn_len) != 0) { 1579 BIO_printf(bio_err, "Error setting ALPN\n"); 1580 goto end; 1581 } 1582 OPENSSL_free(alpn); 1583 } 1584 1585 for (i = 0; i < serverinfo_count; i++) { 1586 if (!SSL_CTX_add_client_custom_ext(ctx, 1587 serverinfo_types[i], 1588 NULL, NULL, NULL, 1589 serverinfo_cli_parse_cb, NULL)) { 1590 BIO_printf(bio_err, 1591 "Warning: Unable to add custom extension %u, skipping\n", 1592 serverinfo_types[i]); 1593 } 1594 } 1595 1596 if (state) 1597 SSL_CTX_set_info_callback(ctx, apps_ssl_info_callback); 1598 1599 #ifndef OPENSSL_NO_CT 1600 /* Enable SCT processing, without early connection termination */ 1601 if (ct_validation && 1602 !SSL_CTX_enable_ct(ctx, SSL_CT_VALIDATION_PERMISSIVE)) { 1603 ERR_print_errors(bio_err); 1604 goto end; 1605 } 1606 1607 if (!ctx_set_ctlog_list_file(ctx, ctlog_file)) { 1608 if (ct_validation) { 1609 ERR_print_errors(bio_err); 1610 goto end; 1611 } 1612 1613 /* 1614 * If CT validation is not enabled, the log list isn't needed so don't 1615 * show errors or abort. We try to load it regardless because then we 1616 * can show the names of the logs any SCTs came from (SCTs may be seen 1617 * even with validation disabled). 1618 */ 1619 ERR_clear_error(); 1620 } 1621 #endif 1622 1623 SSL_CTX_set_verify(ctx, verify, verify_callback); 1624 1625 if (!ctx_set_verify_locations(ctx, CAfile, CApath, noCAfile, noCApath)) { 1626 ERR_print_errors(bio_err); 1627 goto end; 1628 } 1629 1630 ssl_ctx_add_crls(ctx, crls, crl_download); 1631 1632 if (!set_cert_key_stuff(ctx, cert, key, chain, build_chain)) 1633 goto end; 1634 1635 if (servername != NULL) { 1636 tlsextcbp.biodebug = bio_err; 1637 SSL_CTX_set_tlsext_servername_callback(ctx, ssl_servername_cb); 1638 SSL_CTX_set_tlsext_servername_arg(ctx, &tlsextcbp); 1639 } 1640 # ifndef OPENSSL_NO_SRP 1641 if (srp_arg.srplogin) { 1642 if (!srp_lateuser && !SSL_CTX_set_srp_username(ctx, srp_arg.srplogin)) { 1643 BIO_printf(bio_err, "Unable to set SRP username\n"); 1644 goto end; 1645 } 1646 srp_arg.msg = c_msg; 1647 srp_arg.debug = c_debug; 1648 SSL_CTX_set_srp_cb_arg(ctx, &srp_arg); 1649 SSL_CTX_set_srp_client_pwd_callback(ctx, ssl_give_srp_client_pwd_cb); 1650 SSL_CTX_set_srp_strength(ctx, srp_arg.strength); 1651 if (c_msg || c_debug || srp_arg.amp == 0) 1652 SSL_CTX_set_srp_verify_param_callback(ctx, 1653 ssl_srp_verify_param_cb); 1654 } 1655 # endif 1656 1657 if (dane_tlsa_domain != NULL) { 1658 if (SSL_CTX_dane_enable(ctx) <= 0) { 1659 BIO_printf(bio_err, 1660 "%s: Error enabling DANE TLSA authentication.\n", 1661 prog); 1662 ERR_print_errors(bio_err); 1663 goto end; 1664 } 1665 } 1666 1667 con = SSL_new(ctx); 1668 if (sess_in) { 1669 SSL_SESSION *sess; 1670 BIO *stmp = BIO_new_file(sess_in, "r"); 1671 if (!stmp) { 1672 BIO_printf(bio_err, "Can't open session file %s\n", sess_in); 1673 ERR_print_errors(bio_err); 1674 goto end; 1675 } 1676 sess = PEM_read_bio_SSL_SESSION(stmp, NULL, 0, NULL); 1677 BIO_free(stmp); 1678 if (!sess) { 1679 BIO_printf(bio_err, "Can't open session file %s\n", sess_in); 1680 ERR_print_errors(bio_err); 1681 goto end; 1682 } 1683 if (!SSL_set_session(con, sess)) { 1684 BIO_printf(bio_err, "Can't set session\n"); 1685 ERR_print_errors(bio_err); 1686 goto end; 1687 } 1688 SSL_SESSION_free(sess); 1689 } 1690 1691 if (fallback_scsv) 1692 SSL_set_mode(con, SSL_MODE_SEND_FALLBACK_SCSV); 1693 1694 if (servername != NULL) { 1695 if (!SSL_set_tlsext_host_name(con, servername)) { 1696 BIO_printf(bio_err, "Unable to set TLS servername extension.\n"); 1697 ERR_print_errors(bio_err); 1698 goto end; 1699 } 1700 } 1701 1702 if (dane_tlsa_domain != NULL) { 1703 if (SSL_dane_enable(con, dane_tlsa_domain) <= 0) { 1704 BIO_printf(bio_err, "%s: Error enabling DANE TLSA " 1705 "authentication.\n", prog); 1706 ERR_print_errors(bio_err); 1707 goto end; 1708 } 1709 if (dane_tlsa_rrset == NULL) { 1710 BIO_printf(bio_err, "%s: DANE TLSA authentication requires at " 1711 "least one -dane_tlsa_rrdata option.\n", prog); 1712 goto end; 1713 } 1714 if (tlsa_import_rrset(con, dane_tlsa_rrset) <= 0) { 1715 BIO_printf(bio_err, "%s: Failed to import any TLSA " 1716 "records.\n", prog); 1717 goto end; 1718 } 1719 if (dane_ee_no_name) 1720 SSL_dane_set_flags(con, DANE_FLAG_NO_DANE_EE_NAMECHECKS); 1721 } else if (dane_tlsa_rrset != NULL) { 1722 BIO_printf(bio_err, "%s: DANE TLSA authentication requires the " 1723 "-dane_tlsa_domain option.\n", prog); 1724 goto end; 1725 } 1726 1727 re_start: 1728 if (init_client(&s, host, port, socket_family, socket_type) == 0) { 1729 BIO_printf(bio_err, "connect:errno=%d\n", get_last_socket_error()); 1730 BIO_closesocket(s); 1731 goto end; 1732 } 1733 BIO_printf(bio_c_out, "CONNECTED(%08X)\n", s); 1734 1735 if (c_nbio) { 1736 if (!BIO_socket_nbio(s, 1)) { 1737 ERR_print_errors(bio_err); 1738 goto end; 1739 } 1740 BIO_printf(bio_c_out, "Turned on non blocking io\n"); 1741 } 1742 #ifndef OPENSSL_NO_DTLS 1743 if (socket_type == SOCK_DGRAM) { 1744 union BIO_sock_info_u peer_info; 1745 1746 sbio = BIO_new_dgram(s, BIO_NOCLOSE); 1747 if ((peer_info.addr = BIO_ADDR_new()) == NULL) { 1748 BIO_printf(bio_err, "memory allocation failure\n"); 1749 BIO_closesocket(s); 1750 goto end; 1751 } 1752 if (!BIO_sock_info(s, BIO_SOCK_INFO_ADDRESS, &peer_info)) { 1753 BIO_printf(bio_err, "getsockname:errno=%d\n", 1754 get_last_socket_error()); 1755 BIO_ADDR_free(peer_info.addr); 1756 BIO_closesocket(s); 1757 goto end; 1758 } 1759 1760 (void)BIO_ctrl_set_connected(sbio, peer_info.addr); 1761 BIO_ADDR_free(peer_info.addr); 1762 peer_info.addr = NULL; 1763 1764 if (enable_timeouts) { 1765 timeout.tv_sec = 0; 1766 timeout.tv_usec = DGRAM_RCV_TIMEOUT; 1767 BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_RECV_TIMEOUT, 0, &timeout); 1768 1769 timeout.tv_sec = 0; 1770 timeout.tv_usec = DGRAM_SND_TIMEOUT; 1771 BIO_ctrl(sbio, BIO_CTRL_DGRAM_SET_SEND_TIMEOUT, 0, &timeout); 1772 } 1773 1774 if (socket_mtu) { 1775 if (socket_mtu < DTLS_get_link_min_mtu(con)) { 1776 BIO_printf(bio_err, "MTU too small. Must be at least %ld\n", 1777 DTLS_get_link_min_mtu(con)); 1778 BIO_free(sbio); 1779 goto shut; 1780 } 1781 SSL_set_options(con, SSL_OP_NO_QUERY_MTU); 1782 if (!DTLS_set_link_mtu(con, socket_mtu)) { 1783 BIO_printf(bio_err, "Failed to set MTU\n"); 1784 BIO_free(sbio); 1785 goto shut; 1786 } 1787 } else 1788 /* want to do MTU discovery */ 1789 BIO_ctrl(sbio, BIO_CTRL_DGRAM_MTU_DISCOVER, 0, NULL); 1790 } else 1791 #endif /* OPENSSL_NO_DTLS */ 1792 sbio = BIO_new_socket(s, BIO_NOCLOSE); 1793 1794 if (nbio_test) { 1795 BIO *test; 1796 1797 test = BIO_new(BIO_f_nbio_test()); 1798 sbio = BIO_push(test, sbio); 1799 } 1800 1801 if (c_debug) { 1802 BIO_set_callback(sbio, bio_dump_callback); 1803 BIO_set_callback_arg(sbio, (char *)bio_c_out); 1804 } 1805 if (c_msg) { 1806 #ifndef OPENSSL_NO_SSL_TRACE 1807 if (c_msg == 2) 1808 SSL_set_msg_callback(con, SSL_trace); 1809 else 1810 #endif 1811 SSL_set_msg_callback(con, msg_cb); 1812 SSL_set_msg_callback_arg(con, bio_c_msg ? bio_c_msg : bio_c_out); 1813 } 1814 1815 if (c_tlsextdebug) { 1816 SSL_set_tlsext_debug_callback(con, tlsext_cb); 1817 SSL_set_tlsext_debug_arg(con, bio_c_out); 1818 } 1819 #ifndef OPENSSL_NO_OCSP 1820 if (c_status_req) { 1821 SSL_set_tlsext_status_type(con, TLSEXT_STATUSTYPE_ocsp); 1822 SSL_CTX_set_tlsext_status_cb(ctx, ocsp_resp_cb); 1823 SSL_CTX_set_tlsext_status_arg(ctx, bio_c_out); 1824 } 1825 #endif 1826 1827 SSL_set_bio(con, sbio, sbio); 1828 SSL_set_connect_state(con); 1829 1830 /* ok, lets connect */ 1831 if (fileno_stdin() > SSL_get_fd(con)) 1832 width = fileno_stdin() + 1; 1833 else 1834 width = SSL_get_fd(con) + 1; 1835 1836 read_tty = 1; 1837 write_tty = 0; 1838 tty_on = 0; 1839 read_ssl = 1; 1840 write_ssl = 1; 1841 1842 cbuf_len = 0; 1843 cbuf_off = 0; 1844 sbuf_len = 0; 1845 sbuf_off = 0; 1846 1847 switch ((PROTOCOL_CHOICE) starttls_proto) { 1848 case PROTO_OFF: 1849 break; 1850 case PROTO_SMTP: 1851 { 1852 /* 1853 * This is an ugly hack that does a lot of assumptions. We do 1854 * have to handle multi-line responses which may come in a single 1855 * packet or not. We therefore have to use BIO_gets() which does 1856 * need a buffering BIO. So during the initial chitchat we do 1857 * push a buffering BIO into the chain that is removed again 1858 * later on to not disturb the rest of the s_client operation. 1859 */ 1860 int foundit = 0; 1861 BIO *fbio = BIO_new(BIO_f_buffer()); 1862 BIO_push(fbio, sbio); 1863 /* wait for multi-line response to end from SMTP */ 1864 do { 1865 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ); 1866 } 1867 while (mbuf_len > 3 && mbuf[3] == '-'); 1868 BIO_printf(fbio, "EHLO %s\r\n", ehlo); 1869 (void)BIO_flush(fbio); 1870 /* wait for multi-line response to end EHLO SMTP response */ 1871 do { 1872 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ); 1873 if (strstr(mbuf, "STARTTLS")) 1874 foundit = 1; 1875 } 1876 while (mbuf_len > 3 && mbuf[3] == '-'); 1877 (void)BIO_flush(fbio); 1878 BIO_pop(fbio); 1879 BIO_free(fbio); 1880 if (!foundit) 1881 BIO_printf(bio_err, 1882 "didn't find starttls in server response," 1883 " trying anyway...\n"); 1884 BIO_printf(sbio, "STARTTLS\r\n"); 1885 BIO_read(sbio, sbuf, BUFSIZZ); 1886 } 1887 break; 1888 case PROTO_POP3: 1889 { 1890 BIO_read(sbio, mbuf, BUFSIZZ); 1891 BIO_printf(sbio, "STLS\r\n"); 1892 mbuf_len = BIO_read(sbio, sbuf, BUFSIZZ); 1893 if (mbuf_len < 0) { 1894 BIO_printf(bio_err, "BIO_read failed\n"); 1895 goto end; 1896 } 1897 } 1898 break; 1899 case PROTO_IMAP: 1900 { 1901 int foundit = 0; 1902 BIO *fbio = BIO_new(BIO_f_buffer()); 1903 BIO_push(fbio, sbio); 1904 BIO_gets(fbio, mbuf, BUFSIZZ); 1905 /* STARTTLS command requires CAPABILITY... */ 1906 BIO_printf(fbio, ". CAPABILITY\r\n"); 1907 (void)BIO_flush(fbio); 1908 /* wait for multi-line CAPABILITY response */ 1909 do { 1910 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ); 1911 if (strstr(mbuf, "STARTTLS")) 1912 foundit = 1; 1913 } 1914 while (mbuf_len > 3 && mbuf[0] != '.'); 1915 (void)BIO_flush(fbio); 1916 BIO_pop(fbio); 1917 BIO_free(fbio); 1918 if (!foundit) 1919 BIO_printf(bio_err, 1920 "didn't find STARTTLS in server response," 1921 " trying anyway...\n"); 1922 BIO_printf(sbio, ". STARTTLS\r\n"); 1923 BIO_read(sbio, sbuf, BUFSIZZ); 1924 } 1925 break; 1926 case PROTO_FTP: 1927 { 1928 BIO *fbio = BIO_new(BIO_f_buffer()); 1929 BIO_push(fbio, sbio); 1930 /* wait for multi-line response to end from FTP */ 1931 do { 1932 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ); 1933 } 1934 while (mbuf_len > 3 && mbuf[3] == '-'); 1935 (void)BIO_flush(fbio); 1936 BIO_pop(fbio); 1937 BIO_free(fbio); 1938 BIO_printf(sbio, "AUTH TLS\r\n"); 1939 BIO_read(sbio, sbuf, BUFSIZZ); 1940 } 1941 break; 1942 case PROTO_XMPP: 1943 case PROTO_XMPP_SERVER: 1944 { 1945 int seen = 0; 1946 BIO_printf(sbio, "<stream:stream " 1947 "xmlns:stream='http://etherx.jabber.org/streams' " 1948 "xmlns='jabber:%s' to='%s' version='1.0'>", 1949 starttls_proto == PROTO_XMPP ? "client" : "server", 1950 xmpphost ? xmpphost : host); 1951 seen = BIO_read(sbio, mbuf, BUFSIZZ); 1952 mbuf[seen] = 0; 1953 while (!strstr 1954 (mbuf, "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'") 1955 && !strstr(mbuf, 1956 "<starttls xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\"")) 1957 { 1958 seen = BIO_read(sbio, mbuf, BUFSIZZ); 1959 1960 if (seen <= 0) 1961 goto shut; 1962 1963 mbuf[seen] = 0; 1964 } 1965 BIO_printf(sbio, 1966 "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>"); 1967 seen = BIO_read(sbio, sbuf, BUFSIZZ); 1968 sbuf[seen] = 0; 1969 if (!strstr(sbuf, "<proceed")) 1970 goto shut; 1971 mbuf[0] = 0; 1972 } 1973 break; 1974 case PROTO_TELNET: 1975 { 1976 static const unsigned char tls_do[] = { 1977 /* IAC DO START_TLS */ 1978 255, 253, 46 1979 }; 1980 static const unsigned char tls_will[] = { 1981 /* IAC WILL START_TLS */ 1982 255, 251, 46 1983 }; 1984 static const unsigned char tls_follows[] = { 1985 /* IAC SB START_TLS FOLLOWS IAC SE */ 1986 255, 250, 46, 1, 255, 240 1987 }; 1988 int bytes; 1989 1990 /* Telnet server should demand we issue START_TLS */ 1991 bytes = BIO_read(sbio, mbuf, BUFSIZZ); 1992 if (bytes != 3 || memcmp(mbuf, tls_do, 3) != 0) 1993 goto shut; 1994 /* Agree to issue START_TLS and send the FOLLOWS sub-command */ 1995 BIO_write(sbio, tls_will, 3); 1996 BIO_write(sbio, tls_follows, 6); 1997 (void)BIO_flush(sbio); 1998 /* Telnet server also sent the FOLLOWS sub-command */ 1999 bytes = BIO_read(sbio, mbuf, BUFSIZZ); 2000 if (bytes != 6 || memcmp(mbuf, tls_follows, 6) != 0) 2001 goto shut; 2002 } 2003 break; 2004 case PROTO_CONNECT: 2005 { 2006 enum { 2007 error_proto, /* Wrong protocol, not even HTTP */ 2008 error_connect, /* CONNECT failed */ 2009 success 2010 } foundit = error_connect; 2011 BIO *fbio = BIO_new(BIO_f_buffer()); 2012 2013 BIO_push(fbio, sbio); 2014 BIO_printf(fbio, "CONNECT %s HTTP/1.0\r\n\r\n", connectstr); 2015 (void)BIO_flush(fbio); 2016 /* 2017 * The first line is the HTTP response. According to RFC 7230, 2018 * it's formated exactly like this: 2019 * 2020 * HTTP/d.d ddd Reason text\r\n 2021 */ 2022 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ); 2023 if (mbuf[8] != ' ') { 2024 BIO_printf(bio_err, 2025 "%s: HTTP CONNECT failed, incorrect response " 2026 "from proxy\n", prog); 2027 foundit = error_proto; 2028 } else if (mbuf[9] != '2') { 2029 BIO_printf(bio_err, "%s: HTTP CONNECT failed: %s ", prog, 2030 &mbuf[9]); 2031 } else { 2032 foundit = success; 2033 } 2034 if (foundit != error_proto) { 2035 /* Read past all following headers */ 2036 do { 2037 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ); 2038 } while (mbuf_len > 2); 2039 } 2040 (void)BIO_flush(fbio); 2041 BIO_pop(fbio); 2042 BIO_free(fbio); 2043 if (foundit != success) { 2044 goto shut; 2045 } 2046 } 2047 break; 2048 case PROTO_IRC: 2049 { 2050 int numeric; 2051 BIO *fbio = BIO_new(BIO_f_buffer()); 2052 2053 BIO_push(fbio, sbio); 2054 BIO_printf(fbio, "STARTTLS\r\n"); 2055 (void)BIO_flush(fbio); 2056 width = SSL_get_fd(con) + 1; 2057 2058 do { 2059 numeric = 0; 2060 2061 FD_ZERO(&readfds); 2062 openssl_fdset(SSL_get_fd(con), &readfds); 2063 timeout.tv_sec = S_CLIENT_IRC_READ_TIMEOUT; 2064 timeout.tv_usec = 0; 2065 /* 2066 * If the IRCd doesn't respond within 2067 * S_CLIENT_IRC_READ_TIMEOUT seconds, assume 2068 * it doesn't support STARTTLS. Many IRCds 2069 * will not give _any_ sort of response to a 2070 * STARTTLS command when it's not supported. 2071 */ 2072 if (!BIO_get_buffer_num_lines(fbio) 2073 && !BIO_pending(fbio) 2074 && !BIO_pending(sbio) 2075 && select(width, (void *)&readfds, NULL, NULL, 2076 &timeout) < 1) { 2077 BIO_printf(bio_err, 2078 "Timeout waiting for response (%d seconds).\n", 2079 S_CLIENT_IRC_READ_TIMEOUT); 2080 break; 2081 } 2082 2083 mbuf_len = BIO_gets(fbio, mbuf, BUFSIZZ); 2084 if (mbuf_len < 1 || sscanf(mbuf, "%*s %d", &numeric) != 1) 2085 break; 2086 /* :example.net 451 STARTTLS :You have not registered */ 2087 /* :example.net 421 STARTTLS :Unknown command */ 2088 if ((numeric == 451 || numeric == 421) 2089 && strstr(mbuf, "STARTTLS") != NULL) { 2090 BIO_printf(bio_err, "STARTTLS not supported: %s", mbuf); 2091 break; 2092 } 2093 if (numeric == 691) { 2094 BIO_printf(bio_err, "STARTTLS negotiation failed: "); 2095 ERR_print_errors(bio_err); 2096 break; 2097 } 2098 } while (numeric != 670); 2099 2100 (void)BIO_flush(fbio); 2101 BIO_pop(fbio); 2102 BIO_free(fbio); 2103 if (numeric != 670) { 2104 BIO_printf(bio_err, "Server does not support STARTTLS.\n"); 2105 ret = 1; 2106 goto shut; 2107 } 2108 } 2109 } 2110 2111 for (;;) { 2112 FD_ZERO(&readfds); 2113 FD_ZERO(&writefds); 2114 int fdin = fileno_stdin(); 2115 if (fdin < 0) { 2116 BIO_printf(bio_err,"bad fileno for stdin\n"); 2117 goto shut; 2118 } 2119 int fdout = fileno_stdout(); 2120 if (fdout < 0) { 2121 BIO_printf(bio_err,"bad fileno for stdout\n"); 2122 goto shut; 2123 } 2124 2125 if ((SSL_version(con) == DTLS1_VERSION) && 2126 DTLSv1_get_timeout(con, &timeout)) 2127 timeoutp = &timeout; 2128 else 2129 timeoutp = NULL; 2130 2131 if (SSL_in_init(con) && !SSL_total_renegotiations(con)) { 2132 in_init = 1; 2133 tty_on = 0; 2134 } else { 2135 tty_on = 1; 2136 if (in_init) { 2137 in_init = 0; 2138 2139 if (sess_out) { 2140 BIO *stmp = BIO_new_file(sess_out, "w"); 2141 if (stmp) { 2142 PEM_write_bio_SSL_SESSION(stmp, SSL_get_session(con)); 2143 BIO_free(stmp); 2144 } else 2145 BIO_printf(bio_err, "Error writing session file %s\n", 2146 sess_out); 2147 } 2148 if (c_brief) { 2149 BIO_puts(bio_err, "CONNECTION ESTABLISHED\n"); 2150 print_ssl_summary(con); 2151 } 2152 2153 print_stuff(bio_c_out, con, full_log); 2154 if (full_log > 0) 2155 full_log--; 2156 2157 if (starttls_proto) { 2158 BIO_write(bio_err, mbuf, mbuf_len); 2159 /* We don't need to know any more */ 2160 if (!reconnect) 2161 starttls_proto = PROTO_OFF; 2162 } 2163 2164 if (reconnect) { 2165 reconnect--; 2166 BIO_printf(bio_c_out, 2167 "drop connection and then reconnect\n"); 2168 do_ssl_shutdown(con); 2169 SSL_set_connect_state(con); 2170 BIO_closesocket(SSL_get_fd(con)); 2171 goto re_start; 2172 } 2173 } 2174 } 2175 2176 ssl_pending = read_ssl && SSL_has_pending(con); 2177 2178 if (!ssl_pending) { 2179 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) 2180 if (tty_on) { 2181 /* 2182 * Note that select() returns when read _would not block_, 2183 * and EOF satisfies that. To avoid a CPU-hogging loop, 2184 * set the flag so we exit. 2185 */ 2186 if (read_tty && !at_eof) 2187 openssl_fdset(fileno_stdin(), &readfds); 2188 #if !defined(OPENSSL_SYS_VMS) 2189 if (write_tty) 2190 openssl_fdset(fdout, &writefds); 2191 #endif 2192 } 2193 if (read_ssl) 2194 openssl_fdset(SSL_get_fd(con), &readfds); 2195 if (write_ssl) 2196 openssl_fdset(SSL_get_fd(con), &writefds); 2197 #else 2198 if (!tty_on || !write_tty) { 2199 if (read_ssl) 2200 openssl_fdset(SSL_get_fd(con), &readfds); 2201 if (write_ssl) 2202 openssl_fdset(SSL_get_fd(con), &writefds); 2203 } 2204 #endif 2205 2206 /* 2207 * Note: under VMS with SOCKETSHR the second parameter is 2208 * currently of type (int *) whereas under other systems it is 2209 * (void *) if you don't have a cast it will choke the compiler: 2210 * if you do have a cast then you can either go for (int *) or 2211 * (void *). 2212 */ 2213 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) 2214 /* 2215 * Under Windows/DOS we make the assumption that we can always 2216 * write to the tty: therefore if we need to write to the tty we 2217 * just fall through. Otherwise we timeout the select every 2218 * second and see if there are any keypresses. Note: this is a 2219 * hack, in a proper Windows application we wouldn't do this. 2220 */ 2221 i = 0; 2222 if (!write_tty) { 2223 if (read_tty) { 2224 tv.tv_sec = 1; 2225 tv.tv_usec = 0; 2226 i = select(width, (void *)&readfds, (void *)&writefds, 2227 NULL, &tv); 2228 if (!i && (!has_stdin_waiting() || !read_tty)) 2229 continue; 2230 } else 2231 i = select(width, (void *)&readfds, (void *)&writefds, 2232 NULL, timeoutp); 2233 } 2234 #else 2235 i = select(width, (void *)&readfds, (void *)&writefds, 2236 NULL, timeoutp); 2237 #endif 2238 if (i < 0) { 2239 BIO_printf(bio_err, "bad select %d\n", 2240 get_last_socket_error()); 2241 goto shut; 2242 /* goto end; */ 2243 } 2244 } 2245 2246 if ((SSL_version(con) == DTLS1_VERSION) 2247 && DTLSv1_handle_timeout(con) > 0) { 2248 BIO_printf(bio_err, "TIMEOUT occurred\n"); 2249 } 2250 2251 if (!ssl_pending && FD_ISSET(SSL_get_fd(con), &writefds)) { 2252 k = SSL_write(con, &(cbuf[cbuf_off]), (unsigned int)cbuf_len); 2253 switch (SSL_get_error(con, k)) { 2254 case SSL_ERROR_NONE: 2255 cbuf_off += k; 2256 cbuf_len -= k; 2257 if (k <= 0) 2258 goto end; 2259 /* we have done a write(con,NULL,0); */ 2260 if (cbuf_len <= 0) { 2261 read_tty = 1; 2262 write_ssl = 0; 2263 } else { /* if (cbuf_len > 0) */ 2264 2265 read_tty = 0; 2266 write_ssl = 1; 2267 } 2268 break; 2269 case SSL_ERROR_WANT_WRITE: 2270 BIO_printf(bio_c_out, "write W BLOCK\n"); 2271 write_ssl = 1; 2272 read_tty = 0; 2273 break; 2274 case SSL_ERROR_WANT_ASYNC: 2275 BIO_printf(bio_c_out, "write A BLOCK\n"); 2276 wait_for_async(con); 2277 write_ssl = 1; 2278 read_tty = 0; 2279 break; 2280 case SSL_ERROR_WANT_READ: 2281 BIO_printf(bio_c_out, "write R BLOCK\n"); 2282 write_tty = 0; 2283 read_ssl = 1; 2284 write_ssl = 0; 2285 break; 2286 case SSL_ERROR_WANT_X509_LOOKUP: 2287 BIO_printf(bio_c_out, "write X BLOCK\n"); 2288 break; 2289 case SSL_ERROR_ZERO_RETURN: 2290 if (cbuf_len != 0) { 2291 BIO_printf(bio_c_out, "shutdown\n"); 2292 ret = 0; 2293 goto shut; 2294 } else { 2295 read_tty = 1; 2296 write_ssl = 0; 2297 break; 2298 } 2299 2300 case SSL_ERROR_SYSCALL: 2301 if ((k != 0) || (cbuf_len != 0)) { 2302 BIO_printf(bio_err, "write:errno=%d\n", 2303 get_last_socket_error()); 2304 goto shut; 2305 } else { 2306 read_tty = 1; 2307 write_ssl = 0; 2308 } 2309 break; 2310 case SSL_ERROR_WANT_ASYNC_JOB: 2311 /* This shouldn't ever happen in s_client - treat as an error */ 2312 case SSL_ERROR_SSL: 2313 ERR_print_errors(bio_err); 2314 goto shut; 2315 } 2316 } 2317 #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_VMS) 2318 /* Assume Windows/DOS/BeOS can always write */ 2319 else if (!ssl_pending && write_tty) 2320 #else 2321 else if (!ssl_pending && FD_ISSET(fdout, &writefds)) 2322 #endif 2323 { 2324 #ifdef CHARSET_EBCDIC 2325 ascii2ebcdic(&(sbuf[sbuf_off]), &(sbuf[sbuf_off]), sbuf_len); 2326 #endif 2327 i = raw_write_stdout(&(sbuf[sbuf_off]), sbuf_len); 2328 2329 if (i <= 0) { 2330 BIO_printf(bio_c_out, "DONE\n"); 2331 ret = 0; 2332 goto shut; 2333 /* goto end; */ 2334 } 2335 2336 sbuf_len -= i;; 2337 sbuf_off += i; 2338 if (sbuf_len <= 0) { 2339 read_ssl = 1; 2340 write_tty = 0; 2341 } 2342 } else if (ssl_pending || FD_ISSET(SSL_get_fd(con), &readfds)) { 2343 #ifdef RENEG 2344 { 2345 static int iiii; 2346 if (++iiii == 52) { 2347 SSL_renegotiate(con); 2348 iiii = 0; 2349 } 2350 } 2351 #endif 2352 k = SSL_read(con, sbuf, 1024 /* BUFSIZZ */ ); 2353 2354 switch (SSL_get_error(con, k)) { 2355 case SSL_ERROR_NONE: 2356 if (k <= 0) 2357 goto end; 2358 sbuf_off = 0; 2359 sbuf_len = k; 2360 2361 read_ssl = 0; 2362 write_tty = 1; 2363 break; 2364 case SSL_ERROR_WANT_ASYNC: 2365 BIO_printf(bio_c_out, "read A BLOCK\n"); 2366 wait_for_async(con); 2367 write_tty = 0; 2368 read_ssl = 1; 2369 if ((read_tty == 0) && (write_ssl == 0)) 2370 write_ssl = 1; 2371 break; 2372 case SSL_ERROR_WANT_WRITE: 2373 BIO_printf(bio_c_out, "read W BLOCK\n"); 2374 write_ssl = 1; 2375 read_tty = 0; 2376 break; 2377 case SSL_ERROR_WANT_READ: 2378 BIO_printf(bio_c_out, "read R BLOCK\n"); 2379 write_tty = 0; 2380 read_ssl = 1; 2381 if ((read_tty == 0) && (write_ssl == 0)) 2382 write_ssl = 1; 2383 break; 2384 case SSL_ERROR_WANT_X509_LOOKUP: 2385 BIO_printf(bio_c_out, "read X BLOCK\n"); 2386 break; 2387 case SSL_ERROR_SYSCALL: 2388 ret = get_last_socket_error(); 2389 if (c_brief) 2390 BIO_puts(bio_err, "CONNECTION CLOSED BY SERVER\n"); 2391 else 2392 BIO_printf(bio_err, "read:errno=%d\n", ret); 2393 goto shut; 2394 case SSL_ERROR_ZERO_RETURN: 2395 BIO_printf(bio_c_out, "closed\n"); 2396 ret = 0; 2397 goto shut; 2398 case SSL_ERROR_WANT_ASYNC_JOB: 2399 /* This shouldn't ever happen in s_client. Treat as an error */ 2400 case SSL_ERROR_SSL: 2401 ERR_print_errors(bio_err); 2402 goto shut; 2403 /* break; */ 2404 } 2405 } 2406 /* OPENSSL_SYS_MSDOS includes OPENSSL_SYS_WINDOWS */ 2407 #if defined(OPENSSL_SYS_MSDOS) 2408 else if (has_stdin_waiting()) 2409 #else 2410 else if (FD_ISSET(fdin, &readfds)) 2411 #endif 2412 { 2413 if (crlf) { 2414 int j, lf_num; 2415 2416 i = raw_read_stdin(cbuf, BUFSIZZ / 2); 2417 lf_num = 0; 2418 /* both loops are skipped when i <= 0 */ 2419 for (j = 0; j < i; j++) 2420 if (cbuf[j] == '\n') 2421 lf_num++; 2422 for (j = i - 1; j >= 0; j--) { 2423 cbuf[j + lf_num] = cbuf[j]; 2424 if (cbuf[j] == '\n') { 2425 lf_num--; 2426 i++; 2427 cbuf[j + lf_num] = '\r'; 2428 } 2429 } 2430 assert(lf_num == 0); 2431 } else 2432 i = raw_read_stdin(cbuf, BUFSIZZ); 2433 #if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_MSDOS) 2434 if (i == 0) 2435 at_eof = 1; 2436 #endif 2437 2438 if ((!c_ign_eof) && ((i <= 0) || (cbuf[0] == 'Q' && cmdletters))) { 2439 BIO_printf(bio_err, "DONE\n"); 2440 ret = 0; 2441 goto shut; 2442 } 2443 2444 if ((!c_ign_eof) && (cbuf[0] == 'R' && cmdletters)) { 2445 BIO_printf(bio_err, "RENEGOTIATING\n"); 2446 SSL_renegotiate(con); 2447 cbuf_len = 0; 2448 } 2449 #ifndef OPENSSL_NO_HEARTBEATS 2450 else if ((!c_ign_eof) && (cbuf[0] == 'B' && cmdletters)) { 2451 BIO_printf(bio_err, "HEARTBEATING\n"); 2452 SSL_heartbeat(con); 2453 cbuf_len = 0; 2454 } 2455 #endif 2456 else { 2457 cbuf_len = i; 2458 cbuf_off = 0; 2459 #ifdef CHARSET_EBCDIC 2460 ebcdic2ascii(cbuf, cbuf, i); 2461 #endif 2462 } 2463 2464 write_ssl = 1; 2465 read_tty = 0; 2466 } 2467 } 2468 2469 ret = 0; 2470 shut: 2471 if (in_init) 2472 print_stuff(bio_c_out, con, full_log); 2473 do_ssl_shutdown(con); 2474 #if defined(OPENSSL_SYS_WINDOWS) 2475 /* 2476 * Give the socket time to send its last data before we close it. 2477 * No amount of setting SO_LINGER etc on the socket seems to persuade 2478 * Windows to send the data before closing the socket...but sleeping 2479 * for a short time seems to do it (units in ms) 2480 * TODO: Find a better way to do this 2481 */ 2482 Sleep(50); 2483 #endif 2484 BIO_closesocket(SSL_get_fd(con)); 2485 end: 2486 if (con != NULL) { 2487 if (prexit != 0) 2488 print_stuff(bio_c_out, con, 1); 2489 SSL_free(con); 2490 } 2491 #if !defined(OPENSSL_NO_NEXTPROTONEG) 2492 OPENSSL_free(next_proto.data); 2493 #endif 2494 SSL_CTX_free(ctx); 2495 X509_free(cert); 2496 sk_X509_CRL_pop_free(crls, X509_CRL_free); 2497 EVP_PKEY_free(key); 2498 sk_X509_pop_free(chain, X509_free); 2499 OPENSSL_free(pass); 2500 #ifndef OPENSSL_NO_SRP 2501 OPENSSL_free(srp_arg.srppassin); 2502 #endif 2503 OPENSSL_free(connectstr); 2504 OPENSSL_free(host); 2505 OPENSSL_free(port); 2506 X509_VERIFY_PARAM_free(vpm); 2507 ssl_excert_free(exc); 2508 sk_OPENSSL_STRING_free(ssl_args); 2509 sk_OPENSSL_STRING_free(dane_tlsa_rrset); 2510 SSL_CONF_CTX_free(cctx); 2511 OPENSSL_clear_free(cbuf, BUFSIZZ); 2512 OPENSSL_clear_free(sbuf, BUFSIZZ); 2513 OPENSSL_clear_free(mbuf, BUFSIZZ); 2514 release_engine(e); 2515 BIO_free(bio_c_out); 2516 bio_c_out = NULL; 2517 BIO_free(bio_c_msg); 2518 bio_c_msg = NULL; 2519 return (ret); 2520 } 2521 2522 static void print_stuff(BIO *bio, SSL *s, int full) 2523 { 2524 X509 *peer = NULL; 2525 char buf[BUFSIZ]; 2526 STACK_OF(X509) *sk; 2527 STACK_OF(X509_NAME) *sk2; 2528 const SSL_CIPHER *c; 2529 X509_NAME *xn; 2530 int i; 2531 #ifndef OPENSSL_NO_COMP 2532 const COMP_METHOD *comp, *expansion; 2533 #endif 2534 unsigned char *exportedkeymat; 2535 #ifndef OPENSSL_NO_CT 2536 const SSL_CTX *ctx = SSL_get_SSL_CTX(s); 2537 #endif 2538 2539 if (full) { 2540 int got_a_chain = 0; 2541 2542 sk = SSL_get_peer_cert_chain(s); 2543 if (sk != NULL) { 2544 got_a_chain = 1; 2545 2546 BIO_printf(bio, "---\nCertificate chain\n"); 2547 for (i = 0; i < sk_X509_num(sk); i++) { 2548 X509_NAME_oneline(X509_get_subject_name(sk_X509_value(sk, i)), 2549 buf, sizeof buf); 2550 BIO_printf(bio, "%2d s:%s\n", i, buf); 2551 X509_NAME_oneline(X509_get_issuer_name(sk_X509_value(sk, i)), 2552 buf, sizeof buf); 2553 BIO_printf(bio, " i:%s\n", buf); 2554 if (c_showcerts) 2555 PEM_write_bio_X509(bio, sk_X509_value(sk, i)); 2556 } 2557 } 2558 2559 BIO_printf(bio, "---\n"); 2560 peer = SSL_get_peer_certificate(s); 2561 if (peer != NULL) { 2562 BIO_printf(bio, "Server certificate\n"); 2563 2564 /* Redundant if we showed the whole chain */ 2565 if (!(c_showcerts && got_a_chain)) 2566 PEM_write_bio_X509(bio, peer); 2567 X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof buf); 2568 BIO_printf(bio, "subject=%s\n", buf); 2569 X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof buf); 2570 BIO_printf(bio, "issuer=%s\n", buf); 2571 } else 2572 BIO_printf(bio, "no peer certificate available\n"); 2573 2574 sk2 = SSL_get_client_CA_list(s); 2575 if ((sk2 != NULL) && (sk_X509_NAME_num(sk2) > 0)) { 2576 BIO_printf(bio, "---\nAcceptable client certificate CA names\n"); 2577 for (i = 0; i < sk_X509_NAME_num(sk2); i++) { 2578 xn = sk_X509_NAME_value(sk2, i); 2579 X509_NAME_oneline(xn, buf, sizeof(buf)); 2580 BIO_write(bio, buf, strlen(buf)); 2581 BIO_write(bio, "\n", 1); 2582 } 2583 } else { 2584 BIO_printf(bio, "---\nNo client certificate CA names sent\n"); 2585 } 2586 2587 ssl_print_sigalgs(bio, s); 2588 ssl_print_tmp_key(bio, s); 2589 2590 #ifndef OPENSSL_NO_CT 2591 /* 2592 * When the SSL session is anonymous, or resumed via an abbreviated 2593 * handshake, no SCTs are provided as part of the handshake. While in 2594 * a resumed session SCTs may be present in the session's certificate, 2595 * no callbacks are invoked to revalidate these, and in any case that 2596 * set of SCTs may be incomplete. Thus it makes little sense to 2597 * attempt to display SCTs from a resumed session's certificate, and of 2598 * course none are associated with an anonymous peer. 2599 */ 2600 if (peer != NULL && !SSL_session_reused(s) && SSL_ct_is_enabled(s)) { 2601 const STACK_OF(SCT) *scts = SSL_get0_peer_scts(s); 2602 int sct_count = scts != NULL ? sk_SCT_num(scts) : 0; 2603 2604 BIO_printf(bio, "---\nSCTs present (%i)\n", sct_count); 2605 if (sct_count > 0) { 2606 const CTLOG_STORE *log_store = SSL_CTX_get0_ctlog_store(ctx); 2607 2608 BIO_printf(bio, "---\n"); 2609 for (i = 0; i < sct_count; ++i) { 2610 SCT *sct = sk_SCT_value(scts, i); 2611 2612 BIO_printf(bio, "SCT validation status: %s\n", 2613 SCT_validation_status_string(sct)); 2614 SCT_print(sct, bio, 0, log_store); 2615 if (i < sct_count - 1) 2616 BIO_printf(bio, "\n---\n"); 2617 } 2618 BIO_printf(bio, "\n"); 2619 } 2620 } 2621 #endif 2622 2623 BIO_printf(bio, 2624 "---\nSSL handshake has read %"BIO_PRI64"u" 2625 " bytes and written %"BIO_PRI64"u bytes\n", 2626 BIO_number_read(SSL_get_rbio(s)), 2627 BIO_number_written(SSL_get_wbio(s))); 2628 } 2629 print_verify_detail(s, bio); 2630 BIO_printf(bio, (SSL_session_reused(s) ? "---\nReused, " : "---\nNew, ")); 2631 c = SSL_get_current_cipher(s); 2632 BIO_printf(bio, "%s, Cipher is %s\n", 2633 SSL_CIPHER_get_version(c), SSL_CIPHER_get_name(c)); 2634 if (peer != NULL) { 2635 EVP_PKEY *pktmp; 2636 2637 pktmp = X509_get0_pubkey(peer); 2638 BIO_printf(bio, "Server public key is %d bit\n", 2639 EVP_PKEY_bits(pktmp)); 2640 } 2641 BIO_printf(bio, "Secure Renegotiation IS%s supported\n", 2642 SSL_get_secure_renegotiation_support(s) ? "" : " NOT"); 2643 #ifndef OPENSSL_NO_COMP 2644 comp = SSL_get_current_compression(s); 2645 expansion = SSL_get_current_expansion(s); 2646 BIO_printf(bio, "Compression: %s\n", 2647 comp ? SSL_COMP_get_name(comp) : "NONE"); 2648 BIO_printf(bio, "Expansion: %s\n", 2649 expansion ? SSL_COMP_get_name(expansion) : "NONE"); 2650 #endif 2651 2652 #ifdef SSL_DEBUG 2653 { 2654 /* Print out local port of connection: useful for debugging */ 2655 int sock; 2656 union BIO_sock_info_u info; 2657 2658 sock = SSL_get_fd(s); 2659 if ((info.addr = BIO_ADDR_new()) != NULL 2660 && BIO_sock_info(sock, BIO_SOCK_INFO_ADDRESS, &info)) { 2661 BIO_printf(bio_c_out, "LOCAL PORT is %u\n", 2662 ntohs(BIO_ADDR_rawport(info.addr))); 2663 } 2664 BIO_ADDR_free(info.addr); 2665 } 2666 #endif 2667 2668 #if !defined(OPENSSL_NO_NEXTPROTONEG) 2669 if (next_proto.status != -1) { 2670 const unsigned char *proto; 2671 unsigned int proto_len; 2672 SSL_get0_next_proto_negotiated(s, &proto, &proto_len); 2673 BIO_printf(bio, "Next protocol: (%d) ", next_proto.status); 2674 BIO_write(bio, proto, proto_len); 2675 BIO_write(bio, "\n", 1); 2676 } 2677 #endif 2678 { 2679 const unsigned char *proto; 2680 unsigned int proto_len; 2681 SSL_get0_alpn_selected(s, &proto, &proto_len); 2682 if (proto_len > 0) { 2683 BIO_printf(bio, "ALPN protocol: "); 2684 BIO_write(bio, proto, proto_len); 2685 BIO_write(bio, "\n", 1); 2686 } else 2687 BIO_printf(bio, "No ALPN negotiated\n"); 2688 } 2689 2690 #ifndef OPENSSL_NO_SRTP 2691 { 2692 SRTP_PROTECTION_PROFILE *srtp_profile = 2693 SSL_get_selected_srtp_profile(s); 2694 2695 if (srtp_profile) 2696 BIO_printf(bio, "SRTP Extension negotiated, profile=%s\n", 2697 srtp_profile->name); 2698 } 2699 #endif 2700 2701 SSL_SESSION_print(bio, SSL_get_session(s)); 2702 if (SSL_get_session(s) != NULL && keymatexportlabel != NULL) { 2703 BIO_printf(bio, "Keying material exporter:\n"); 2704 BIO_printf(bio, " Label: '%s'\n", keymatexportlabel); 2705 BIO_printf(bio, " Length: %i bytes\n", keymatexportlen); 2706 exportedkeymat = app_malloc(keymatexportlen, "export key"); 2707 if (!SSL_export_keying_material(s, exportedkeymat, 2708 keymatexportlen, 2709 keymatexportlabel, 2710 strlen(keymatexportlabel), 2711 NULL, 0, 0)) { 2712 BIO_printf(bio, " Error\n"); 2713 } else { 2714 BIO_printf(bio, " Keying material: "); 2715 for (i = 0; i < keymatexportlen; i++) 2716 BIO_printf(bio, "%02X", exportedkeymat[i]); 2717 BIO_printf(bio, "\n"); 2718 } 2719 OPENSSL_free(exportedkeymat); 2720 } 2721 BIO_printf(bio, "---\n"); 2722 X509_free(peer); 2723 /* flush, or debugging output gets mixed with http response */ 2724 (void)BIO_flush(bio); 2725 } 2726 2727 # ifndef OPENSSL_NO_OCSP 2728 static int ocsp_resp_cb(SSL *s, void *arg) 2729 { 2730 const unsigned char *p; 2731 int len; 2732 OCSP_RESPONSE *rsp; 2733 len = SSL_get_tlsext_status_ocsp_resp(s, &p); 2734 BIO_puts(arg, "OCSP response: "); 2735 if (!p) { 2736 BIO_puts(arg, "no response sent\n"); 2737 return 1; 2738 } 2739 rsp = d2i_OCSP_RESPONSE(NULL, &p, len); 2740 if (!rsp) { 2741 BIO_puts(arg, "response parse error\n"); 2742 BIO_dump_indent(arg, (char *)p, len, 4); 2743 return 0; 2744 } 2745 BIO_puts(arg, "\n======================================\n"); 2746 OCSP_RESPONSE_print(arg, rsp, 0); 2747 BIO_puts(arg, "======================================\n"); 2748 OCSP_RESPONSE_free(rsp); 2749 return 1; 2750 } 2751 # endif 2752 2753 #endif /* OPENSSL_NO_SOCK */ 2754
Indexes created Sat Feb 28 05:31:39 UTC 2026