1 /* $OpenBSD: ssh.c,v 1.462 2017/08/12 06:46:01 djm Exp $ */ 2 /* 3 * Author: Tatu Ylonen <ylo@cs.hut.fi> 4 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland 5 * All rights reserved 6 * Ssh client program. This program can be used to log into a remote machine. 7 * The software supports strong authentication, encryption, and forwarding 8 * of X11, TCP/IP, and authentication connections. 9 * 10 * As far as I am concerned, the code I have written for this software 11 * can be used freely for any purpose. Any derived versions of this 12 * software must be clearly marked as such, and if the derived work is 13 * incompatible with the protocol description in the RFC file, it must be 14 * called by a name other than "ssh" or "Secure Shell". 15 * 16 * Copyright (c) 1999 Niels Provos. All rights reserved. 17 * Copyright (c) 2000, 2001, 2002, 2003 Markus Friedl. All rights reserved. 18 * 19 * Modified to work with SSL by Niels Provos <provos@citi.umich.edu> 20 * in Canada (German citizen). 21 * 22 * Redistribution and use in source and binary forms, with or without 23 * modification, are permitted provided that the following conditions 24 * are met: 25 * 1. Redistributions of source code must retain the above copyright 26 * notice, this list of conditions and the following disclaimer. 27 * 2. Redistributions in binary form must reproduce the above copyright 28 * notice, this list of conditions and the following disclaimer in the 29 * documentation and/or other materials provided with the distribution. 30 * 31 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 32 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 33 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 34 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 35 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 36 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 37 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 38 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 39 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 40 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 41 */ 42 43 #include <sys/types.h> 44 #include <sys/ioctl.h> 45 #include <sys/queue.h> 46 #include <sys/resource.h> 47 #include <sys/socket.h> 48 #include <sys/stat.h> 49 #include <sys/time.h> 50 #include <sys/wait.h> 51 52 #include <ctype.h> 53 #include <errno.h> 54 #include <fcntl.h> 55 #include <netdb.h> 56 #include <paths.h> 57 #include <pwd.h> 58 #include <signal.h> 59 #include <stddef.h> 60 #include <stdio.h> 61 #include <stdlib.h> 62 #include <string.h> 63 #include <unistd.h> 64 #include <limits.h> 65 #include <locale.h> 66 67 #ifdef WITH_OPENSSL 68 #include <openssl/evp.h> 69 #include <openssl/err.h> 70 #endif 71 72 #include "xmalloc.h" 73 #include "ssh.h" 74 #include "ssh2.h" 75 #include "canohost.h" 76 #include "compat.h" 77 #include "cipher.h" 78 #include "digest.h" 79 #include "packet.h" 80 #include "buffer.h" 81 #include "channels.h" 82 #include "key.h" 83 #include "authfd.h" 84 #include "authfile.h" 85 #include "pathnames.h" 86 #include "dispatch.h" 87 #include "clientloop.h" 88 #include "log.h" 89 #include "misc.h" 90 #include "readconf.h" 91 #include "sshconnect.h" 92 #include "kex.h" 93 #include "mac.h" 94 #include "sshpty.h" 95 #include "match.h" 96 #include "msg.h" 97 #include "uidswap.h" 98 #include "version.h" 99 #include "ssherr.h" 100 #include "myproposal.h" 101 102 #ifdef ENABLE_PKCS11 103 #include "ssh-pkcs11.h" 104 #endif 105 106 extern char *__progname; 107 108 /* Flag indicating whether debug mode is on. May be set on the command line. */ 109 int debug_flag = 0; 110 111 /* Flag indicating whether a tty should be requested */ 112 int tty_flag = 0; 113 114 /* don't exec a shell */ 115 int no_shell_flag = 0; 116 117 /* 118 * Flag indicating that nothing should be read from stdin. This can be set 119 * on the command line. 120 */ 121 int stdin_null_flag = 0; 122 123 /* 124 * Flag indicating that the current process should be backgrounded and 125 * a new slave launched in the foreground for ControlPersist. 126 */ 127 int need_controlpersist_detach = 0; 128 129 /* Copies of flags for ControlPersist foreground slave */ 130 int ostdin_null_flag, ono_shell_flag, otty_flag, orequest_tty; 131 132 /* 133 * Flag indicating that ssh should fork after authentication. This is useful 134 * so that the passphrase can be entered manually, and then ssh goes to the 135 * background. 136 */ 137 int fork_after_authentication_flag = 0; 138 139 /* 140 * General data structure for command line options and options configurable 141 * in configuration files. See readconf.h. 142 */ 143 Options options; 144 145 /* optional user configfile */ 146 char *config = NULL; 147 148 /* 149 * Name of the host we are connecting to. This is the name given on the 150 * command line, or the HostName specified for the user-supplied name in a 151 * configuration file. 152 */ 153 char *host; 154 155 /* socket address the host resolves to */ 156 struct sockaddr_storage hostaddr; 157 158 /* Private host keys. */ 159 Sensitive sensitive_data; 160 161 /* Original real UID. */ 162 uid_t original_real_uid; 163 uid_t original_effective_uid; 164 165 /* command to be executed */ 166 Buffer command; 167 168 /* Should we execute a command or invoke a subsystem? */ 169 int subsystem_flag = 0; 170 171 /* # of replies received for global requests */ 172 static int remote_forward_confirms_received = 0; 173 174 /* mux.c */ 175 extern int muxserver_sock; 176 extern u_int muxclient_command; 177 178 /* Prints a help message to the user. This function never returns. */ 179 180 static void 181 usage(void) 182 { 183 fprintf(stderr, 184 "usage: ssh [-46AaCfGgKkMNnqsTtVvXxYy] [-b bind_address] [-c cipher_spec]\n" 185 " [-D [bind_address:]port] [-E log_file] [-e escape_char]\n" 186 " [-F configfile] [-I pkcs11] [-i identity_file]\n" 187 " [-J [user@]host[:port]] [-L address] [-l login_name] [-m mac_spec]\n" 188 " [-O ctl_cmd] [-o option] [-p port] [-Q query_option] [-R address]\n" 189 " [-S ctl_path] [-W host:port] [-w local_tun[:remote_tun]]\n" 190 " [user@]hostname [command]\n" 191 ); 192 exit(255); 193 } 194 195 static int ssh_session2(void); 196 static void load_public_identity_files(void); 197 static void main_sigchld_handler(int); 198 199 /* ~/ expand a list of paths. NB. assumes path[n] is heap-allocated. */ 200 static void 201 tilde_expand_paths(char **paths, u_int num_paths) 202 { 203 u_int i; 204 char *cp; 205 206 for (i = 0; i < num_paths; i++) { 207 cp = tilde_expand_filename(paths[i], original_real_uid); 208 free(paths[i]); 209 paths[i] = cp; 210 } 211 } 212 213 /* 214 * Attempt to resolve a host name / port to a set of addresses and 215 * optionally return any CNAMEs encountered along the way. 216 * Returns NULL on failure. 217 * NB. this function must operate with a options having undefined members. 218 */ 219 static struct addrinfo * 220 resolve_host(const char *name, int port, int logerr, char *cname, size_t clen) 221 { 222 char strport[NI_MAXSERV]; 223 struct addrinfo hints, *res; 224 int gaierr, loglevel = SYSLOG_LEVEL_DEBUG1; 225 226 if (port <= 0) 227 port = default_ssh_port(); 228 229 snprintf(strport, sizeof strport, "%d", port); 230 memset(&hints, 0, sizeof(hints)); 231 hints.ai_family = options.address_family == -1 ? 232 AF_UNSPEC : options.address_family; 233 hints.ai_socktype = SOCK_STREAM; 234 if (cname != NULL) 235 hints.ai_flags = AI_CANONNAME; 236 if ((gaierr = getaddrinfo(name, strport, &hints, &res)) != 0) { 237 if (logerr || (gaierr != EAI_NONAME && gaierr != EAI_NODATA)) 238 loglevel = SYSLOG_LEVEL_ERROR; 239 do_log2(loglevel, "%s: Could not resolve hostname %.100s: %s", 240 __progname, name, ssh_gai_strerror(gaierr)); 241 return NULL; 242 } 243 if (cname != NULL && res->ai_canonname != NULL) { 244 if (strlcpy(cname, res->ai_canonname, clen) >= clen) { 245 error("%s: host \"%s\" cname \"%s\" too long (max %lu)", 246 __func__, name, res->ai_canonname, (u_long)clen); 247 if (clen > 0) 248 *cname = '\0'; 249 } 250 } 251 return res; 252 } 253 254 /* 255 * Attempt to resolve a numeric host address / port to a single address. 256 * Returns a canonical address string. 257 * Returns NULL on failure. 258 * NB. this function must operate with a options having undefined members. 259 */ 260 static struct addrinfo * 261 resolve_addr(const char *name, int port, char *caddr, size_t clen) 262 { 263 char addr[NI_MAXHOST], strport[NI_MAXSERV]; 264 struct addrinfo hints, *res; 265 int gaierr; 266 267 if (port <= 0) 268 port = default_ssh_port(); 269 snprintf(strport, sizeof strport, "%u", port); 270 memset(&hints, 0, sizeof(hints)); 271 hints.ai_family = options.address_family == -1 ? 272 AF_UNSPEC : options.address_family; 273 hints.ai_socktype = SOCK_STREAM; 274 hints.ai_flags = AI_NUMERICHOST|AI_NUMERICSERV; 275 if ((gaierr = getaddrinfo(name, strport, &hints, &res)) != 0) { 276 debug2("%s: could not resolve name %.100s as address: %s", 277 __func__, name, ssh_gai_strerror(gaierr)); 278 return NULL; 279 } 280 if (res == NULL) { 281 debug("%s: getaddrinfo %.100s returned no addresses", 282 __func__, name); 283 return NULL; 284 } 285 if (res->ai_next != NULL) { 286 debug("%s: getaddrinfo %.100s returned multiple addresses", 287 __func__, name); 288 goto fail; 289 } 290 if ((gaierr = getnameinfo(res->ai_addr, res->ai_addrlen, 291 addr, sizeof(addr), NULL, 0, NI_NUMERICHOST)) != 0) { 292 debug("%s: Could not format address for name %.100s: %s", 293 __func__, name, ssh_gai_strerror(gaierr)); 294 goto fail; 295 } 296 if (strlcpy(caddr, addr, clen) >= clen) { 297 error("%s: host \"%s\" addr \"%s\" too long (max %lu)", 298 __func__, name, addr, (u_long)clen); 299 if (clen > 0) 300 *caddr = '\0'; 301 fail: 302 freeaddrinfo(res); 303 return NULL; 304 } 305 return res; 306 } 307 308 /* 309 * Check whether the cname is a permitted replacement for the hostname 310 * and perform the replacement if it is. 311 * NB. this function must operate with a options having undefined members. 312 */ 313 static int 314 check_follow_cname(int direct, char **namep, const char *cname) 315 { 316 int i; 317 struct allowed_cname *rule; 318 319 if (*cname == '\0' || options.num_permitted_cnames == 0 || 320 strcmp(*namep, cname) == 0) 321 return 0; 322 if (options.canonicalize_hostname == SSH_CANONICALISE_NO) 323 return 0; 324 /* 325 * Don't attempt to canonicalize names that will be interpreted by 326 * a proxy or jump host unless the user specifically requests so. 327 */ 328 if (!direct && 329 options.canonicalize_hostname != SSH_CANONICALISE_ALWAYS) 330 return 0; 331 debug3("%s: check \"%s\" CNAME \"%s\"", __func__, *namep, cname); 332 for (i = 0; i < options.num_permitted_cnames; i++) { 333 rule = options.permitted_cnames + i; 334 if (match_pattern_list(*namep, rule->source_list, 1) != 1 || 335 match_pattern_list(cname, rule->target_list, 1) != 1) 336 continue; 337 verbose("Canonicalized DNS aliased hostname " 338 "\"%s\" => \"%s\"", *namep, cname); 339 free(*namep); 340 *namep = xstrdup(cname); 341 return 1; 342 } 343 return 0; 344 } 345 346 /* 347 * Attempt to resolve the supplied hostname after applying the user's 348 * canonicalization rules. Returns the address list for the host or NULL 349 * if no name was found after canonicalization. 350 * NB. this function must operate with a options having undefined members. 351 */ 352 static struct addrinfo * 353 resolve_canonicalize(char **hostp, int port) 354 { 355 int i, direct, ndots; 356 char *cp, *fullhost, newname[NI_MAXHOST]; 357 struct addrinfo *addrs; 358 359 if (options.canonicalize_hostname == SSH_CANONICALISE_NO) 360 return NULL; 361 362 /* 363 * Don't attempt to canonicalize names that will be interpreted by 364 * a proxy unless the user specifically requests so. 365 */ 366 direct = option_clear_or_none(options.proxy_command) && 367 options.jump_host == NULL; 368 if (!direct && 369 options.canonicalize_hostname != SSH_CANONICALISE_ALWAYS) 370 return NULL; 371 372 /* Try numeric hostnames first */ 373 if ((addrs = resolve_addr(*hostp, port, 374 newname, sizeof(newname))) != NULL) { 375 debug2("%s: hostname %.100s is address", __func__, *hostp); 376 if (strcasecmp(*hostp, newname) != 0) { 377 debug2("%s: canonicalised address \"%s\" => \"%s\"", 378 __func__, *hostp, newname); 379 free(*hostp); 380 *hostp = xstrdup(newname); 381 } 382 return addrs; 383 } 384 385 /* If domain name is anchored, then resolve it now */ 386 if ((*hostp)[strlen(*hostp) - 1] == '.') { 387 debug3("%s: name is fully qualified", __func__); 388 fullhost = xstrdup(*hostp); 389 if ((addrs = resolve_host(fullhost, port, 0, 390 newname, sizeof(newname))) != NULL) 391 goto found; 392 free(fullhost); 393 goto notfound; 394 } 395 396 /* Don't apply canonicalization to sufficiently-qualified hostnames */ 397 ndots = 0; 398 for (cp = *hostp; *cp != '\0'; cp++) { 399 if (*cp == '.') 400 ndots++; 401 } 402 if (ndots > options.canonicalize_max_dots) { 403 debug3("%s: not canonicalizing hostname \"%s\" (max dots %d)", 404 __func__, *hostp, options.canonicalize_max_dots); 405 return NULL; 406 } 407 /* Attempt each supplied suffix */ 408 for (i = 0; i < options.num_canonical_domains; i++) { 409 *newname = '\0'; 410 xasprintf(&fullhost, "%s.%s.", *hostp, 411 options.canonical_domains[i]); 412 debug3("%s: attempting \"%s\" => \"%s\"", __func__, 413 *hostp, fullhost); 414 if ((addrs = resolve_host(fullhost, port, 0, 415 newname, sizeof(newname))) == NULL) { 416 free(fullhost); 417 continue; 418 } 419 found: 420 /* Remove trailing '.' */ 421 fullhost[strlen(fullhost) - 1] = '\0'; 422 /* Follow CNAME if requested */ 423 if (!check_follow_cname(direct, &fullhost, newname)) { 424 debug("Canonicalized hostname \"%s\" => \"%s\"", 425 *hostp, fullhost); 426 } 427 free(*hostp); 428 *hostp = fullhost; 429 return addrs; 430 } 431 notfound: 432 if (!options.canonicalize_fallback_local) 433 fatal("%s: Could not resolve host \"%s\"", __progname, *hostp); 434 debug2("%s: host %s not found in any suffix", __func__, *hostp); 435 return NULL; 436 } 437 438 /* 439 * Read per-user configuration file. Ignore the system wide config 440 * file if the user specifies a config file on the command line. 441 */ 442 static void 443 process_config_files(const char *host_arg, struct passwd *pw, int post_canon) 444 { 445 char buf[PATH_MAX]; 446 int r; 447 448 if (config != NULL) { 449 if (strcasecmp(config, "none") != 0 && 450 !read_config_file(config, pw, host, host_arg, &options, 451 SSHCONF_USERCONF | (post_canon ? SSHCONF_POSTCANON : 0))) 452 fatal("Can't open user config file %.100s: " 453 "%.100s", config, strerror(errno)); 454 } else { 455 r = snprintf(buf, sizeof buf, "%s/%s", pw->pw_dir, 456 _PATH_SSH_USER_CONFFILE); 457 if (r > 0 && (size_t)r < sizeof(buf)) 458 (void)read_config_file(buf, pw, host, host_arg, 459 &options, SSHCONF_CHECKPERM | SSHCONF_USERCONF | 460 (post_canon ? SSHCONF_POSTCANON : 0)); 461 462 /* Read systemwide configuration file after user config. */ 463 (void)read_config_file(_PATH_HOST_CONFIG_FILE, pw, 464 host, host_arg, &options, 465 post_canon ? SSHCONF_POSTCANON : 0); 466 } 467 } 468 469 /* Rewrite the port number in an addrinfo list of addresses */ 470 static void 471 set_addrinfo_port(struct addrinfo *addrs, int port) 472 { 473 struct addrinfo *addr; 474 475 for (addr = addrs; addr != NULL; addr = addr->ai_next) { 476 switch (addr->ai_family) { 477 case AF_INET: 478 ((struct sockaddr_in *)addr->ai_addr)-> 479 sin_port = htons(port); 480 break; 481 case AF_INET6: 482 ((struct sockaddr_in6 *)addr->ai_addr)-> 483 sin6_port = htons(port); 484 break; 485 } 486 } 487 } 488 489 /* 490 * Main program for the ssh client. 491 */ 492 int 493 main(int ac, char **av) 494 { 495 struct ssh *ssh = NULL; 496 int i, r, opt, exit_status, use_syslog, direct, timeout_ms; 497 int config_test = 0, opt_terminated = 0; 498 char *p, *cp, *line, *argv0, buf[PATH_MAX], *host_arg, *logfile; 499 char thishost[NI_MAXHOST], shorthost[NI_MAXHOST], portstr[NI_MAXSERV]; 500 char cname[NI_MAXHOST], uidstr[32], *conn_hash_hex; 501 struct stat st; 502 struct passwd *pw; 503 extern int optind, optreset; 504 extern char *optarg; 505 struct Forward fwd; 506 struct addrinfo *addrs = NULL; 507 struct ssh_digest_ctx *md; 508 u_char conn_hash[SSH_DIGEST_MAX_LENGTH]; 509 510 ssh_malloc_init(); /* must be called before any mallocs */ 511 /* Ensure that fds 0, 1 and 2 are open or directed to /dev/null */ 512 sanitise_stdfd(); 513 514 /* 515 * Discard other fds that are hanging around. These can cause problem 516 * with backgrounded ssh processes started by ControlPersist. 517 */ 518 closefrom(STDERR_FILENO + 1); 519 520 /* 521 * Save the original real uid. It will be needed later (uid-swapping 522 * may clobber the real uid). 523 */ 524 original_real_uid = getuid(); 525 original_effective_uid = geteuid(); 526 527 /* 528 * Use uid-swapping to give up root privileges for the duration of 529 * option processing. We will re-instantiate the rights when we are 530 * ready to create the privileged port, and will permanently drop 531 * them when the port has been created (actually, when the connection 532 * has been made, as we may need to create the port several times). 533 */ 534 PRIV_END; 535 536 /* If we are installed setuid root be careful to not drop core. */ 537 if (original_real_uid != original_effective_uid) { 538 struct rlimit rlim; 539 rlim.rlim_cur = rlim.rlim_max = 0; 540 if (setrlimit(RLIMIT_CORE, &rlim) < 0) 541 fatal("setrlimit failed: %.100s", strerror(errno)); 542 } 543 /* Get user data. */ 544 pw = getpwuid(original_real_uid); 545 if (!pw) { 546 logit("No user exists for uid %lu", (u_long)original_real_uid); 547 exit(255); 548 } 549 /* Take a copy of the returned structure. */ 550 pw = pwcopy(pw); 551 552 /* 553 * Set our umask to something reasonable, as some files are created 554 * with the default umask. This will make them world-readable but 555 * writable only by the owner, which is ok for all files for which we 556 * don't set the modes explicitly. 557 */ 558 umask(022); 559 560 setlocale(LC_CTYPE, ""); 561 562 /* 563 * Initialize option structure to indicate that no values have been 564 * set. 565 */ 566 initialize_options(&options); 567 568 /* Parse command-line arguments. */ 569 host = NULL; 570 use_syslog = 0; 571 logfile = NULL; 572 argv0 = av[0]; 573 574 again: 575 while ((opt = getopt(ac, av, "1246ab:c:e:fgi:kl:m:no:p:qstvx" 576 "ACD:E:F:GI:J:KL:MNO:PQ:R:S:TVw:W:XYy")) != -1) { 577 switch (opt) { 578 case '1': 579 fatal("SSH protocol v.1 is no longer supported"); 580 break; 581 case '2': 582 /* Ignored */ 583 break; 584 case '4': 585 options.address_family = AF_INET; 586 break; 587 case '6': 588 options.address_family = AF_INET6; 589 break; 590 case 'n': 591 stdin_null_flag = 1; 592 break; 593 case 'f': 594 fork_after_authentication_flag = 1; 595 stdin_null_flag = 1; 596 break; 597 case 'x': 598 options.forward_x11 = 0; 599 break; 600 case 'X': 601 options.forward_x11 = 1; 602 break; 603 case 'y': 604 use_syslog = 1; 605 break; 606 case 'E': 607 logfile = optarg; 608 break; 609 case 'G': 610 config_test = 1; 611 break; 612 case 'Y': 613 options.forward_x11 = 1; 614 options.forward_x11_trusted = 1; 615 break; 616 case 'g': 617 options.fwd_opts.gateway_ports = 1; 618 break; 619 case 'O': 620 if (options.stdio_forward_host != NULL) 621 fatal("Cannot specify multiplexing " 622 "command with -W"); 623 else if (muxclient_command != 0) 624 fatal("Multiplexing command already specified"); 625 if (strcmp(optarg, "check") == 0) 626 muxclient_command = SSHMUX_COMMAND_ALIVE_CHECK; 627 else if (strcmp(optarg, "forward") == 0) 628 muxclient_command = SSHMUX_COMMAND_FORWARD; 629 else if (strcmp(optarg, "exit") == 0) 630 muxclient_command = SSHMUX_COMMAND_TERMINATE; 631 else if (strcmp(optarg, "stop") == 0) 632 muxclient_command = SSHMUX_COMMAND_STOP; 633 else if (strcmp(optarg, "cancel") == 0) 634 muxclient_command = SSHMUX_COMMAND_CANCEL_FWD; 635 else if (strcmp(optarg, "proxy") == 0) 636 muxclient_command = SSHMUX_COMMAND_PROXY; 637 else 638 fatal("Invalid multiplex command."); 639 break; 640 case 'P': /* deprecated */ 641 options.use_privileged_port = 0; 642 break; 643 case 'Q': 644 cp = NULL; 645 if (strcmp(optarg, "cipher") == 0) 646 cp = cipher_alg_list('\n', 0); 647 else if (strcmp(optarg, "cipher-auth") == 0) 648 cp = cipher_alg_list('\n', 1); 649 else if (strcmp(optarg, "mac") == 0) 650 cp = mac_alg_list('\n'); 651 else if (strcmp(optarg, "kex") == 0) 652 cp = kex_alg_list('\n'); 653 else if (strcmp(optarg, "key") == 0) 654 cp = sshkey_alg_list(0, 0, 0, '\n'); 655 else if (strcmp(optarg, "key-cert") == 0) 656 cp = sshkey_alg_list(1, 0, 0, '\n'); 657 else if (strcmp(optarg, "key-plain") == 0) 658 cp = sshkey_alg_list(0, 1, 0, '\n'); 659 else if (strcmp(optarg, "protocol-version") == 0) { 660 cp = xstrdup("2"); 661 } 662 if (cp == NULL) 663 fatal("Unsupported query \"%s\"", optarg); 664 printf("%s\n", cp); 665 free(cp); 666 exit(0); 667 break; 668 case 'a': 669 options.forward_agent = 0; 670 break; 671 case 'A': 672 options.forward_agent = 1; 673 break; 674 case 'k': 675 options.gss_deleg_creds = 0; 676 break; 677 case 'K': 678 options.gss_authentication = 1; 679 options.gss_deleg_creds = 1; 680 break; 681 case 'i': 682 p = tilde_expand_filename(optarg, original_real_uid); 683 if (stat(p, &st) < 0) 684 fprintf(stderr, "Warning: Identity file %s " 685 "not accessible: %s.\n", p, 686 strerror(errno)); 687 else 688 add_identity_file(&options, NULL, p, 1); 689 free(p); 690 break; 691 case 'I': 692 #ifdef ENABLE_PKCS11 693 free(options.pkcs11_provider); 694 options.pkcs11_provider = xstrdup(optarg); 695 #else 696 fprintf(stderr, "no support for PKCS#11.\n"); 697 #endif 698 break; 699 case 'J': 700 if (options.jump_host != NULL) 701 fatal("Only a single -J option permitted"); 702 if (options.proxy_command != NULL) 703 fatal("Cannot specify -J with ProxyCommand"); 704 if (parse_jump(optarg, &options, 1) == -1) 705 fatal("Invalid -J argument"); 706 options.proxy_command = xstrdup("none"); 707 break; 708 case 't': 709 if (options.request_tty == REQUEST_TTY_YES) 710 options.request_tty = REQUEST_TTY_FORCE; 711 else 712 options.request_tty = REQUEST_TTY_YES; 713 break; 714 case 'v': 715 if (debug_flag == 0) { 716 debug_flag = 1; 717 options.log_level = SYSLOG_LEVEL_DEBUG1; 718 } else { 719 if (options.log_level < SYSLOG_LEVEL_DEBUG3) { 720 debug_flag++; 721 options.log_level++; 722 } 723 } 724 break; 725 case 'V': 726 fprintf(stderr, "%s, %s\n", 727 SSH_VERSION, 728 #ifdef WITH_OPENSSL 729 SSLeay_version(SSLEAY_VERSION) 730 #else 731 "without OpenSSL" 732 #endif 733 ); 734 if (opt == 'V') 735 exit(0); 736 break; 737 case 'w': 738 if (options.tun_open == -1) 739 options.tun_open = SSH_TUNMODE_DEFAULT; 740 options.tun_local = a2tun(optarg, &options.tun_remote); 741 if (options.tun_local == SSH_TUNID_ERR) { 742 fprintf(stderr, 743 "Bad tun device '%s'\n", optarg); 744 exit(255); 745 } 746 break; 747 case 'W': 748 if (options.stdio_forward_host != NULL) 749 fatal("stdio forward already specified"); 750 if (muxclient_command != 0) 751 fatal("Cannot specify stdio forward with -O"); 752 if (parse_forward(&fwd, optarg, 1, 0)) { 753 options.stdio_forward_host = fwd.listen_host; 754 options.stdio_forward_port = fwd.listen_port; 755 free(fwd.connect_host); 756 } else { 757 fprintf(stderr, 758 "Bad stdio forwarding specification '%s'\n", 759 optarg); 760 exit(255); 761 } 762 options.request_tty = REQUEST_TTY_NO; 763 no_shell_flag = 1; 764 break; 765 case 'q': 766 options.log_level = SYSLOG_LEVEL_QUIET; 767 break; 768 case 'e': 769 if (optarg[0] == '^' && optarg[2] == 0 && 770 (u_char) optarg[1] >= 64 && 771 (u_char) optarg[1] < 128) 772 options.escape_char = (u_char) optarg[1] & 31; 773 else if (strlen(optarg) == 1) 774 options.escape_char = (u_char) optarg[0]; 775 else if (strcmp(optarg, "none") == 0) 776 options.escape_char = SSH_ESCAPECHAR_NONE; 777 else { 778 fprintf(stderr, "Bad escape character '%s'.\n", 779 optarg); 780 exit(255); 781 } 782 break; 783 case 'c': 784 if (!ciphers_valid(*optarg == '+' ? 785 optarg + 1 : optarg)) { 786 fprintf(stderr, "Unknown cipher type '%s'\n", 787 optarg); 788 exit(255); 789 } 790 free(options.ciphers); 791 options.ciphers = xstrdup(optarg); 792 break; 793 case 'm': 794 if (mac_valid(optarg)) { 795 free(options.macs); 796 options.macs = xstrdup(optarg); 797 } else { 798 fprintf(stderr, "Unknown mac type '%s'\n", 799 optarg); 800 exit(255); 801 } 802 break; 803 case 'M': 804 if (options.control_master == SSHCTL_MASTER_YES) 805 options.control_master = SSHCTL_MASTER_ASK; 806 else 807 options.control_master = SSHCTL_MASTER_YES; 808 break; 809 case 'p': 810 options.port = a2port(optarg); 811 if (options.port <= 0) { 812 fprintf(stderr, "Bad port '%s'\n", optarg); 813 exit(255); 814 } 815 break; 816 case 'l': 817 options.user = optarg; 818 break; 819 820 case 'L': 821 if (parse_forward(&fwd, optarg, 0, 0)) 822 add_local_forward(&options, &fwd); 823 else { 824 fprintf(stderr, 825 "Bad local forwarding specification '%s'\n", 826 optarg); 827 exit(255); 828 } 829 break; 830 831 case 'R': 832 if (parse_forward(&fwd, optarg, 0, 1)) { 833 add_remote_forward(&options, &fwd); 834 } else { 835 fprintf(stderr, 836 "Bad remote forwarding specification " 837 "'%s'\n", optarg); 838 exit(255); 839 } 840 break; 841 842 case 'D': 843 if (parse_forward(&fwd, optarg, 1, 0)) { 844 add_local_forward(&options, &fwd); 845 } else { 846 fprintf(stderr, 847 "Bad dynamic forwarding specification " 848 "'%s'\n", optarg); 849 exit(255); 850 } 851 break; 852 853 case 'C': 854 options.compression = 1; 855 break; 856 case 'N': 857 no_shell_flag = 1; 858 options.request_tty = REQUEST_TTY_NO; 859 break; 860 case 'T': 861 options.request_tty = REQUEST_TTY_NO; 862 break; 863 case 'o': 864 line = xstrdup(optarg); 865 if (process_config_line(&options, pw, 866 host ? host : "", host ? host : "", line, 867 "command-line", 0, NULL, SSHCONF_USERCONF) != 0) 868 exit(255); 869 free(line); 870 break; 871 case 's': 872 subsystem_flag = 1; 873 break; 874 case 'S': 875 free(options.control_path); 876 options.control_path = xstrdup(optarg); 877 break; 878 case 'b': 879 options.bind_address = optarg; 880 break; 881 case 'F': 882 config = optarg; 883 break; 884 default: 885 usage(); 886 } 887 } 888 889 if (optind > 1 && strcmp(av[optind - 1], "--") == 0) 890 opt_terminated = 1; 891 892 ac -= optind; 893 av += optind; 894 895 if (ac > 0 && !host) { 896 if (strrchr(*av, '@')) { 897 p = xstrdup(*av); 898 cp = strrchr(p, '@'); 899 if (cp == NULL || cp == p) 900 usage(); 901 options.user = p; 902 *cp = '\0'; 903 host = xstrdup(++cp); 904 } else 905 host = xstrdup(*av); 906 if (ac > 1 && !opt_terminated) { 907 optind = optreset = 1; 908 goto again; 909 } 910 ac--, av++; 911 } 912 913 /* Check that we got a host name. */ 914 if (!host) 915 usage(); 916 917 host_arg = xstrdup(host); 918 919 #ifdef WITH_OPENSSL 920 OpenSSL_add_all_algorithms(); 921 ERR_load_crypto_strings(); 922 #endif 923 924 /* Initialize the command to execute on remote host. */ 925 buffer_init(&command); 926 927 /* 928 * Save the command to execute on the remote host in a buffer. There 929 * is no limit on the length of the command, except by the maximum 930 * packet size. Also sets the tty flag if there is no command. 931 */ 932 if (!ac) { 933 /* No command specified - execute shell on a tty. */ 934 if (subsystem_flag) { 935 fprintf(stderr, 936 "You must specify a subsystem to invoke.\n"); 937 usage(); 938 } 939 } else { 940 /* A command has been specified. Store it into the buffer. */ 941 for (i = 0; i < ac; i++) { 942 if (i) 943 buffer_append(&command, " ", 1); 944 buffer_append(&command, av[i], strlen(av[i])); 945 } 946 } 947 948 /* 949 * Initialize "log" output. Since we are the client all output 950 * goes to stderr unless otherwise specified by -y or -E. 951 */ 952 if (use_syslog && logfile != NULL) 953 fatal("Can't specify both -y and -E"); 954 if (logfile != NULL) 955 log_redirect_stderr_to(logfile); 956 log_init(argv0, 957 options.log_level == SYSLOG_LEVEL_NOT_SET ? 958 SYSLOG_LEVEL_INFO : options.log_level, 959 options.log_facility == SYSLOG_FACILITY_NOT_SET ? 960 SYSLOG_FACILITY_USER : options.log_facility, 961 !use_syslog); 962 963 if (debug_flag) 964 logit("%s, %s", SSH_VERSION, 965 #ifdef WITH_OPENSSL 966 SSLeay_version(SSLEAY_VERSION) 967 #else 968 "without OpenSSL" 969 #endif 970 ); 971 972 /* Parse the configuration files */ 973 process_config_files(host_arg, pw, 0); 974 975 /* Hostname canonicalisation needs a few options filled. */ 976 fill_default_options_for_canonicalization(&options); 977 978 /* If the user has replaced the hostname then take it into use now */ 979 if (options.hostname != NULL) { 980 /* NB. Please keep in sync with readconf.c:match_cfg_line() */ 981 cp = percent_expand(options.hostname, 982 "h", host, (char *)NULL); 983 free(host); 984 host = cp; 985 free(options.hostname); 986 options.hostname = xstrdup(host); 987 } 988 989 /* If canonicalization requested then try to apply it */ 990 lowercase(host); 991 if (options.canonicalize_hostname != SSH_CANONICALISE_NO) 992 addrs = resolve_canonicalize(&host, options.port); 993 994 /* 995 * If CanonicalizePermittedCNAMEs have been specified but 996 * other canonicalization did not happen (by not being requested 997 * or by failing with fallback) then the hostname may still be changed 998 * as a result of CNAME following. 999 * 1000 * Try to resolve the bare hostname name using the system resolver's 1001 * usual search rules and then apply the CNAME follow rules. 1002 * 1003 * Skip the lookup if a ProxyCommand is being used unless the user 1004 * has specifically requested canonicalisation for this case via 1005 * CanonicalizeHostname=always 1006 */ 1007 direct = option_clear_or_none(options.proxy_command) && 1008 options.jump_host == NULL; 1009 if (addrs == NULL && options.num_permitted_cnames != 0 && (direct || 1010 options.canonicalize_hostname == SSH_CANONICALISE_ALWAYS)) { 1011 if ((addrs = resolve_host(host, options.port, 1012 option_clear_or_none(options.proxy_command), 1013 cname, sizeof(cname))) == NULL) { 1014 /* Don't fatal proxied host names not in the DNS */ 1015 if (option_clear_or_none(options.proxy_command)) 1016 cleanup_exit(255); /* logged in resolve_host */ 1017 } else 1018 check_follow_cname(direct, &host, cname); 1019 } 1020 1021 /* 1022 * If canonicalisation is enabled then re-parse the configuration 1023 * files as new stanzas may match. 1024 */ 1025 if (options.canonicalize_hostname != 0) { 1026 debug("Re-reading configuration after hostname " 1027 "canonicalisation"); 1028 free(options.hostname); 1029 options.hostname = xstrdup(host); 1030 process_config_files(host_arg, pw, 1); 1031 /* 1032 * Address resolution happens early with canonicalisation 1033 * enabled and the port number may have changed since, so 1034 * reset it in address list 1035 */ 1036 if (addrs != NULL && options.port > 0) 1037 set_addrinfo_port(addrs, options.port); 1038 } 1039 1040 /* Fill configuration defaults. */ 1041 fill_default_options(&options); 1042 1043 /* 1044 * If ProxyJump option specified, then construct a ProxyCommand now. 1045 */ 1046 if (options.jump_host != NULL) { 1047 char port_s[8]; 1048 1049 /* Consistency check */ 1050 if (options.proxy_command != NULL) 1051 fatal("inconsistent options: ProxyCommand+ProxyJump"); 1052 /* Never use FD passing for ProxyJump */ 1053 options.proxy_use_fdpass = 0; 1054 snprintf(port_s, sizeof(port_s), "%d", options.jump_port); 1055 xasprintf(&options.proxy_command, 1056 "ssh%s%s%s%s%s%s%s%s%s%.*s -W '[%%h]:%%p' %s", 1057 /* Optional "-l user" argument if jump_user set */ 1058 options.jump_user == NULL ? "" : " -l ", 1059 options.jump_user == NULL ? "" : options.jump_user, 1060 /* Optional "-p port" argument if jump_port set */ 1061 options.jump_port <= 0 ? "" : " -p ", 1062 options.jump_port <= 0 ? "" : port_s, 1063 /* Optional additional jump hosts ",..." */ 1064 options.jump_extra == NULL ? "" : " -J ", 1065 options.jump_extra == NULL ? "" : options.jump_extra, 1066 /* Optional "-F" argumment if -F specified */ 1067 config == NULL ? "" : " -F ", 1068 config == NULL ? "" : config, 1069 /* Optional "-v" arguments if -v set */ 1070 debug_flag ? " -" : "", 1071 debug_flag, "vvv", 1072 /* Mandatory hostname */ 1073 options.jump_host); 1074 debug("Setting implicit ProxyCommand from ProxyJump: %s", 1075 options.proxy_command); 1076 } 1077 1078 if (options.port == 0) 1079 options.port = default_ssh_port(); 1080 channel_set_af(options.address_family); 1081 1082 /* Tidy and check options */ 1083 if (options.host_key_alias != NULL) 1084 lowercase(options.host_key_alias); 1085 if (options.proxy_command != NULL && 1086 strcmp(options.proxy_command, "-") == 0 && 1087 options.proxy_use_fdpass) 1088 fatal("ProxyCommand=- and ProxyUseFDPass are incompatible"); 1089 if (options.control_persist && 1090 options.update_hostkeys == SSH_UPDATE_HOSTKEYS_ASK) { 1091 debug("UpdateHostKeys=ask is incompatible with ControlPersist; " 1092 "disabling"); 1093 options.update_hostkeys = 0; 1094 } 1095 if (options.connection_attempts <= 0) 1096 fatal("Invalid number of ConnectionAttempts"); 1097 1098 if (original_effective_uid != 0) 1099 options.use_privileged_port = 0; 1100 1101 if (buffer_len(&command) != 0 && options.remote_command != NULL) 1102 fatal("Cannot execute command-line and remote command."); 1103 1104 /* Cannot fork to background if no command. */ 1105 if (fork_after_authentication_flag && buffer_len(&command) == 0 && 1106 options.remote_command == NULL && !no_shell_flag) 1107 fatal("Cannot fork into background without a command " 1108 "to execute."); 1109 1110 /* reinit */ 1111 log_init(argv0, options.log_level, options.log_facility, !use_syslog); 1112 1113 if (options.request_tty == REQUEST_TTY_YES || 1114 options.request_tty == REQUEST_TTY_FORCE) 1115 tty_flag = 1; 1116 1117 /* Allocate a tty by default if no command specified. */ 1118 if (buffer_len(&command) == 0 && options.remote_command == NULL) 1119 tty_flag = options.request_tty != REQUEST_TTY_NO; 1120 1121 /* Force no tty */ 1122 if (options.request_tty == REQUEST_TTY_NO || 1123 (muxclient_command && muxclient_command != SSHMUX_COMMAND_PROXY)) 1124 tty_flag = 0; 1125 /* Do not allocate a tty if stdin is not a tty. */ 1126 if ((!isatty(fileno(stdin)) || stdin_null_flag) && 1127 options.request_tty != REQUEST_TTY_FORCE) { 1128 if (tty_flag) 1129 logit("Pseudo-terminal will not be allocated because " 1130 "stdin is not a terminal."); 1131 tty_flag = 0; 1132 } 1133 1134 if (options.user == NULL) 1135 options.user = xstrdup(pw->pw_name); 1136 1137 if (gethostname(thishost, sizeof(thishost)) == -1) 1138 fatal("gethostname: %s", strerror(errno)); 1139 strlcpy(shorthost, thishost, sizeof(shorthost)); 1140 shorthost[strcspn(thishost, ".")] = '\0'; 1141 snprintf(portstr, sizeof(portstr), "%d", options.port); 1142 snprintf(uidstr, sizeof(uidstr), "%d", pw->pw_uid); 1143 1144 if ((md = ssh_digest_start(SSH_DIGEST_SHA1)) == NULL || 1145 ssh_digest_update(md, thishost, strlen(thishost)) < 0 || 1146 ssh_digest_update(md, host, strlen(host)) < 0 || 1147 ssh_digest_update(md, portstr, strlen(portstr)) < 0 || 1148 ssh_digest_update(md, options.user, strlen(options.user)) < 0 || 1149 ssh_digest_final(md, conn_hash, sizeof(conn_hash)) < 0) 1150 fatal("%s: mux digest failed", __func__); 1151 ssh_digest_free(md); 1152 conn_hash_hex = tohex(conn_hash, ssh_digest_bytes(SSH_DIGEST_SHA1)); 1153 1154 if (options.local_command != NULL) { 1155 debug3("expanding LocalCommand: %s", options.local_command); 1156 cp = options.local_command; 1157 options.local_command = percent_expand(cp, 1158 "C", conn_hash_hex, 1159 "L", shorthost, 1160 "d", pw->pw_dir, 1161 "h", host, 1162 "l", thishost, 1163 "n", host_arg, 1164 "p", portstr, 1165 "r", options.user, 1166 "u", pw->pw_name, 1167 (char *)NULL); 1168 debug3("expanded LocalCommand: %s", options.local_command); 1169 free(cp); 1170 } 1171 1172 if (options.remote_command != NULL) { 1173 debug3("expanding RemoteCommand: %s", options.remote_command); 1174 cp = options.remote_command; 1175 options.remote_command = percent_expand(cp, 1176 "C", conn_hash_hex, 1177 "L", shorthost, 1178 "d", pw->pw_dir, 1179 "h", host, 1180 "l", thishost, 1181 "n", host_arg, 1182 "p", portstr, 1183 "r", options.user, 1184 "u", pw->pw_name, 1185 (char *)NULL); 1186 debug3("expanded RemoteCommand: %s", options.remote_command); 1187 free(cp); 1188 buffer_append(&command, options.remote_command, 1189 strlen(options.remote_command)); 1190 1191 } 1192 1193 if (options.control_path != NULL) { 1194 cp = tilde_expand_filename(options.control_path, 1195 original_real_uid); 1196 free(options.control_path); 1197 options.control_path = percent_expand(cp, 1198 "C", conn_hash_hex, 1199 "L", shorthost, 1200 "h", host, 1201 "l", thishost, 1202 "n", host_arg, 1203 "p", portstr, 1204 "r", options.user, 1205 "u", pw->pw_name, 1206 "i", uidstr, 1207 (char *)NULL); 1208 free(cp); 1209 } 1210 free(conn_hash_hex); 1211 1212 if (config_test) { 1213 dump_client_config(&options, host); 1214 exit(0); 1215 } 1216 1217 if (muxclient_command != 0 && options.control_path == NULL) 1218 fatal("No ControlPath specified for \"-O\" command"); 1219 if (options.control_path != NULL) { 1220 int sock; 1221 if ((sock = muxclient(options.control_path)) >= 0) { 1222 packet_set_connection(sock, sock); 1223 ssh = active_state; /* XXX */ 1224 packet_set_mux(); 1225 goto skip_connect; 1226 } 1227 } 1228 1229 /* 1230 * If hostname canonicalisation was not enabled, then we may not 1231 * have yet resolved the hostname. Do so now. 1232 */ 1233 if (addrs == NULL && options.proxy_command == NULL) { 1234 debug2("resolving \"%s\" port %d", host, options.port); 1235 if ((addrs = resolve_host(host, options.port, 1, 1236 cname, sizeof(cname))) == NULL) 1237 cleanup_exit(255); /* resolve_host logs the error */ 1238 } 1239 1240 timeout_ms = options.connection_timeout * 1000; 1241 1242 /* Open a connection to the remote host. */ 1243 if (ssh_connect(host, addrs, &hostaddr, options.port, 1244 options.address_family, options.connection_attempts, 1245 &timeout_ms, options.tcp_keep_alive, 1246 options.use_privileged_port) != 0) 1247 exit(255); 1248 1249 if (addrs != NULL) 1250 freeaddrinfo(addrs); 1251 1252 packet_set_timeout(options.server_alive_interval, 1253 options.server_alive_count_max); 1254 1255 ssh = active_state; /* XXX */ 1256 1257 if (timeout_ms > 0) 1258 debug3("timeout: %d ms remain after connect", timeout_ms); 1259 1260 /* 1261 * If we successfully made the connection, load the host private key 1262 * in case we will need it later for combined rsa-rhosts 1263 * authentication. This must be done before releasing extra 1264 * privileges, because the file is only readable by root. 1265 * If we cannot access the private keys, load the public keys 1266 * instead and try to execute the ssh-keysign helper instead. 1267 */ 1268 sensitive_data.nkeys = 0; 1269 sensitive_data.keys = NULL; 1270 sensitive_data.external_keysign = 0; 1271 if (options.hostbased_authentication) { 1272 sensitive_data.nkeys = 9; 1273 sensitive_data.keys = xcalloc(sensitive_data.nkeys, 1274 sizeof(struct sshkey)); /* XXX */ 1275 1276 PRIV_START; 1277 sensitive_data.keys[1] = key_load_private_cert(KEY_ECDSA, 1278 _PATH_HOST_ECDSA_KEY_FILE, "", NULL); 1279 sensitive_data.keys[2] = key_load_private_cert(KEY_ED25519, 1280 _PATH_HOST_ED25519_KEY_FILE, "", NULL); 1281 sensitive_data.keys[3] = key_load_private_cert(KEY_RSA, 1282 _PATH_HOST_RSA_KEY_FILE, "", NULL); 1283 sensitive_data.keys[4] = key_load_private_cert(KEY_DSA, 1284 _PATH_HOST_DSA_KEY_FILE, "", NULL); 1285 sensitive_data.keys[5] = key_load_private_type(KEY_ECDSA, 1286 _PATH_HOST_ECDSA_KEY_FILE, "", NULL, NULL); 1287 sensitive_data.keys[6] = key_load_private_type(KEY_ED25519, 1288 _PATH_HOST_ED25519_KEY_FILE, "", NULL, NULL); 1289 sensitive_data.keys[7] = key_load_private_type(KEY_RSA, 1290 _PATH_HOST_RSA_KEY_FILE, "", NULL, NULL); 1291 sensitive_data.keys[8] = key_load_private_type(KEY_DSA, 1292 _PATH_HOST_DSA_KEY_FILE, "", NULL, NULL); 1293 PRIV_END; 1294 1295 if (options.hostbased_authentication == 1 && 1296 sensitive_data.keys[0] == NULL && 1297 sensitive_data.keys[5] == NULL && 1298 sensitive_data.keys[6] == NULL && 1299 sensitive_data.keys[7] == NULL && 1300 sensitive_data.keys[8] == NULL) { 1301 sensitive_data.keys[1] = key_load_cert( 1302 _PATH_HOST_ECDSA_KEY_FILE); 1303 sensitive_data.keys[2] = key_load_cert( 1304 _PATH_HOST_ED25519_KEY_FILE); 1305 sensitive_data.keys[3] = key_load_cert( 1306 _PATH_HOST_RSA_KEY_FILE); 1307 sensitive_data.keys[4] = key_load_cert( 1308 _PATH_HOST_DSA_KEY_FILE); 1309 sensitive_data.keys[5] = key_load_public( 1310 _PATH_HOST_ECDSA_KEY_FILE, NULL); 1311 sensitive_data.keys[6] = key_load_public( 1312 _PATH_HOST_ED25519_KEY_FILE, NULL); 1313 sensitive_data.keys[7] = key_load_public( 1314 _PATH_HOST_RSA_KEY_FILE, NULL); 1315 sensitive_data.keys[8] = key_load_public( 1316 _PATH_HOST_DSA_KEY_FILE, NULL); 1317 sensitive_data.external_keysign = 1; 1318 } 1319 } 1320 /* 1321 * Get rid of any extra privileges that we may have. We will no 1322 * longer need them. Also, extra privileges could make it very hard 1323 * to read identity files and other non-world-readable files from the 1324 * user's home directory if it happens to be on a NFS volume where 1325 * root is mapped to nobody. 1326 */ 1327 if (original_effective_uid == 0) { 1328 PRIV_START; 1329 permanently_set_uid(pw); 1330 } 1331 1332 /* 1333 * Now that we are back to our own permissions, create ~/.ssh 1334 * directory if it doesn't already exist. 1335 */ 1336 if (config == NULL) { 1337 r = snprintf(buf, sizeof buf, "%s%s%s", pw->pw_dir, 1338 strcmp(pw->pw_dir, "/") ? "/" : "", _PATH_SSH_USER_DIR); 1339 if (r > 0 && (size_t)r < sizeof(buf) && stat(buf, &st) < 0) 1340 if (mkdir(buf, 0700) < 0) 1341 error("Could not create directory '%.200s'.", 1342 buf); 1343 } 1344 1345 /* load options.identity_files */ 1346 load_public_identity_files(); 1347 1348 /* optionally set the SSH_AUTHSOCKET_ENV_NAME varibale */ 1349 if (options.identity_agent && 1350 strcmp(options.identity_agent, SSH_AUTHSOCKET_ENV_NAME) != 0) { 1351 if (strcmp(options.identity_agent, "none") == 0) { 1352 unsetenv(SSH_AUTHSOCKET_ENV_NAME); 1353 } else { 1354 p = tilde_expand_filename(options.identity_agent, 1355 original_real_uid); 1356 cp = percent_expand(p, "d", pw->pw_dir, 1357 "u", pw->pw_name, "l", thishost, "h", host, 1358 "r", options.user, (char *)NULL); 1359 setenv(SSH_AUTHSOCKET_ENV_NAME, cp, 1); 1360 free(cp); 1361 free(p); 1362 } 1363 } 1364 1365 /* Expand ~ in known host file names. */ 1366 tilde_expand_paths(options.system_hostfiles, 1367 options.num_system_hostfiles); 1368 tilde_expand_paths(options.user_hostfiles, options.num_user_hostfiles); 1369 1370 signal(SIGPIPE, SIG_IGN); /* ignore SIGPIPE early */ 1371 signal(SIGCHLD, main_sigchld_handler); 1372 1373 /* Log into the remote system. Never returns if the login fails. */ 1374 ssh_login(&sensitive_data, host, (struct sockaddr *)&hostaddr, 1375 options.port, pw, timeout_ms); 1376 1377 if (packet_connection_is_on_socket()) { 1378 verbose("Authenticated to %s ([%s]:%d).", host, 1379 ssh_remote_ipaddr(ssh), ssh_remote_port(ssh)); 1380 } else { 1381 verbose("Authenticated to %s (via proxy).", host); 1382 } 1383 1384 /* We no longer need the private host keys. Clear them now. */ 1385 if (sensitive_data.nkeys != 0) { 1386 for (i = 0; i < sensitive_data.nkeys; i++) { 1387 if (sensitive_data.keys[i] != NULL) { 1388 /* Destroys contents safely */ 1389 debug3("clear hostkey %d", i); 1390 key_free(sensitive_data.keys[i]); 1391 sensitive_data.keys[i] = NULL; 1392 } 1393 } 1394 free(sensitive_data.keys); 1395 } 1396 for (i = 0; i < options.num_identity_files; i++) { 1397 free(options.identity_files[i]); 1398 options.identity_files[i] = NULL; 1399 if (options.identity_keys[i]) { 1400 key_free(options.identity_keys[i]); 1401 options.identity_keys[i] = NULL; 1402 } 1403 } 1404 for (i = 0; i < options.num_certificate_files; i++) { 1405 free(options.certificate_files[i]); 1406 options.certificate_files[i] = NULL; 1407 } 1408 1409 skip_connect: 1410 exit_status = ssh_session2(); 1411 packet_close(); 1412 1413 if (options.control_path != NULL && muxserver_sock != -1) 1414 unlink(options.control_path); 1415 1416 /* Kill ProxyCommand if it is running. */ 1417 ssh_kill_proxy_command(); 1418 1419 return exit_status; 1420 } 1421 1422 static void 1423 control_persist_detach(void) 1424 { 1425 pid_t pid; 1426 int devnull, keep_stderr; 1427 1428 debug("%s: backgrounding master process", __func__); 1429 1430 /* 1431 * master (current process) into the background, and make the 1432 * foreground process a client of the backgrounded master. 1433 */ 1434 switch ((pid = fork())) { 1435 case -1: 1436 fatal("%s: fork: %s", __func__, strerror(errno)); 1437 case 0: 1438 /* Child: master process continues mainloop */ 1439 break; 1440 default: 1441 /* Parent: set up mux slave to connect to backgrounded master */ 1442 debug2("%s: background process is %ld", __func__, (long)pid); 1443 stdin_null_flag = ostdin_null_flag; 1444 options.request_tty = orequest_tty; 1445 tty_flag = otty_flag; 1446 close(muxserver_sock); 1447 muxserver_sock = -1; 1448 options.control_master = SSHCTL_MASTER_NO; 1449 muxclient(options.control_path); 1450 /* muxclient() doesn't return on success. */ 1451 fatal("Failed to connect to new control master"); 1452 } 1453 if ((devnull = open(_PATH_DEVNULL, O_RDWR)) == -1) { 1454 error("%s: open(\"/dev/null\"): %s", __func__, 1455 strerror(errno)); 1456 } else { 1457 keep_stderr = log_is_on_stderr() && debug_flag; 1458 if (dup2(devnull, STDIN_FILENO) == -1 || 1459 dup2(devnull, STDOUT_FILENO) == -1 || 1460 (!keep_stderr && dup2(devnull, STDERR_FILENO) == -1)) 1461 error("%s: dup2: %s", __func__, strerror(errno)); 1462 if (devnull > STDERR_FILENO) 1463 close(devnull); 1464 } 1465 daemon(1, 1); 1466 setproctitle("%s [mux]", options.control_path); 1467 } 1468 1469 /* Do fork() after authentication. Used by "ssh -f" */ 1470 static void 1471 fork_postauth(void) 1472 { 1473 if (need_controlpersist_detach) 1474 control_persist_detach(); 1475 debug("forking to background"); 1476 fork_after_authentication_flag = 0; 1477 if (daemon(1, 1) < 0) 1478 fatal("daemon() failed: %.200s", strerror(errno)); 1479 } 1480 1481 /* Callback for remote forward global requests */ 1482 static void 1483 ssh_confirm_remote_forward(int type, u_int32_t seq, void *ctxt) 1484 { 1485 struct Forward *rfwd = (struct Forward *)ctxt; 1486 1487 /* XXX verbose() on failure? */ 1488 debug("remote forward %s for: listen %s%s%d, connect %s:%d", 1489 type == SSH2_MSG_REQUEST_SUCCESS ? "success" : "failure", 1490 rfwd->listen_path ? rfwd->listen_path : 1491 rfwd->listen_host ? rfwd->listen_host : "", 1492 (rfwd->listen_path || rfwd->listen_host) ? ":" : "", 1493 rfwd->listen_port, rfwd->connect_path ? rfwd->connect_path : 1494 rfwd->connect_host, rfwd->connect_port); 1495 if (rfwd->listen_path == NULL && rfwd->listen_port == 0) { 1496 if (type == SSH2_MSG_REQUEST_SUCCESS) { 1497 rfwd->allocated_port = packet_get_int(); 1498 logit("Allocated port %u for remote forward to %s:%d", 1499 rfwd->allocated_port, 1500 rfwd->connect_host, rfwd->connect_port); 1501 channel_update_permitted_opens(rfwd->handle, 1502 rfwd->allocated_port); 1503 } else { 1504 channel_update_permitted_opens(rfwd->handle, -1); 1505 } 1506 } 1507 1508 if (type == SSH2_MSG_REQUEST_FAILURE) { 1509 if (options.exit_on_forward_failure) { 1510 if (rfwd->listen_path != NULL) 1511 fatal("Error: remote port forwarding failed " 1512 "for listen path %s", rfwd->listen_path); 1513 else 1514 fatal("Error: remote port forwarding failed " 1515 "for listen port %d", rfwd->listen_port); 1516 } else { 1517 if (rfwd->listen_path != NULL) 1518 logit("Warning: remote port forwarding failed " 1519 "for listen path %s", rfwd->listen_path); 1520 else 1521 logit("Warning: remote port forwarding failed " 1522 "for listen port %d", rfwd->listen_port); 1523 } 1524 } 1525 if (++remote_forward_confirms_received == options.num_remote_forwards) { 1526 debug("All remote forwarding requests processed"); 1527 if (fork_after_authentication_flag) 1528 fork_postauth(); 1529 } 1530 } 1531 1532 static void 1533 client_cleanup_stdio_fwd(int id, void *arg) 1534 { 1535 debug("stdio forwarding: done"); 1536 cleanup_exit(0); 1537 } 1538 1539 static void 1540 ssh_stdio_confirm(int id, int success, void *arg) 1541 { 1542 if (!success) 1543 fatal("stdio forwarding failed"); 1544 } 1545 1546 static void 1547 ssh_init_stdio_forwarding(void) 1548 { 1549 Channel *c; 1550 int in, out; 1551 1552 if (options.stdio_forward_host == NULL) 1553 return; 1554 1555 debug3("%s: %s:%d", __func__, options.stdio_forward_host, 1556 options.stdio_forward_port); 1557 1558 if ((in = dup(STDIN_FILENO)) < 0 || 1559 (out = dup(STDOUT_FILENO)) < 0) 1560 fatal("channel_connect_stdio_fwd: dup() in/out failed"); 1561 if ((c = channel_connect_stdio_fwd(options.stdio_forward_host, 1562 options.stdio_forward_port, in, out)) == NULL) 1563 fatal("%s: channel_connect_stdio_fwd failed", __func__); 1564 channel_register_cleanup(c->self, client_cleanup_stdio_fwd, 0); 1565 channel_register_open_confirm(c->self, ssh_stdio_confirm, NULL); 1566 } 1567 1568 static void 1569 ssh_init_forwarding(void) 1570 { 1571 int success = 0; 1572 int i; 1573 1574 /* Initiate local TCP/IP port forwardings. */ 1575 for (i = 0; i < options.num_local_forwards; i++) { 1576 debug("Local connections to %.200s:%d forwarded to remote " 1577 "address %.200s:%d", 1578 (options.local_forwards[i].listen_path != NULL) ? 1579 options.local_forwards[i].listen_path : 1580 (options.local_forwards[i].listen_host == NULL) ? 1581 (options.fwd_opts.gateway_ports ? "*" : "LOCALHOST") : 1582 options.local_forwards[i].listen_host, 1583 options.local_forwards[i].listen_port, 1584 (options.local_forwards[i].connect_path != NULL) ? 1585 options.local_forwards[i].connect_path : 1586 options.local_forwards[i].connect_host, 1587 options.local_forwards[i].connect_port); 1588 success += channel_setup_local_fwd_listener( 1589 &options.local_forwards[i], &options.fwd_opts); 1590 } 1591 if (i > 0 && success != i && options.exit_on_forward_failure) 1592 fatal("Could not request local forwarding."); 1593 if (i > 0 && success == 0) 1594 error("Could not request local forwarding."); 1595 1596 /* Initiate remote TCP/IP port forwardings. */ 1597 for (i = 0; i < options.num_remote_forwards; i++) { 1598 debug("Remote connections from %.200s:%d forwarded to " 1599 "local address %.200s:%d", 1600 (options.remote_forwards[i].listen_path != NULL) ? 1601 options.remote_forwards[i].listen_path : 1602 (options.remote_forwards[i].listen_host == NULL) ? 1603 "LOCALHOST" : options.remote_forwards[i].listen_host, 1604 options.remote_forwards[i].listen_port, 1605 (options.remote_forwards[i].connect_path != NULL) ? 1606 options.remote_forwards[i].connect_path : 1607 options.remote_forwards[i].connect_host, 1608 options.remote_forwards[i].connect_port); 1609 options.remote_forwards[i].handle = 1610 channel_request_remote_forwarding( 1611 &options.remote_forwards[i]); 1612 if (options.remote_forwards[i].handle < 0) { 1613 if (options.exit_on_forward_failure) 1614 fatal("Could not request remote forwarding."); 1615 else 1616 logit("Warning: Could not request remote " 1617 "forwarding."); 1618 } else { 1619 client_register_global_confirm(ssh_confirm_remote_forward, 1620 &options.remote_forwards[i]); 1621 } 1622 } 1623 1624 /* Initiate tunnel forwarding. */ 1625 if (options.tun_open != SSH_TUNMODE_NO) { 1626 if (client_request_tun_fwd(options.tun_open, 1627 options.tun_local, options.tun_remote) == -1) { 1628 if (options.exit_on_forward_failure) 1629 fatal("Could not request tunnel forwarding."); 1630 else 1631 error("Could not request tunnel forwarding."); 1632 } 1633 } 1634 } 1635 1636 static void 1637 check_agent_present(void) 1638 { 1639 int r; 1640 1641 if (options.forward_agent) { 1642 /* Clear agent forwarding if we don't have an agent. */ 1643 if ((r = ssh_get_authentication_socket(NULL)) != 0) { 1644 options.forward_agent = 0; 1645 if (r != SSH_ERR_AGENT_NOT_PRESENT) 1646 debug("ssh_get_authentication_socket: %s", 1647 ssh_err(r)); 1648 } 1649 } 1650 } 1651 1652 static void 1653 ssh_session2_setup(int id, int success, void *arg) 1654 { 1655 extern char **environ; 1656 const char *display; 1657 int interactive = tty_flag; 1658 char *proto = NULL, *data = NULL; 1659 1660 if (!success) 1661 return; /* No need for error message, channels code sens one */ 1662 1663 display = getenv("DISPLAY"); 1664 if (display == NULL && options.forward_x11) 1665 debug("X11 forwarding requested but DISPLAY not set"); 1666 if (options.forward_x11 && client_x11_get_proto(display, 1667 options.xauth_location, options.forward_x11_trusted, 1668 options.forward_x11_timeout, &proto, &data) == 0) { 1669 /* Request forwarding with authentication spoofing. */ 1670 debug("Requesting X11 forwarding with authentication " 1671 "spoofing."); 1672 x11_request_forwarding_with_spoofing(id, display, proto, 1673 data, 1); 1674 client_expect_confirm(id, "X11 forwarding", CONFIRM_WARN); 1675 /* XXX exit_on_forward_failure */ 1676 interactive = 1; 1677 } 1678 1679 check_agent_present(); 1680 if (options.forward_agent) { 1681 debug("Requesting authentication agent forwarding."); 1682 channel_request_start(id, "auth-agent-req@openssh.com", 0); 1683 packet_send(); 1684 } 1685 1686 /* Tell the packet module whether this is an interactive session. */ 1687 packet_set_interactive(interactive, 1688 options.ip_qos_interactive, options.ip_qos_bulk); 1689 1690 client_session2_setup(id, tty_flag, subsystem_flag, getenv("TERM"), 1691 NULL, fileno(stdin), &command, environ); 1692 } 1693 1694 /* open new channel for a session */ 1695 static int 1696 ssh_session2_open(void) 1697 { 1698 Channel *c; 1699 int window, packetmax, in, out, err; 1700 1701 if (stdin_null_flag) { 1702 in = open(_PATH_DEVNULL, O_RDONLY); 1703 } else { 1704 in = dup(STDIN_FILENO); 1705 } 1706 out = dup(STDOUT_FILENO); 1707 err = dup(STDERR_FILENO); 1708 1709 if (in < 0 || out < 0 || err < 0) 1710 fatal("dup() in/out/err failed"); 1711 1712 /* enable nonblocking unless tty */ 1713 if (!isatty(in)) 1714 set_nonblock(in); 1715 if (!isatty(out)) 1716 set_nonblock(out); 1717 if (!isatty(err)) 1718 set_nonblock(err); 1719 1720 window = CHAN_SES_WINDOW_DEFAULT; 1721 packetmax = CHAN_SES_PACKET_DEFAULT; 1722 if (tty_flag) { 1723 window >>= 1; 1724 packetmax >>= 1; 1725 } 1726 c = channel_new( 1727 "session", SSH_CHANNEL_OPENING, in, out, err, 1728 window, packetmax, CHAN_EXTENDED_WRITE, 1729 "client-session", /*nonblock*/0); 1730 1731 debug3("ssh_session2_open: channel_new: %d", c->self); 1732 1733 channel_send_open(c->self); 1734 if (!no_shell_flag) 1735 channel_register_open_confirm(c->self, 1736 ssh_session2_setup, NULL); 1737 1738 return c->self; 1739 } 1740 1741 static int 1742 ssh_session2(void) 1743 { 1744 int id = -1; 1745 1746 /* XXX should be pre-session */ 1747 if (!options.control_persist) 1748 ssh_init_stdio_forwarding(); 1749 ssh_init_forwarding(); 1750 1751 /* Start listening for multiplex clients */ 1752 if (!packet_get_mux()) 1753 muxserver_listen(); 1754 1755 /* 1756 * If we are in control persist mode and have a working mux listen 1757 * socket, then prepare to background ourselves and have a foreground 1758 * client attach as a control slave. 1759 * NB. we must save copies of the flags that we override for 1760 * the backgrounding, since we defer attachment of the slave until 1761 * after the connection is fully established (in particular, 1762 * async rfwd replies have been received for ExitOnForwardFailure). 1763 */ 1764 if (options.control_persist && muxserver_sock != -1) { 1765 ostdin_null_flag = stdin_null_flag; 1766 ono_shell_flag = no_shell_flag; 1767 orequest_tty = options.request_tty; 1768 otty_flag = tty_flag; 1769 stdin_null_flag = 1; 1770 no_shell_flag = 1; 1771 tty_flag = 0; 1772 if (!fork_after_authentication_flag) 1773 need_controlpersist_detach = 1; 1774 fork_after_authentication_flag = 1; 1775 } 1776 /* 1777 * ControlPersist mux listen socket setup failed, attempt the 1778 * stdio forward setup that we skipped earlier. 1779 */ 1780 if (options.control_persist && muxserver_sock == -1) 1781 ssh_init_stdio_forwarding(); 1782 1783 if (!no_shell_flag || (datafellows & SSH_BUG_DUMMYCHAN)) 1784 id = ssh_session2_open(); 1785 else { 1786 packet_set_interactive( 1787 options.control_master == SSHCTL_MASTER_NO, 1788 options.ip_qos_interactive, options.ip_qos_bulk); 1789 } 1790 1791 /* If we don't expect to open a new session, then disallow it */ 1792 if (options.control_master == SSHCTL_MASTER_NO && 1793 (datafellows & SSH_NEW_OPENSSH)) { 1794 debug("Requesting no-more-sessions@openssh.com"); 1795 packet_start(SSH2_MSG_GLOBAL_REQUEST); 1796 packet_put_cstring("no-more-sessions@openssh.com"); 1797 packet_put_char(0); 1798 packet_send(); 1799 } 1800 1801 /* Execute a local command */ 1802 if (options.local_command != NULL && 1803 options.permit_local_command) 1804 ssh_local_cmd(options.local_command); 1805 1806 /* 1807 * If requested and we are not interested in replies to remote 1808 * forwarding requests, then let ssh continue in the background. 1809 */ 1810 if (fork_after_authentication_flag) { 1811 if (options.exit_on_forward_failure && 1812 options.num_remote_forwards > 0) { 1813 debug("deferring postauth fork until remote forward " 1814 "confirmation received"); 1815 } else 1816 fork_postauth(); 1817 } 1818 1819 return client_loop(tty_flag, tty_flag ? 1820 options.escape_char : SSH_ESCAPECHAR_NONE, id); 1821 } 1822 1823 /* Loads all IdentityFile and CertificateFile keys */ 1824 static void 1825 load_public_identity_files(void) 1826 { 1827 char *filename, *cp, thishost[NI_MAXHOST]; 1828 char *pwdir = NULL, *pwname = NULL; 1829 struct sshkey *public; 1830 struct passwd *pw; 1831 int i; 1832 u_int n_ids, n_certs; 1833 char *identity_files[SSH_MAX_IDENTITY_FILES]; 1834 struct sshkey *identity_keys[SSH_MAX_IDENTITY_FILES]; 1835 char *certificate_files[SSH_MAX_CERTIFICATE_FILES]; 1836 struct sshkey *certificates[SSH_MAX_CERTIFICATE_FILES]; 1837 #ifdef ENABLE_PKCS11 1838 struct sshkey **keys; 1839 int nkeys; 1840 #endif /* PKCS11 */ 1841 1842 n_ids = n_certs = 0; 1843 memset(identity_files, 0, sizeof(identity_files)); 1844 memset(identity_keys, 0, sizeof(identity_keys)); 1845 memset(certificate_files, 0, sizeof(certificate_files)); 1846 memset(certificates, 0, sizeof(certificates)); 1847 1848 #ifdef ENABLE_PKCS11 1849 if (options.pkcs11_provider != NULL && 1850 options.num_identity_files < SSH_MAX_IDENTITY_FILES && 1851 (pkcs11_init(!options.batch_mode) == 0) && 1852 (nkeys = pkcs11_add_provider(options.pkcs11_provider, NULL, 1853 &keys)) > 0) { 1854 for (i = 0; i < nkeys; i++) { 1855 if (n_ids >= SSH_MAX_IDENTITY_FILES) { 1856 key_free(keys[i]); 1857 continue; 1858 } 1859 identity_keys[n_ids] = keys[i]; 1860 identity_files[n_ids] = 1861 xstrdup(options.pkcs11_provider); /* XXX */ 1862 n_ids++; 1863 } 1864 free(keys); 1865 } 1866 #endif /* ENABLE_PKCS11 */ 1867 if ((pw = getpwuid(original_real_uid)) == NULL) 1868 fatal("load_public_identity_files: getpwuid failed"); 1869 pwname = xstrdup(pw->pw_name); 1870 pwdir = xstrdup(pw->pw_dir); 1871 if (gethostname(thishost, sizeof(thishost)) == -1) 1872 fatal("load_public_identity_files: gethostname: %s", 1873 strerror(errno)); 1874 for (i = 0; i < options.num_identity_files; i++) { 1875 if (n_ids >= SSH_MAX_IDENTITY_FILES || 1876 strcasecmp(options.identity_files[i], "none") == 0) { 1877 free(options.identity_files[i]); 1878 options.identity_files[i] = NULL; 1879 continue; 1880 } 1881 cp = tilde_expand_filename(options.identity_files[i], 1882 original_real_uid); 1883 filename = percent_expand(cp, "d", pwdir, 1884 "u", pwname, "l", thishost, "h", host, 1885 "r", options.user, (char *)NULL); 1886 free(cp); 1887 public = key_load_public(filename, NULL); 1888 debug("identity file %s type %d", filename, 1889 public ? public->type : -1); 1890 free(options.identity_files[i]); 1891 identity_files[n_ids] = filename; 1892 identity_keys[n_ids] = public; 1893 1894 if (++n_ids >= SSH_MAX_IDENTITY_FILES) 1895 continue; 1896 1897 /* 1898 * If no certificates have been explicitly listed then try 1899 * to add the default certificate variant too. 1900 */ 1901 if (options.num_certificate_files != 0) 1902 continue; 1903 xasprintf(&cp, "%s-cert", filename); 1904 public = key_load_public(cp, NULL); 1905 debug("identity file %s type %d", cp, 1906 public ? public->type : -1); 1907 if (public == NULL) { 1908 free(cp); 1909 continue; 1910 } 1911 if (!key_is_cert(public)) { 1912 debug("%s: key %s type %s is not a certificate", 1913 __func__, cp, key_type(public)); 1914 key_free(public); 1915 free(cp); 1916 continue; 1917 } 1918 /* NB. leave filename pointing to private key */ 1919 identity_files[n_ids] = xstrdup(filename); 1920 identity_keys[n_ids] = public; 1921 n_ids++; 1922 } 1923 1924 if (options.num_certificate_files > SSH_MAX_CERTIFICATE_FILES) 1925 fatal("%s: too many certificates", __func__); 1926 for (i = 0; i < options.num_certificate_files; i++) { 1927 cp = tilde_expand_filename(options.certificate_files[i], 1928 original_real_uid); 1929 filename = percent_expand(cp, "d", pwdir, 1930 "u", pwname, "l", thishost, "h", host, 1931 "r", options.user, (char *)NULL); 1932 free(cp); 1933 1934 public = key_load_public(filename, NULL); 1935 debug("certificate file %s type %d", filename, 1936 public ? public->type : -1); 1937 free(options.certificate_files[i]); 1938 options.certificate_files[i] = NULL; 1939 if (public == NULL) { 1940 free(filename); 1941 continue; 1942 } 1943 if (!key_is_cert(public)) { 1944 debug("%s: key %s type %s is not a certificate", 1945 __func__, filename, key_type(public)); 1946 key_free(public); 1947 free(filename); 1948 continue; 1949 } 1950 certificate_files[n_certs] = filename; 1951 certificates[n_certs] = public; 1952 ++n_certs; 1953 } 1954 1955 options.num_identity_files = n_ids; 1956 memcpy(options.identity_files, identity_files, sizeof(identity_files)); 1957 memcpy(options.identity_keys, identity_keys, sizeof(identity_keys)); 1958 1959 options.num_certificate_files = n_certs; 1960 memcpy(options.certificate_files, 1961 certificate_files, sizeof(certificate_files)); 1962 memcpy(options.certificates, certificates, sizeof(certificates)); 1963 1964 explicit_bzero(pwname, strlen(pwname)); 1965 free(pwname); 1966 explicit_bzero(pwdir, strlen(pwdir)); 1967 free(pwdir); 1968 } 1969 1970 static void 1971 main_sigchld_handler(int sig) 1972 { 1973 int save_errno = errno; 1974 pid_t pid; 1975 int status; 1976 1977 while ((pid = waitpid(-1, &status, WNOHANG)) > 0 || 1978 (pid < 0 && errno == EINTR)) 1979 ; 1980 1981 signal(sig, main_sigchld_handler); 1982 errno = save_errno; 1983 } 1984