blob: 160bf6b546da59990b194335a90821da339cc472 [file] [log] [blame]
djm@openbsd.org25b2ed62019-01-19 21:36:06 +00001/* $OpenBSD: ssh.c,v 1.499 2019/01/19 21:36:06 djm Exp $ */
Damien Millerd4a8b7e1999-10-27 13:42:43 +10002/*
Damien Miller95def091999-11-25 00:26:21 +11003 * Author: Tatu Ylonen <ylo@cs.hut.fi>
4 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
5 * All rights reserved
Damien Miller95def091999-11-25 00:26:21 +11006 * 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 *
Damien Millere4340be2000-09-16 13:29:08 +110010 * 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.
Darren Tucker0a118da2003-10-15 15:54:32 +100017 * Copyright (c) 2000, 2001, 2002, 2003 Markus Friedl. All rights reserved.
Damien Millere4340be2000-09-16 13:29:08 +110018 *
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.
Damien Miller95def091999-11-25 00:26:21 +110041 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100042
43#include "includes.h"
Damien Millercd4223c2006-03-15 11:22:47 +110044
Damien Millerf17883e2006-03-15 11:45:54 +110045#include <sys/types.h>
46#ifdef HAVE_SYS_STAT_H
47# include <sys/stat.h>
48#endif
Damien Millercd4223c2006-03-15 11:22:47 +110049#include <sys/resource.h>
Damien Miller17e91c02006-03-15 11:28:34 +110050#include <sys/ioctl.h>
Damien Millere3b60b52006-07-10 21:08:03 +100051#include <sys/socket.h>
Damien Miller857b02e2010-09-24 22:02:56 +100052#include <sys/wait.h>
Damien Miller03e20032006-03-15 11:16:59 +110053
Damien Millerc7b06362006-03-15 11:53:45 +110054#include <ctype.h>
Darren Tuckerba724052006-07-12 22:24:22 +100055#include <errno.h>
Damien Miller57cf6382006-07-10 21:13:46 +100056#include <fcntl.h>
Damien Millerb8fe89c2006-07-24 14:51:00 +100057#include <netdb.h>
Damien Miller6645e7a2006-03-15 14:42:54 +110058#ifdef HAVE_PATHS_H
Damien Miller03e20032006-03-15 11:16:59 +110059#include <paths.h>
Damien Miller6645e7a2006-03-15 14:42:54 +110060#endif
Damien Miller9f2abc42006-07-10 20:53:08 +100061#include <pwd.h>
Damien Miller6ff3cad2006-03-15 11:52:09 +110062#include <signal.h>
Damien Millerded319c2006-09-01 15:38:36 +100063#include <stdarg.h>
Damien Miller2d00e632006-07-24 13:53:19 +100064#include <stddef.h>
Damien Millera7a73ee2006-08-05 11:37:59 +100065#include <stdio.h>
Damien Millere7a1e5c2006-08-05 11:34:19 +100066#include <stdlib.h>
Damien Millere3476ed2006-07-24 14:13:33 +100067#include <string.h>
Damien Millere6b3b612006-07-24 14:01:23 +100068#include <unistd.h>
deraadt@openbsd.org087266e2015-01-20 23:14:00 +000069#include <limits.h>
djm@openbsd.org65c6c6b2016-07-17 04:20:16 +000070#include <locale.h>
Damien Millereba71ba2000-04-29 23:57:08 +100071
Darren Tucker46aa3e02006-09-02 15:32:40 +100072#include <netinet/in.h>
73#include <arpa/inet.h>
74
Damien Miller1f0311c2014-05-15 14:24:09 +100075#ifdef WITH_OPENSSL
Damien Millereba71ba2000-04-29 23:57:08 +100076#include <openssl/evp.h>
Damien Miller0bc1bd82000-11-13 22:57:25 +110077#include <openssl/err.h>
Damien Miller1f0311c2014-05-15 14:24:09 +100078#endif
Darren Tuckerbfaaf962008-02-28 19:13:52 +110079#include "openbsd-compat/openssl-compat.h"
Damien Millerb84886b2008-05-19 15:05:07 +100080#include "openbsd-compat/sys-queue.h"
Damien Millerd4a8b7e1999-10-27 13:42:43 +100081
Damien Millerd7834352006-08-05 12:39:39 +100082#include "xmalloc.h"
Damien Millerd4a8b7e1999-10-27 13:42:43 +100083#include "ssh.h"
Damien Miller1383bd82000-04-06 12:32:37 +100084#include "ssh2.h"
Damien Millerb96c4412010-07-02 13:34:24 +100085#include "canohost.h"
Damien Miller1383bd82000-04-06 12:32:37 +100086#include "compat.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000087#include "cipher.h"
Damien Miller9c386432014-07-03 21:27:46 +100088#include "digest.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000089#include "packet.h"
markus@openbsd.orgcecee2d2018-07-09 21:03:30 +000090#include "sshbuf.h"
Ben Lindstromc7637672001-06-09 00:36:26 +000091#include "channels.h"
markus@openbsd.org5467fbc2018-07-11 18:53:29 +000092#include "sshkey.h"
Damien Miller994cf142000-07-21 10:19:44 +100093#include "authfd.h"
Damien Millereba71ba2000-04-29 23:57:08 +100094#include "authfile.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000095#include "pathnames.h"
Damien Miller0e220db2004-06-15 10:34:08 +100096#include "dispatch.h"
Ben Lindstrombf555ba2001-01-18 02:04:35 +000097#include "clientloop.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000098#include "log.h"
Damien Miller7acefbb2014-07-18 14:11:24 +100099#include "misc.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +0000100#include "readconf.h"
101#include "sshconnect.h"
Ben Lindstrom06b33aa2001-02-15 03:01:59 +0000102#include "kex.h"
103#include "mac.h"
Darren Tucker06f2bd82004-05-13 16:06:46 +1000104#include "sshpty.h"
Darren Tucker46bc0752004-05-02 22:11:30 +1000105#include "match.h"
Damien Miller0e220db2004-06-15 10:34:08 +1000106#include "msg.h"
Damien Millerb7576772006-07-10 20:23:39 +1000107#include "version.h"
djm@openbsd.org141efe42015-01-14 20:05:27 +0000108#include "ssherr.h"
djm@openbsd.orgf9eca242015-07-30 00:01:34 +0000109#include "myproposal.h"
Damien Millerdda78a02016-12-12 13:57:10 +1100110#include "utf8.h"
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000111
Damien Miller7ea845e2010-02-12 09:21:02 +1100112#ifdef ENABLE_PKCS11
113#include "ssh-pkcs11.h"
Ben Lindstrombcc18082001-08-06 21:59:25 +0000114#endif
Ben Lindstromc5b68002001-07-04 04:52:03 +0000115
djm@openbsd.org25b2ed62019-01-19 21:36:06 +0000116extern struct ssh *active_state; /* XXX remove after sshconnect2.c updated */
djm@openbsd.org0fa174e2019-01-19 21:31:32 +0000117
Damien Miller3f905871999-11-15 17:10:57 +1100118extern char *__progname;
Damien Miller3f905871999-11-15 17:10:57 +1100119
Damien Millerea2c1a42011-06-03 12:10:22 +1000120/* Saves a copy of argv for setproctitle emulation */
121#ifndef HAVE_SETPROCTITLE
122static char **saved_av;
123#endif
124
Darren Tuckerd6173c02008-06-13 04:52:53 +1000125/* Flag indicating whether debug mode is on. May be set on the command line. */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000126int debug_flag = 0;
127
Damien Miller21771e22011-05-15 08:45:50 +1000128/* Flag indicating whether a tty should be requested */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000129int tty_flag = 0;
130
Damien Miller1383bd82000-04-06 12:32:37 +1000131/* don't exec a shell */
132int no_shell_flag = 0;
Damien Miller1383bd82000-04-06 12:32:37 +1000133
Damien Miller5428f641999-11-25 11:54:57 +1100134/*
135 * Flag indicating that nothing should be read from stdin. This can be set
136 * on the command line.
137 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000138int stdin_null_flag = 0;
139
Damien Miller5428f641999-11-25 11:54:57 +1100140/*
Damien Millere11e1ea2010-08-03 16:04:46 +1000141 * Flag indicating that the current process should be backgrounded and
142 * a new slave launched in the foreground for ControlPersist.
143 */
144int need_controlpersist_detach = 0;
145
146/* Copies of flags for ControlPersist foreground slave */
Damien Miller21771e22011-05-15 08:45:50 +1000147int ostdin_null_flag, ono_shell_flag, otty_flag, orequest_tty;
Damien Millere11e1ea2010-08-03 16:04:46 +1000148
149/*
Damien Miller5428f641999-11-25 11:54:57 +1100150 * Flag indicating that ssh should fork after authentication. This is useful
Ben Lindstromf666fec2002-06-06 19:51:58 +0000151 * so that the passphrase can be entered manually, and then ssh goes to the
Damien Miller5428f641999-11-25 11:54:57 +1100152 * background.
153 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000154int fork_after_authentication_flag = 0;
155
Damien Miller5428f641999-11-25 11:54:57 +1100156/*
157 * General data structure for command line options and options configurable
158 * in configuration files. See readconf.h.
159 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000160Options options;
161
Ben Lindstrom14f31ab2001-09-12 17:48:04 +0000162/* optional user configfile */
163char *config = NULL;
164
Damien Miller5428f641999-11-25 11:54:57 +1100165/*
166 * Name of the host we are connecting to. This is the name given on the
167 * command line, or the HostName specified for the user-supplied name in a
168 * configuration file.
169 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000170char *host;
171
djm@openbsd.orgb7548b12017-10-23 05:08:00 +0000172/* Various strings used to to percent_expand() arguments */
173static char thishost[NI_MAXHOST], shorthost[NI_MAXHOST], portstr[NI_MAXSERV];
174static char uidstr[32], *host_arg, *conn_hash_hex;
175
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000176/* socket address the host resolves to */
Damien Miller34132e52000-01-14 15:45:46 +1100177struct sockaddr_storage hostaddr;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000178
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000179/* Private host keys. */
Ben Lindstrom1bad2562002-06-06 19:57:33 +0000180Sensitive sensitive_data;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000181
Damien Miller1383bd82000-04-06 12:32:37 +1000182/* command to be executed */
markus@openbsd.orgcecee2d2018-07-09 21:03:30 +0000183struct sshbuf *command;
Damien Miller1383bd82000-04-06 12:32:37 +1000184
Damien Miller832562e2001-01-30 09:30:01 +1100185/* Should we execute a command or invoke a subsystem? */
186int subsystem_flag = 0;
187
Damien Miller2797f7f2002-04-23 21:09:44 +1000188/* # of replies received for global requests */
Darren Tucker9f407c42008-06-13 04:50:27 +1000189static int remote_forward_confirms_received = 0;
Damien Miller2797f7f2002-04-23 21:09:44 +1000190
Damien Millerb1cbfa22008-05-19 16:00:08 +1000191/* mux.c */
192extern int muxserver_sock;
193extern u_int muxclient_command;
Damien Miller0e220db2004-06-15 10:34:08 +1000194
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000195/* Prints a help message to the user. This function never returns. */
196
Ben Lindstrombba81212001-06-25 05:01:22 +0000197static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +0000198usage(void)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000199{
Damien Miller50955102004-03-22 09:34:58 +1100200 fprintf(stderr,
djm@openbsd.orgac2e3022018-02-23 02:34:33 +0000201"usage: ssh [-46AaCfGgKkMNnqsTtVvXxYy] [-B bind_interface]\n"
202" [-b bind_address] [-c cipher_spec] [-D [bind_address:]port]\n"
203" [-E log_file] [-e escape_char] [-F configfile] [-I pkcs11]\n"
204" [-i identity_file] [-J [user@]host[:port]] [-L address]\n"
205" [-l login_name] [-m mac_spec] [-O ctl_cmd] [-o option] [-p port]\n"
206" [-Q query_option] [-R address] [-S ctl_path] [-W host:port]\n"
207" [-w local_tun[:remote_tun]] destination [command]\n"
Damien Miller50955102004-03-22 09:34:58 +1100208 );
Darren Tuckere9a9b712005-12-20 16:15:51 +1100209 exit(255);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000210}
211
djm@openbsd.orgb7548b12017-10-23 05:08:00 +0000212static int ssh_session2(struct ssh *, struct passwd *);
213static void load_public_identity_files(struct passwd *);
Damien Miller857b02e2010-09-24 22:02:56 +1000214static void main_sigchld_handler(int);
Damien Millerb1cbfa22008-05-19 16:00:08 +1000215
Damien Miller295ee632011-05-29 21:42:31 +1000216/* ~/ expand a list of paths. NB. assumes path[n] is heap-allocated. */
217static void
218tilde_expand_paths(char **paths, u_int num_paths)
219{
220 u_int i;
221 char *cp;
222
223 for (i = 0; i < num_paths; i++) {
dtucker@openbsd.orge655ee02018-07-27 05:34:42 +0000224 cp = tilde_expand_filename(paths[i], getuid());
Darren Tuckera627d422013-06-02 07:31:17 +1000225 free(paths[i]);
Damien Miller295ee632011-05-29 21:42:31 +1000226 paths[i] = cp;
227 }
228}
229
Damien Miller13f97b22014-02-24 15:57:55 +1100230/*
231 * Attempt to resolve a host name / port to a set of addresses and
232 * optionally return any CNAMEs encountered along the way.
233 * Returns NULL on failure.
234 * NB. this function must operate with a options having undefined members.
235 */
Damien Miller0faf7472013-10-17 11:47:23 +1100236static struct addrinfo *
Damien Miller13f97b22014-02-24 15:57:55 +1100237resolve_host(const char *name, int port, int logerr, char *cname, size_t clen)
Damien Miller0faf7472013-10-17 11:47:23 +1100238{
239 char strport[NI_MAXSERV];
240 struct addrinfo hints, *res;
241 int gaierr, loglevel = SYSLOG_LEVEL_DEBUG1;
242
Damien Miller13f97b22014-02-24 15:57:55 +1100243 if (port <= 0)
244 port = default_ssh_port();
245
djm@openbsd.orgb1d38a32015-10-15 23:51:40 +0000246 snprintf(strport, sizeof strport, "%d", port);
Damien Miller1d2c4562014-02-04 11:18:20 +1100247 memset(&hints, 0, sizeof(hints));
Damien Miller13f97b22014-02-24 15:57:55 +1100248 hints.ai_family = options.address_family == -1 ?
249 AF_UNSPEC : options.address_family;
Damien Miller0faf7472013-10-17 11:47:23 +1100250 hints.ai_socktype = SOCK_STREAM;
251 if (cname != NULL)
252 hints.ai_flags = AI_CANONNAME;
253 if ((gaierr = getaddrinfo(name, strport, &hints, &res)) != 0) {
254 if (logerr || (gaierr != EAI_NONAME && gaierr != EAI_NODATA))
255 loglevel = SYSLOG_LEVEL_ERROR;
256 do_log2(loglevel, "%s: Could not resolve hostname %.100s: %s",
257 __progname, name, ssh_gai_strerror(gaierr));
258 return NULL;
259 }
260 if (cname != NULL && res->ai_canonname != NULL) {
261 if (strlcpy(cname, res->ai_canonname, clen) >= clen) {
262 error("%s: host \"%s\" cname \"%s\" too long (max %lu)",
263 __func__, name, res->ai_canonname, (u_long)clen);
264 if (clen > 0)
265 *cname = '\0';
266 }
267 }
268 return res;
269}
270
djm@openbsd.orgfc21ea92018-01-23 05:06:25 +0000271/* Returns non-zero if name can only be an address and not a hostname */
272static int
273is_addr_fast(const char *name)
274{
275 return (strchr(name, '%') != NULL || strchr(name, ':') != NULL ||
276 strspn(name, "0123456789.") == strlen(name));
277}
278
279/* Returns non-zero if name represents a valid, single address */
280static int
281is_addr(const char *name)
282{
283 char strport[NI_MAXSERV];
284 struct addrinfo hints, *res;
285
286 if (is_addr_fast(name))
287 return 1;
288
289 snprintf(strport, sizeof strport, "%u", default_ssh_port());
290 memset(&hints, 0, sizeof(hints));
291 hints.ai_family = options.address_family == -1 ?
292 AF_UNSPEC : options.address_family;
293 hints.ai_socktype = SOCK_STREAM;
294 hints.ai_flags = AI_NUMERICHOST|AI_NUMERICSERV;
295 if (getaddrinfo(name, strport, &hints, &res) != 0)
296 return 0;
297 if (res == NULL || res->ai_next != NULL) {
298 freeaddrinfo(res);
299 return 0;
300 }
301 freeaddrinfo(res);
302 return 1;
303}
304
Damien Miller0faf7472013-10-17 11:47:23 +1100305/*
djm@openbsd.org90109022015-01-16 07:19:48 +0000306 * Attempt to resolve a numeric host address / port to a single address.
307 * Returns a canonical address string.
308 * Returns NULL on failure.
309 * NB. this function must operate with a options having undefined members.
310 */
311static struct addrinfo *
312resolve_addr(const char *name, int port, char *caddr, size_t clen)
313{
314 char addr[NI_MAXHOST], strport[NI_MAXSERV];
315 struct addrinfo hints, *res;
316 int gaierr;
317
318 if (port <= 0)
319 port = default_ssh_port();
320 snprintf(strport, sizeof strport, "%u", port);
321 memset(&hints, 0, sizeof(hints));
322 hints.ai_family = options.address_family == -1 ?
323 AF_UNSPEC : options.address_family;
324 hints.ai_socktype = SOCK_STREAM;
325 hints.ai_flags = AI_NUMERICHOST|AI_NUMERICSERV;
326 if ((gaierr = getaddrinfo(name, strport, &hints, &res)) != 0) {
327 debug2("%s: could not resolve name %.100s as address: %s",
328 __func__, name, ssh_gai_strerror(gaierr));
329 return NULL;
330 }
331 if (res == NULL) {
332 debug("%s: getaddrinfo %.100s returned no addresses",
333 __func__, name);
334 return NULL;
335 }
336 if (res->ai_next != NULL) {
337 debug("%s: getaddrinfo %.100s returned multiple addresses",
338 __func__, name);
339 goto fail;
340 }
341 if ((gaierr = getnameinfo(res->ai_addr, res->ai_addrlen,
342 addr, sizeof(addr), NULL, 0, NI_NUMERICHOST)) != 0) {
343 debug("%s: Could not format address for name %.100s: %s",
344 __func__, name, ssh_gai_strerror(gaierr));
345 goto fail;
346 }
347 if (strlcpy(caddr, addr, clen) >= clen) {
348 error("%s: host \"%s\" addr \"%s\" too long (max %lu)",
349 __func__, name, addr, (u_long)clen);
350 if (clen > 0)
351 *caddr = '\0';
352 fail:
353 freeaddrinfo(res);
354 return NULL;
355 }
356 return res;
357}
358
359/*
Damien Miller0faf7472013-10-17 11:47:23 +1100360 * Check whether the cname is a permitted replacement for the hostname
361 * and perform the replacement if it is.
Damien Miller13f97b22014-02-24 15:57:55 +1100362 * NB. this function must operate with a options having undefined members.
Damien Miller0faf7472013-10-17 11:47:23 +1100363 */
364static int
djm@openbsd.orged877ef2016-07-15 00:24:30 +0000365check_follow_cname(int direct, char **namep, const char *cname)
Damien Miller0faf7472013-10-17 11:47:23 +1100366{
367 int i;
368 struct allowed_cname *rule;
369
370 if (*cname == '\0' || options.num_permitted_cnames == 0 ||
371 strcmp(*namep, cname) == 0)
372 return 0;
Damien Miller38505592013-10-17 11:48:13 +1100373 if (options.canonicalize_hostname == SSH_CANONICALISE_NO)
Damien Miller0faf7472013-10-17 11:47:23 +1100374 return 0;
375 /*
Damien Miller38505592013-10-17 11:48:13 +1100376 * Don't attempt to canonicalize names that will be interpreted by
djm@openbsd.orged877ef2016-07-15 00:24:30 +0000377 * a proxy or jump host unless the user specifically requests so.
Damien Miller0faf7472013-10-17 11:47:23 +1100378 */
djm@openbsd.orged877ef2016-07-15 00:24:30 +0000379 if (!direct &&
Damien Miller38505592013-10-17 11:48:13 +1100380 options.canonicalize_hostname != SSH_CANONICALISE_ALWAYS)
Damien Miller0faf7472013-10-17 11:47:23 +1100381 return 0;
382 debug3("%s: check \"%s\" CNAME \"%s\"", __func__, *namep, cname);
383 for (i = 0; i < options.num_permitted_cnames; i++) {
384 rule = options.permitted_cnames + i;
djm@openbsd.orge661a862015-05-04 06:10:48 +0000385 if (match_pattern_list(*namep, rule->source_list, 1) != 1 ||
386 match_pattern_list(cname, rule->target_list, 1) != 1)
Damien Miller0faf7472013-10-17 11:47:23 +1100387 continue;
Damien Miller38505592013-10-17 11:48:13 +1100388 verbose("Canonicalized DNS aliased hostname "
Damien Miller0faf7472013-10-17 11:47:23 +1100389 "\"%s\" => \"%s\"", *namep, cname);
390 free(*namep);
391 *namep = xstrdup(cname);
392 return 1;
393 }
394 return 0;
395}
396
397/*
398 * Attempt to resolve the supplied hostname after applying the user's
Damien Miller51682fa2013-10-17 11:48:31 +1100399 * canonicalization rules. Returns the address list for the host or NULL
400 * if no name was found after canonicalization.
Damien Miller13f97b22014-02-24 15:57:55 +1100401 * NB. this function must operate with a options having undefined members.
Damien Miller0faf7472013-10-17 11:47:23 +1100402 */
403static struct addrinfo *
Damien Miller13f97b22014-02-24 15:57:55 +1100404resolve_canonicalize(char **hostp, int port)
Damien Miller0faf7472013-10-17 11:47:23 +1100405{
djm@openbsd.orged877ef2016-07-15 00:24:30 +0000406 int i, direct, ndots;
djm@openbsd.org90109022015-01-16 07:19:48 +0000407 char *cp, *fullhost, newname[NI_MAXHOST];
Damien Miller0faf7472013-10-17 11:47:23 +1100408 struct addrinfo *addrs;
409
djm@openbsd.orgfc21ea92018-01-23 05:06:25 +0000410 /*
411 * Attempt to canonicalise addresses, regardless of
412 * whether hostname canonicalisation was requested
413 */
414 if ((addrs = resolve_addr(*hostp, port,
415 newname, sizeof(newname))) != NULL) {
416 debug2("%s: hostname %.100s is address", __func__, *hostp);
417 if (strcasecmp(*hostp, newname) != 0) {
418 debug2("%s: canonicalised address \"%s\" => \"%s\"",
419 __func__, *hostp, newname);
420 free(*hostp);
421 *hostp = xstrdup(newname);
422 }
423 return addrs;
424 }
425
426 /*
427 * If this looks like an address but didn't parse as one, it might
428 * be an address with an invalid interface scope. Skip further
429 * attempts at canonicalisation.
430 */
431 if (is_addr_fast(*hostp)) {
432 debug("%s: hostname %.100s is an unrecognised address",
433 __func__, *hostp);
434 return NULL;
435 }
436
Damien Miller38505592013-10-17 11:48:13 +1100437 if (options.canonicalize_hostname == SSH_CANONICALISE_NO)
Damien Miller0faf7472013-10-17 11:47:23 +1100438 return NULL;
Damien Miller13f97b22014-02-24 15:57:55 +1100439
Damien Miller0faf7472013-10-17 11:47:23 +1100440 /*
Damien Miller38505592013-10-17 11:48:13 +1100441 * Don't attempt to canonicalize names that will be interpreted by
Damien Miller0faf7472013-10-17 11:47:23 +1100442 * a proxy unless the user specifically requests so.
443 */
djm@openbsd.orged877ef2016-07-15 00:24:30 +0000444 direct = option_clear_or_none(options.proxy_command) &&
445 options.jump_host == NULL;
446 if (!direct &&
Damien Miller38505592013-10-17 11:48:13 +1100447 options.canonicalize_hostname != SSH_CANONICALISE_ALWAYS)
Damien Miller0faf7472013-10-17 11:47:23 +1100448 return NULL;
Damien Miller13f97b22014-02-24 15:57:55 +1100449
djm@openbsd.org5ee00632015-10-16 18:40:49 +0000450 /* If domain name is anchored, then resolve it now */
451 if ((*hostp)[strlen(*hostp) - 1] == '.') {
452 debug3("%s: name is fully qualified", __func__);
453 fullhost = xstrdup(*hostp);
454 if ((addrs = resolve_host(fullhost, port, 0,
455 newname, sizeof(newname))) != NULL)
456 goto found;
457 free(fullhost);
458 goto notfound;
459 }
460
Damien Miller51682fa2013-10-17 11:48:31 +1100461 /* Don't apply canonicalization to sufficiently-qualified hostnames */
Damien Miller0faf7472013-10-17 11:47:23 +1100462 ndots = 0;
463 for (cp = *hostp; *cp != '\0'; cp++) {
464 if (*cp == '.')
465 ndots++;
466 }
Damien Miller38505592013-10-17 11:48:13 +1100467 if (ndots > options.canonicalize_max_dots) {
468 debug3("%s: not canonicalizing hostname \"%s\" (max dots %d)",
469 __func__, *hostp, options.canonicalize_max_dots);
Damien Miller0faf7472013-10-17 11:47:23 +1100470 return NULL;
471 }
472 /* Attempt each supplied suffix */
473 for (i = 0; i < options.num_canonical_domains; i++) {
djm@openbsd.org90109022015-01-16 07:19:48 +0000474 *newname = '\0';
Damien Miller0faf7472013-10-17 11:47:23 +1100475 xasprintf(&fullhost, "%s.%s.", *hostp,
476 options.canonical_domains[i]);
Damien Miller13f97b22014-02-24 15:57:55 +1100477 debug3("%s: attempting \"%s\" => \"%s\"", __func__,
478 *hostp, fullhost);
479 if ((addrs = resolve_host(fullhost, port, 0,
djm@openbsd.org90109022015-01-16 07:19:48 +0000480 newname, sizeof(newname))) == NULL) {
Damien Miller0faf7472013-10-17 11:47:23 +1100481 free(fullhost);
482 continue;
483 }
djm@openbsd.org5ee00632015-10-16 18:40:49 +0000484 found:
Damien Miller0faf7472013-10-17 11:47:23 +1100485 /* Remove trailing '.' */
486 fullhost[strlen(fullhost) - 1] = '\0';
487 /* Follow CNAME if requested */
djm@openbsd.orged877ef2016-07-15 00:24:30 +0000488 if (!check_follow_cname(direct, &fullhost, newname)) {
Damien Miller38505592013-10-17 11:48:13 +1100489 debug("Canonicalized hostname \"%s\" => \"%s\"",
Damien Miller0faf7472013-10-17 11:47:23 +1100490 *hostp, fullhost);
491 }
492 free(*hostp);
493 *hostp = fullhost;
494 return addrs;
495 }
djm@openbsd.org5ee00632015-10-16 18:40:49 +0000496 notfound:
Damien Miller38505592013-10-17 11:48:13 +1100497 if (!options.canonicalize_fallback_local)
Damien Miller13f97b22014-02-24 15:57:55 +1100498 fatal("%s: Could not resolve host \"%s\"", __progname, *hostp);
499 debug2("%s: host %s not found in any suffix", __func__, *hostp);
Damien Miller0faf7472013-10-17 11:47:23 +1100500 return NULL;
501}
502
Damien Miller95def091999-11-25 00:26:21 +1100503/*
markus@openbsd.org5467fbc2018-07-11 18:53:29 +0000504 * Check the result of hostkey loading, ignoring some errors and
505 * fatal()ing for others.
506 */
507static void
508check_load(int r, const char *path, const char *message)
509{
510 switch (r) {
511 case 0:
512 break;
513 case SSH_ERR_INTERNAL_ERROR:
514 case SSH_ERR_ALLOC_FAIL:
515 fatal("load %s \"%s\": %s", message, path, ssh_err(r));
516 case SSH_ERR_SYSTEM_ERROR:
517 /* Ignore missing files */
518 if (errno == ENOENT)
519 break;
520 /* FALLTHROUGH */
521 default:
522 error("load %s \"%s\": %s", message, path, ssh_err(r));
523 break;
524 }
525}
526
527/*
Damien Miller13f97b22014-02-24 15:57:55 +1100528 * Read per-user configuration file. Ignore the system wide config
529 * file if the user specifies a config file on the command line.
530 */
531static void
djm@openbsd.org9e34e0c2018-11-23 05:08:07 +0000532process_config_files(const char *host_name, struct passwd *pw, int final_pass,
533 int *want_final_pass)
Damien Miller13f97b22014-02-24 15:57:55 +1100534{
deraadt@openbsd.org087266e2015-01-20 23:14:00 +0000535 char buf[PATH_MAX];
Damien Miller13f97b22014-02-24 15:57:55 +1100536 int r;
537
538 if (config != NULL) {
539 if (strcasecmp(config, "none") != 0 &&
djm@openbsd.orgb7548b12017-10-23 05:08:00 +0000540 !read_config_file(config, pw, host, host_name, &options,
djm@openbsd.org9e34e0c2018-11-23 05:08:07 +0000541 SSHCONF_USERCONF | (final_pass ? SSHCONF_FINAL : 0),
542 want_final_pass))
Damien Miller13f97b22014-02-24 15:57:55 +1100543 fatal("Can't open user config file %.100s: "
544 "%.100s", config, strerror(errno));
545 } else {
546 r = snprintf(buf, sizeof buf, "%s/%s", pw->pw_dir,
547 _PATH_SSH_USER_CONFFILE);
548 if (r > 0 && (size_t)r < sizeof(buf))
djm@openbsd.orgb7548b12017-10-23 05:08:00 +0000549 (void)read_config_file(buf, pw, host, host_name,
djm@openbsd.org957fbce2014-10-08 22:20:25 +0000550 &options, SSHCONF_CHECKPERM | SSHCONF_USERCONF |
djm@openbsd.org9e34e0c2018-11-23 05:08:07 +0000551 (final_pass ? SSHCONF_FINAL : 0), want_final_pass);
Damien Miller13f97b22014-02-24 15:57:55 +1100552
553 /* Read systemwide configuration file after user config. */
djm@openbsd.org957fbce2014-10-08 22:20:25 +0000554 (void)read_config_file(_PATH_HOST_CONFIG_FILE, pw,
djm@openbsd.orgb7548b12017-10-23 05:08:00 +0000555 host, host_name, &options,
djm@openbsd.org9e34e0c2018-11-23 05:08:07 +0000556 final_pass ? SSHCONF_FINAL : 0, want_final_pass);
djm@openbsd.org957fbce2014-10-08 22:20:25 +0000557 }
558}
559
560/* Rewrite the port number in an addrinfo list of addresses */
561static void
562set_addrinfo_port(struct addrinfo *addrs, int port)
563{
564 struct addrinfo *addr;
565
566 for (addr = addrs; addr != NULL; addr = addr->ai_next) {
567 switch (addr->ai_family) {
568 case AF_INET:
569 ((struct sockaddr_in *)addr->ai_addr)->
570 sin_port = htons(port);
571 break;
572 case AF_INET6:
573 ((struct sockaddr_in6 *)addr->ai_addr)->
574 sin6_port = htons(port);
575 break;
576 }
Damien Miller13f97b22014-02-24 15:57:55 +1100577 }
578}
579
580/*
Damien Miller95def091999-11-25 00:26:21 +1100581 * Main program for the ssh client.
582 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000583int
584main(int ac, char **av)
585{
djm@openbsd.org95767262016-03-07 19:02:43 +0000586 struct ssh *ssh = NULL;
djm@openbsd.org643c2ad2017-08-12 06:46:01 +0000587 int i, r, opt, exit_status, use_syslog, direct, timeout_ms;
djm@openbsd.org9e34e0c2018-11-23 05:08:07 +0000588 int was_addr, config_test = 0, opt_terminated = 0, want_final_pass = 0;
djm@openbsd.orgb7548b12017-10-23 05:08:00 +0000589 char *p, *cp, *line, *argv0, buf[PATH_MAX], *logfile;
590 char cname[NI_MAXHOST];
Damien Miller95def091999-11-25 00:26:21 +1100591 struct stat st;
Ben Lindstrom086cf212001-03-05 05:56:40 +0000592 struct passwd *pw;
Ben Lindstrom5ccf63a2001-09-24 20:00:10 +0000593 extern int optind, optreset;
Damien Miller4f8e6692001-07-14 13:22:53 +1000594 extern char *optarg;
Damien Miller7acefbb2014-07-18 14:11:24 +1000595 struct Forward fwd;
Damien Miller0faf7472013-10-17 11:47:23 +1100596 struct addrinfo *addrs = NULL;
Damien Miller9c386432014-07-03 21:27:46 +1000597 struct ssh_digest_ctx *md;
598 u_char conn_hash[SSH_DIGEST_MAX_LENGTH];
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000599
dtucker@openbsd.orgffb1e7e2016-02-15 09:47:49 +0000600 ssh_malloc_init(); /* must be called before any mallocs */
Darren Tuckerce321d82005-10-03 18:11:24 +1000601 /* Ensure that fds 0, 1 and 2 are open or directed to /dev/null */
602 sanitise_stdfd();
603
Damien Miller59d3d5b2003-08-22 09:34:41 +1000604 __progname = ssh_get_progname(av[0]);
Damien Millerf9b625c2000-07-09 22:42:32 +1000605
Damien Millerea2c1a42011-06-03 12:10:22 +1000606#ifndef HAVE_SETPROCTITLE
607 /* Prepare for later setproctitle emulation */
608 /* Save argv so it isn't clobbered by setproctitle() emulation */
609 saved_av = xcalloc(ac + 1, sizeof(*saved_av));
610 for (i = 0; i < ac; i++)
611 saved_av[i] = xstrdup(av[i]);
612 saved_av[i] = NULL;
613 compat_init_setproctitle(ac, av);
614 av = saved_av;
615#endif
616
Damien Miller42c5ec42018-11-23 10:40:06 +1100617 seed_rng();
618
Damien Miller5428f641999-11-25 11:54:57 +1100619 /*
Damien Miller00d9ae22010-08-17 01:59:31 +1000620 * Discard other fds that are hanging around. These can cause problem
621 * with backgrounded ssh processes started by ControlPersist.
622 */
623 closefrom(STDERR_FILENO + 1);
624
Ben Lindstrom3fcf1a22001-04-08 18:26:59 +0000625 /* Get user data. */
dtucker@openbsd.orge655ee02018-07-27 05:34:42 +0000626 pw = getpwuid(getuid());
Ben Lindstrom3fcf1a22001-04-08 18:26:59 +0000627 if (!pw) {
dtucker@openbsd.orge655ee02018-07-27 05:34:42 +0000628 logit("No user exists for uid %lu", (u_long)getuid());
Darren Tuckere9a9b712005-12-20 16:15:51 +1100629 exit(255);
Ben Lindstrom3fcf1a22001-04-08 18:26:59 +0000630 }
631 /* Take a copy of the returned structure. */
632 pw = pwcopy(pw);
633
Damien Miller5428f641999-11-25 11:54:57 +1100634 /*
Damien Miller5428f641999-11-25 11:54:57 +1100635 * Set our umask to something reasonable, as some files are created
636 * with the default umask. This will make them world-readable but
637 * writable only by the owner, which is ok for all files for which we
638 * don't set the modes explicitly.
639 */
Damien Miller95def091999-11-25 00:26:21 +1100640 umask(022);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000641
Damien Millerdda78a02016-12-12 13:57:10 +1100642 msetlocale();
djm@openbsd.org65c6c6b2016-07-17 04:20:16 +0000643
Darren Tuckerd6173c02008-06-13 04:52:53 +1000644 /*
645 * Initialize option structure to indicate that no values have been
646 * set.
647 */
Damien Miller95def091999-11-25 00:26:21 +1100648 initialize_options(&options);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000649
djm@openbsd.orgdbee4112017-09-12 06:32:07 +0000650 /*
651 * Prepare main ssh transport/connection structures
652 */
653 if ((ssh = ssh_alloc_session_state()) == NULL)
654 fatal("Couldn't allocate session state");
djm@openbsd.org25b2ed62019-01-19 21:36:06 +0000655 active_state = ssh; /* XXX */
djm@openbsd.orgdbee4112017-09-12 06:32:07 +0000656 channel_init_channels(ssh);
djm@openbsd.orgdbee4112017-09-12 06:32:07 +0000657
Damien Miller95def091999-11-25 00:26:21 +1100658 /* Parse command-line arguments. */
659 host = NULL;
Damien Millere272a5b2008-11-03 19:22:37 +1100660 use_syslog = 0;
Damien Miller03d4d7e2013-04-23 15:21:06 +1000661 logfile = NULL;
Darren Tucker72efd742009-06-21 17:48:00 +1000662 argv0 = av[0];
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000663
Damien Miller2ecb6bd2006-03-15 12:03:53 +1100664 again:
Darren Tuckerd6173c02008-06-13 04:52:53 +1000665 while ((opt = getopt(ac, av, "1246ab:c:e:fgi:kl:m:no:p:qstvx"
djm@openbsd.orgac2e3022018-02-23 02:34:33 +0000666 "AB:CD:E:F:GI:J:KL:MNO:PQ:R:S:TVw:W:XYy")) != -1) {
Damien Miller95def091999-11-25 00:26:21 +1100667 switch (opt) {
Ben Lindstrom1e7d3062001-02-09 02:36:43 +0000668 case '1':
djm@openbsd.org99f95ba2017-04-30 23:11:45 +0000669 fatal("SSH protocol v.1 is no longer supported");
Ben Lindstrom1e7d3062001-02-09 02:36:43 +0000670 break;
Damien Miller4af51302000-04-16 11:18:38 +1000671 case '2':
djm@openbsd.org99f95ba2017-04-30 23:11:45 +0000672 /* Ignored */
Damien Miller4af51302000-04-16 11:18:38 +1000673 break;
Damien Miller34132e52000-01-14 15:45:46 +1100674 case '4':
Darren Tucker0a4f04b2003-07-03 20:37:47 +1000675 options.address_family = AF_INET;
Damien Miller34132e52000-01-14 15:45:46 +1100676 break;
Damien Miller34132e52000-01-14 15:45:46 +1100677 case '6':
Darren Tucker0a4f04b2003-07-03 20:37:47 +1000678 options.address_family = AF_INET6;
Damien Miller34132e52000-01-14 15:45:46 +1100679 break;
Damien Miller95def091999-11-25 00:26:21 +1100680 case 'n':
681 stdin_null_flag = 1;
682 break;
Damien Miller95def091999-11-25 00:26:21 +1100683 case 'f':
684 fork_after_authentication_flag = 1;
685 stdin_null_flag = 1;
686 break;
Damien Miller95def091999-11-25 00:26:21 +1100687 case 'x':
688 options.forward_x11 = 0;
689 break;
Damien Miller95def091999-11-25 00:26:21 +1100690 case 'X':
691 options.forward_x11 = 1;
692 break;
Damien Millere272a5b2008-11-03 19:22:37 +1100693 case 'y':
694 use_syslog = 1;
695 break;
Damien Miller03d4d7e2013-04-23 15:21:06 +1000696 case 'E':
dtucker@openbsd.org4f7cc2f2015-09-04 08:21:47 +0000697 logfile = optarg;
Damien Miller03d4d7e2013-04-23 15:21:06 +1000698 break;
djm@openbsd.org957fbce2014-10-08 22:20:25 +0000699 case 'G':
700 config_test = 1;
701 break;
Darren Tucker0a118da2003-10-15 15:54:32 +1000702 case 'Y':
703 options.forward_x11 = 1;
704 options.forward_x11_trusted = 1;
705 break;
Damien Miller95def091999-11-25 00:26:21 +1100706 case 'g':
Damien Miller7acefbb2014-07-18 14:11:24 +1000707 options.fwd_opts.gateway_ports = 1;
Damien Miller95def091999-11-25 00:26:21 +1100708 break;
Darren Tucker7ebfc102004-11-07 20:06:19 +1100709 case 'O':
dtucker@openbsd.org8543ff32016-06-03 03:14:41 +0000710 if (options.stdio_forward_host != NULL)
Damien Millere1537f92010-01-26 13:26:22 +1100711 fatal("Cannot specify multiplexing "
712 "command with -W");
713 else if (muxclient_command != 0)
714 fatal("Multiplexing command already specified");
Darren Tucker7ebfc102004-11-07 20:06:19 +1100715 if (strcmp(optarg, "check") == 0)
Damien Millerb1cbfa22008-05-19 16:00:08 +1000716 muxclient_command = SSHMUX_COMMAND_ALIVE_CHECK;
Damien Miller388f6fc2010-05-21 14:57:35 +1000717 else if (strcmp(optarg, "forward") == 0)
718 muxclient_command = SSHMUX_COMMAND_FORWARD;
Darren Tucker7ebfc102004-11-07 20:06:19 +1100719 else if (strcmp(optarg, "exit") == 0)
Damien Millerb1cbfa22008-05-19 16:00:08 +1000720 muxclient_command = SSHMUX_COMMAND_TERMINATE;
Damien Miller6c3eec72011-05-05 14:16:22 +1000721 else if (strcmp(optarg, "stop") == 0)
722 muxclient_command = SSHMUX_COMMAND_STOP;
Damien Millerf6dff7c2011-09-22 21:38:52 +1000723 else if (strcmp(optarg, "cancel") == 0)
724 muxclient_command = SSHMUX_COMMAND_CANCEL_FWD;
markus@openbsd.org8d057842016-09-30 09:19:13 +0000725 else if (strcmp(optarg, "proxy") == 0)
726 muxclient_command = SSHMUX_COMMAND_PROXY;
Darren Tucker7ebfc102004-11-07 20:06:19 +1100727 else
728 fatal("Invalid multiplex command.");
729 break;
Damien Miller147bba32002-09-04 16:46:06 +1000730 case 'P': /* deprecated */
Damien Miller95def091999-11-25 00:26:21 +1100731 break;
Damien Millerd937dc02013-12-05 10:19:54 +1100732 case 'Q':
Damien Millerea111192013-04-23 19:24:32 +1000733 cp = NULL;
Damien Millerd937dc02013-12-05 10:19:54 +1100734 if (strcmp(optarg, "cipher") == 0)
Damien Miller0fde8ac2013-11-21 14:12:23 +1100735 cp = cipher_alg_list('\n', 0);
Damien Millerd937dc02013-12-05 10:19:54 +1100736 else if (strcmp(optarg, "cipher-auth") == 0)
Damien Miller0fde8ac2013-11-21 14:12:23 +1100737 cp = cipher_alg_list('\n', 1);
Damien Millerd937dc02013-12-05 10:19:54 +1100738 else if (strcmp(optarg, "mac") == 0)
Damien Miller690d9892013-11-08 12:16:49 +1100739 cp = mac_alg_list('\n');
Damien Millerd937dc02013-12-05 10:19:54 +1100740 else if (strcmp(optarg, "kex") == 0)
Damien Miller690d9892013-11-08 12:16:49 +1100741 cp = kex_alg_list('\n');
Damien Millerd937dc02013-12-05 10:19:54 +1100742 else if (strcmp(optarg, "key") == 0)
djm@openbsd.org183ba552017-03-10 04:07:20 +0000743 cp = sshkey_alg_list(0, 0, 0, '\n');
Damien Miller5be9d9e2013-12-07 11:24:01 +1100744 else if (strcmp(optarg, "key-cert") == 0)
djm@openbsd.org183ba552017-03-10 04:07:20 +0000745 cp = sshkey_alg_list(1, 0, 0, '\n');
Damien Miller5be9d9e2013-12-07 11:24:01 +1100746 else if (strcmp(optarg, "key-plain") == 0)
djm@openbsd.org183ba552017-03-10 04:07:20 +0000747 cp = sshkey_alg_list(0, 1, 0, '\n');
djm@openbsd.org357128a2018-09-12 01:30:10 +0000748 else if (strcmp(optarg, "sig") == 0)
djm@openbsd.orgaa083aa2018-09-20 03:31:49 +0000749 cp = sshkey_alg_list(0, 1, 1, '\n');
djm@openbsd.org357128a2018-09-12 01:30:10 +0000750 else if (strcmp(optarg, "protocol-version") == 0)
djm@openbsd.org68d2dfc2015-03-03 06:48:58 +0000751 cp = xstrdup("2");
djm@openbsd.org357128a2018-09-12 01:30:10 +0000752 else if (strcmp(optarg, "help") == 0) {
753 cp = xstrdup(
754 "cipher\ncipher-auth\nkex\nkey\n"
755 "key-cert\nkey-plain\nmac\n"
756 "protocol-version\nsig");
djm@openbsd.org68d2dfc2015-03-03 06:48:58 +0000757 }
Damien Millerea111192013-04-23 19:24:32 +1000758 if (cp == NULL)
759 fatal("Unsupported query \"%s\"", optarg);
760 printf("%s\n", cp);
761 free(cp);
762 exit(0);
763 break;
Damien Miller95def091999-11-25 00:26:21 +1100764 case 'a':
765 options.forward_agent = 0;
766 break;
Damien Millerb1715dc2000-05-30 13:44:51 +1000767 case 'A':
768 options.forward_agent = 1;
769 break;
Damien Miller95def091999-11-25 00:26:21 +1100770 case 'k':
Damien Millere0113cc2003-11-24 13:10:09 +1100771 options.gss_deleg_creds = 0;
Damien Miller95def091999-11-25 00:26:21 +1100772 break;
Darren Tucker415bddc2007-06-12 23:43:16 +1000773 case 'K':
774 options.gss_authentication = 1;
775 options.gss_deleg_creds = 1;
776 break;
Damien Miller95def091999-11-25 00:26:21 +1100777 case 'i':
dtucker@openbsd.orge655ee02018-07-27 05:34:42 +0000778 p = tilde_expand_filename(optarg, getuid());
dtucker@openbsd.org03239c12015-10-25 23:42:00 +0000779 if (stat(p, &st) < 0)
Damien Millerf4614452001-07-14 12:18:10 +1000780 fprintf(stderr, "Warning: Identity file %s "
dtucker@openbsd.org03239c12015-10-25 23:42:00 +0000781 "not accessible: %s.\n", p,
Damien Miller3eb48b62005-03-01 21:15:46 +1100782 strerror(errno));
dtucker@openbsd.org03239c12015-10-25 23:42:00 +0000783 else
784 add_identity_file(&options, NULL, p, 1);
785 free(p);
Damien Miller95def091999-11-25 00:26:21 +1100786 break;
Ben Lindstromc5b68002001-07-04 04:52:03 +0000787 case 'I':
Damien Miller7ea845e2010-02-12 09:21:02 +1100788#ifdef ENABLE_PKCS11
dtucker@openbsd.org4f7cc2f2015-09-04 08:21:47 +0000789 free(options.pkcs11_provider);
Damien Miller7ea845e2010-02-12 09:21:02 +1100790 options.pkcs11_provider = xstrdup(optarg);
Ben Lindstrombcc18082001-08-06 21:59:25 +0000791#else
Damien Miller7ea845e2010-02-12 09:21:02 +1100792 fprintf(stderr, "no support for PKCS#11.\n");
Ben Lindstrombcc18082001-08-06 21:59:25 +0000793#endif
Ben Lindstromc5b68002001-07-04 04:52:03 +0000794 break;
djm@openbsd.orged877ef2016-07-15 00:24:30 +0000795 case 'J':
796 if (options.jump_host != NULL)
797 fatal("Only a single -J option permitted");
798 if (options.proxy_command != NULL)
799 fatal("Cannot specify -J with ProxyCommand");
800 if (parse_jump(optarg, &options, 1) == -1)
801 fatal("Invalid -J argument");
802 options.proxy_command = xstrdup("none");
803 break;
Damien Miller95def091999-11-25 00:26:21 +1100804 case 't':
Damien Miller21771e22011-05-15 08:45:50 +1000805 if (options.request_tty == REQUEST_TTY_YES)
806 options.request_tty = REQUEST_TTY_FORCE;
807 else
808 options.request_tty = REQUEST_TTY_YES;
Damien Miller95def091999-11-25 00:26:21 +1100809 break;
Damien Miller95def091999-11-25 00:26:21 +1100810 case 'v':
Darren Tuckere98dfa32003-07-19 19:54:31 +1000811 if (debug_flag == 0) {
Damien Millere4340be2000-09-16 13:29:08 +1100812 debug_flag = 1;
813 options.log_level = SYSLOG_LEVEL_DEBUG1;
Darren Tuckere98dfa32003-07-19 19:54:31 +1000814 } else {
djm@openbsd.orged877ef2016-07-15 00:24:30 +0000815 if (options.log_level < SYSLOG_LEVEL_DEBUG3) {
816 debug_flag++;
Darren Tuckere98dfa32003-07-19 19:54:31 +1000817 options.log_level++;
djm@openbsd.orged877ef2016-07-15 00:24:30 +0000818 }
Darren Tuckere98dfa32003-07-19 19:54:31 +1000819 }
Damien Miller03d4d7e2013-04-23 15:21:06 +1000820 break;
Damien Miller95def091999-11-25 00:26:21 +1100821 case 'V':
Damien Miller0c889cd2004-03-22 09:36:00 +1100822 fprintf(stderr, "%s, %s\n",
Damien Miller1f0311c2014-05-15 14:24:09 +1000823 SSH_RELEASE,
824#ifdef WITH_OPENSSL
djm@openbsd.orga65784c2018-10-23 05:56:35 +0000825 OpenSSL_version(OPENSSL_VERSION)
Damien Miller1f0311c2014-05-15 14:24:09 +1000826#else
827 "without OpenSSL"
828#endif
829 );
Damien Miller95def091999-11-25 00:26:21 +1100830 if (opt == 'V')
831 exit(0);
Damien Miller95def091999-11-25 00:26:21 +1100832 break;
Damien Millerd27b9472005-12-13 19:29:02 +1100833 case 'w':
Damien Miller7b58e802005-12-13 19:33:19 +1100834 if (options.tun_open == -1)
835 options.tun_open = SSH_TUNMODE_DEFAULT;
Damien Millerd27b9472005-12-13 19:29:02 +1100836 options.tun_local = a2tun(optarg, &options.tun_remote);
Damien Miller7b58e802005-12-13 19:33:19 +1100837 if (options.tun_local == SSH_TUNID_ERR) {
Darren Tuckerd6173c02008-06-13 04:52:53 +1000838 fprintf(stderr,
839 "Bad tun device '%s'\n", optarg);
Darren Tuckere9a9b712005-12-20 16:15:51 +1100840 exit(255);
Damien Millerd27b9472005-12-13 19:29:02 +1100841 }
842 break;
Darren Tucker7ad8dd22010-01-12 19:40:27 +1100843 case 'W':
dtucker@openbsd.org8543ff32016-06-03 03:14:41 +0000844 if (options.stdio_forward_host != NULL)
Damien Millere1537f92010-01-26 13:26:22 +1100845 fatal("stdio forward already specified");
846 if (muxclient_command != 0)
847 fatal("Cannot specify stdio forward with -O");
Darren Tucker7ad8dd22010-01-12 19:40:27 +1100848 if (parse_forward(&fwd, optarg, 1, 0)) {
dtucker@openbsd.org8543ff32016-06-03 03:14:41 +0000849 options.stdio_forward_host = fwd.listen_host;
850 options.stdio_forward_port = fwd.listen_port;
Darren Tuckera627d422013-06-02 07:31:17 +1000851 free(fwd.connect_host);
Darren Tucker7ad8dd22010-01-12 19:40:27 +1100852 } else {
853 fprintf(stderr,
854 "Bad stdio forwarding specification '%s'\n",
855 optarg);
856 exit(255);
857 }
Damien Miller21771e22011-05-15 08:45:50 +1000858 options.request_tty = REQUEST_TTY_NO;
Darren Tucker7ad8dd22010-01-12 19:40:27 +1100859 no_shell_flag = 1;
Darren Tucker7ad8dd22010-01-12 19:40:27 +1100860 break;
Damien Miller95def091999-11-25 00:26:21 +1100861 case 'q':
862 options.log_level = SYSLOG_LEVEL_QUIET;
863 break;
Damien Miller95def091999-11-25 00:26:21 +1100864 case 'e':
865 if (optarg[0] == '^' && optarg[2] == 0 &&
Damien Millerf4614452001-07-14 12:18:10 +1000866 (u_char) optarg[1] >= 64 &&
867 (u_char) optarg[1] < 128)
Ben Lindstrom46c16222000-12-22 01:43:59 +0000868 options.escape_char = (u_char) optarg[1] & 31;
Damien Miller95def091999-11-25 00:26:21 +1100869 else if (strlen(optarg) == 1)
Ben Lindstrom46c16222000-12-22 01:43:59 +0000870 options.escape_char = (u_char) optarg[0];
Damien Miller95def091999-11-25 00:26:21 +1100871 else if (strcmp(optarg, "none") == 0)
Ben Lindstrom2b1f71b2001-06-05 20:32:21 +0000872 options.escape_char = SSH_ESCAPECHAR_NONE;
Damien Miller95def091999-11-25 00:26:21 +1100873 else {
Damien Millerf4614452001-07-14 12:18:10 +1000874 fprintf(stderr, "Bad escape character '%s'.\n",
875 optarg);
Darren Tuckere9a9b712005-12-20 16:15:51 +1100876 exit(255);
Damien Miller95def091999-11-25 00:26:21 +1100877 }
878 break;
Damien Miller95def091999-11-25 00:26:21 +1100879 case 'c':
djm@openbsd.orgcdccebd2017-04-30 23:15:04 +0000880 if (!ciphers_valid(*optarg == '+' ?
djm@openbsd.orgf9eca242015-07-30 00:01:34 +0000881 optarg + 1 : optarg)) {
djm@openbsd.orgf9eca242015-07-30 00:01:34 +0000882 fprintf(stderr, "Unknown cipher type '%s'\n",
883 optarg);
884 exit(255);
885 }
djm@openbsd.orgcdccebd2017-04-30 23:15:04 +0000886 free(options.ciphers);
887 options.ciphers = xstrdup(optarg);
Damien Miller95def091999-11-25 00:26:21 +1100888 break;
Ben Lindstrom06b33aa2001-02-15 03:01:59 +0000889 case 'm':
dtucker@openbsd.org4f7cc2f2015-09-04 08:21:47 +0000890 if (mac_valid(optarg)) {
891 free(options.macs);
Ben Lindstrom06b33aa2001-02-15 03:01:59 +0000892 options.macs = xstrdup(optarg);
dtucker@openbsd.org4f7cc2f2015-09-04 08:21:47 +0000893 } else {
Damien Millerf4614452001-07-14 12:18:10 +1000894 fprintf(stderr, "Unknown mac type '%s'\n",
895 optarg);
Darren Tuckere9a9b712005-12-20 16:15:51 +1100896 exit(255);
Ben Lindstrom06b33aa2001-02-15 03:01:59 +0000897 }
898 break;
Damien Miller0e220db2004-06-15 10:34:08 +1000899 case 'M':
Damien Millerd14b1e72005-06-16 13:19:41 +1000900 if (options.control_master == SSHCTL_MASTER_YES)
901 options.control_master = SSHCTL_MASTER_ASK;
902 else
903 options.control_master = SSHCTL_MASTER_YES;
Damien Miller0e220db2004-06-15 10:34:08 +1000904 break;
Damien Miller95def091999-11-25 00:26:21 +1100905 case 'p':
millert@openbsd.org887669e2017-10-21 23:06:24 +0000906 if (options.port == -1) {
907 options.port = a2port(optarg);
908 if (options.port <= 0) {
909 fprintf(stderr, "Bad port '%s'\n",
910 optarg);
911 exit(255);
912 }
Ben Lindstrom146edb92001-04-11 23:06:28 +0000913 }
Damien Miller95def091999-11-25 00:26:21 +1100914 break;
Damien Miller95def091999-11-25 00:26:21 +1100915 case 'l':
millert@openbsd.org887669e2017-10-21 23:06:24 +0000916 if (options.user == NULL)
917 options.user = optarg;
Damien Miller95def091999-11-25 00:26:21 +1100918 break;
Ben Lindstrom1a174712001-09-12 17:56:15 +0000919
Damien Miller95def091999-11-25 00:26:21 +1100920 case 'L':
Damien Miller4bf648f2009-02-14 16:28:21 +1100921 if (parse_forward(&fwd, optarg, 0, 0))
Damien Millerf91ee4c2005-03-01 21:24:33 +1100922 add_local_forward(&options, &fwd);
923 else {
Damien Millerf4614452001-07-14 12:18:10 +1000924 fprintf(stderr,
Damien Millerf91ee4c2005-03-01 21:24:33 +1100925 "Bad local forwarding specification '%s'\n",
Damien Millerf4614452001-07-14 12:18:10 +1000926 optarg);
Darren Tuckere9a9b712005-12-20 16:15:51 +1100927 exit(255);
Ben Lindstrom1a174712001-09-12 17:56:15 +0000928 }
Damien Millerf91ee4c2005-03-01 21:24:33 +1100929 break;
930
931 case 'R':
markus@openbsd.org609d7a62017-09-21 19:16:53 +0000932 if (parse_forward(&fwd, optarg, 0, 1) ||
933 parse_forward(&fwd, optarg, 1, 1)) {
Damien Millerf91ee4c2005-03-01 21:24:33 +1100934 add_remote_forward(&options, &fwd);
935 } else {
936 fprintf(stderr,
937 "Bad remote forwarding specification "
938 "'%s'\n", optarg);
Darren Tuckere9a9b712005-12-20 16:15:51 +1100939 exit(255);
Damien Millerf91ee4c2005-03-01 21:24:33 +1100940 }
Damien Miller95def091999-11-25 00:26:21 +1100941 break;
Ben Lindstrom3bb4f9d2001-04-08 18:30:26 +0000942
943 case 'D':
Damien Miller4bf648f2009-02-14 16:28:21 +1100944 if (parse_forward(&fwd, optarg, 1, 0)) {
Damien Millera699d952008-11-03 19:27:34 +1100945 add_local_forward(&options, &fwd);
Damien Millerf91ee4c2005-03-01 21:24:33 +1100946 } else {
Damien Millera699d952008-11-03 19:27:34 +1100947 fprintf(stderr,
948 "Bad dynamic forwarding specification "
949 "'%s'\n", optarg);
Darren Tuckere9a9b712005-12-20 16:15:51 +1100950 exit(255);
Ben Lindstrom146edb92001-04-11 23:06:28 +0000951 }
Ben Lindstrom3bb4f9d2001-04-08 18:30:26 +0000952 break;
953
Damien Miller95def091999-11-25 00:26:21 +1100954 case 'C':
955 options.compression = 1;
956 break;
Damien Miller1383bd82000-04-06 12:32:37 +1000957 case 'N':
958 no_shell_flag = 1;
Damien Miller21771e22011-05-15 08:45:50 +1000959 options.request_tty = REQUEST_TTY_NO;
Damien Miller1383bd82000-04-06 12:32:37 +1000960 break;
Damien Miller1383bd82000-04-06 12:32:37 +1000961 case 'T':
Damien Miller21771e22011-05-15 08:45:50 +1000962 options.request_tty = REQUEST_TTY_NO;
Damien Miller1383bd82000-04-06 12:32:37 +1000963 break;
Damien Miller95def091999-11-25 00:26:21 +1100964 case 'o':
Damien Miller9836cf82003-12-17 16:30:06 +1100965 line = xstrdup(optarg);
djm@openbsd.org957fbce2014-10-08 22:20:25 +0000966 if (process_config_line(&options, pw,
967 host ? host : "", host ? host : "", line,
968 "command-line", 0, NULL, SSHCONF_USERCONF) != 0)
Darren Tuckere9a9b712005-12-20 16:15:51 +1100969 exit(255);
Darren Tuckera627d422013-06-02 07:31:17 +1000970 free(line);
Damien Miller95def091999-11-25 00:26:21 +1100971 break;
Damien Miller832562e2001-01-30 09:30:01 +1100972 case 's':
973 subsystem_flag = 1;
974 break;
Damien Miller0e220db2004-06-15 10:34:08 +1000975 case 'S':
mmcc@openbsd.orgd59ce082015-12-10 17:08:40 +0000976 free(options.control_path);
Damien Miller0e220db2004-06-15 10:34:08 +1000977 options.control_path = xstrdup(optarg);
Damien Miller0e220db2004-06-15 10:34:08 +1000978 break;
Ben Lindstrome0f88042001-04-30 13:06:24 +0000979 case 'b':
980 options.bind_address = optarg;
981 break;
djm@openbsd.orgac2e3022018-02-23 02:34:33 +0000982 case 'B':
983 options.bind_interface = optarg;
984 break;
Ben Lindstrom14f31ab2001-09-12 17:48:04 +0000985 case 'F':
986 config = optarg;
987 break;
Damien Miller95def091999-11-25 00:26:21 +1100988 default:
989 usage();
990 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000991 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000992
djm@openbsd.org643c2ad2017-08-12 06:46:01 +0000993 if (optind > 1 && strcmp(av[optind - 1], "--") == 0)
994 opt_terminated = 1;
995
Damien Millerf4614452001-07-14 12:18:10 +1000996 ac -= optind;
997 av += optind;
998
Darren Tuckerb8c884a2010-01-08 18:53:43 +1100999 if (ac > 0 && !host) {
millert@openbsd.org887669e2017-10-21 23:06:24 +00001000 int tport;
1001 char *tuser;
1002 switch (parse_ssh_uri(*av, &tuser, &host, &tport)) {
1003 case -1:
1004 usage();
1005 break;
1006 case 0:
1007 if (options.user == NULL) {
1008 options.user = tuser;
1009 tuser = NULL;
1010 }
1011 free(tuser);
1012 if (options.port == -1 && tport != -1)
1013 options.port = tport;
1014 break;
1015 default:
Damien Millerf4614452001-07-14 12:18:10 +10001016 p = xstrdup(*av);
Ben Lindstromc276c122002-12-23 02:14:51 +00001017 cp = strrchr(p, '@');
millert@openbsd.org887669e2017-10-21 23:06:24 +00001018 if (cp != NULL) {
1019 if (cp == p)
1020 usage();
1021 if (options.user == NULL) {
1022 options.user = p;
1023 p = NULL;
1024 }
1025 *cp++ = '\0';
1026 host = xstrdup(cp);
1027 free(p);
1028 } else
1029 host = p;
1030 break;
1031 }
djm@openbsd.org643c2ad2017-08-12 06:46:01 +00001032 if (ac > 1 && !opt_terminated) {
Ben Lindstromb9fa6912002-12-23 02:24:54 +00001033 optind = optreset = 1;
Damien Millerf4614452001-07-14 12:18:10 +10001034 goto again;
1035 }
Ben Lindstromb9fa6912002-12-23 02:24:54 +00001036 ac--, av++;
Damien Millerf4614452001-07-14 12:18:10 +10001037 }
1038
Damien Miller95def091999-11-25 00:26:21 +11001039 /* Check that we got a host name. */
1040 if (!host)
1041 usage();
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001042
Damien Miller0faf7472013-10-17 11:47:23 +11001043 host_arg = xstrdup(host);
1044
Damien Miller95def091999-11-25 00:26:21 +11001045 /* Initialize the command to execute on remote host. */
markus@openbsd.orgcecee2d2018-07-09 21:03:30 +00001046 if ((command = sshbuf_new()) == NULL)
1047 fatal("sshbuf_new failed");
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001048
Damien Miller5428f641999-11-25 11:54:57 +11001049 /*
1050 * Save the command to execute on the remote host in a buffer. There
1051 * is no limit on the length of the command, except by the maximum
1052 * packet size. Also sets the tty flag if there is no command.
1053 */
Damien Millerf4614452001-07-14 12:18:10 +10001054 if (!ac) {
Damien Miller95def091999-11-25 00:26:21 +11001055 /* No command specified - execute shell on a tty. */
Damien Miller832562e2001-01-30 09:30:01 +11001056 if (subsystem_flag) {
Damien Millerf4614452001-07-14 12:18:10 +10001057 fprintf(stderr,
1058 "You must specify a subsystem to invoke.\n");
Damien Miller832562e2001-01-30 09:30:01 +11001059 usage();
1060 }
Damien Miller95def091999-11-25 00:26:21 +11001061 } else {
Damien Millerf4614452001-07-14 12:18:10 +10001062 /* A command has been specified. Store it into the buffer. */
1063 for (i = 0; i < ac; i++) {
markus@openbsd.orgcecee2d2018-07-09 21:03:30 +00001064 if ((r = sshbuf_putf(command, "%s%s",
1065 i ? " " : "", av[i])) != 0)
1066 fatal("%s: buffer error: %s",
1067 __func__, ssh_err(r));
Damien Miller95def091999-11-25 00:26:21 +11001068 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001069 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001070
Ben Lindstrom8a432f52001-03-05 07:24:46 +00001071 /*
1072 * Initialize "log" output. Since we are the client all output
Damien Miller03d4d7e2013-04-23 15:21:06 +10001073 * goes to stderr unless otherwise specified by -y or -E.
Ben Lindstrom8a432f52001-03-05 07:24:46 +00001074 */
Damien Miller03d4d7e2013-04-23 15:21:06 +10001075 if (use_syslog && logfile != NULL)
1076 fatal("Can't specify both -y and -E");
dtucker@openbsd.org4f7cc2f2015-09-04 08:21:47 +00001077 if (logfile != NULL)
Damien Miller03d4d7e2013-04-23 15:21:06 +10001078 log_redirect_stderr_to(logfile);
Darren Tucker72efd742009-06-21 17:48:00 +10001079 log_init(argv0,
djm@openbsd.org@openbsd.orgdbe06622017-10-27 01:57:06 +00001080 options.log_level == SYSLOG_LEVEL_NOT_SET ?
dtucker@openbsd.org68d3a2a2017-04-28 03:20:27 +00001081 SYSLOG_LEVEL_INFO : options.log_level,
djm@openbsd.org@openbsd.orgdbe06622017-10-27 01:57:06 +00001082 options.log_facility == SYSLOG_FACILITY_NOT_SET ?
dtucker@openbsd.org68d3a2a2017-04-28 03:20:27 +00001083 SYSLOG_FACILITY_USER : options.log_facility,
1084 !use_syslog);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001085
Damien Miller03d4d7e2013-04-23 15:21:06 +10001086 if (debug_flag)
Damien Miller1f0311c2014-05-15 14:24:09 +10001087 logit("%s, %s", SSH_RELEASE,
1088#ifdef WITH_OPENSSL
djm@openbsd.orga65784c2018-10-23 05:56:35 +00001089 OpenSSL_version(OPENSSL_VERSION)
Damien Miller1f0311c2014-05-15 14:24:09 +10001090#else
1091 "without OpenSSL"
1092#endif
1093 );
Damien Miller03d4d7e2013-04-23 15:21:06 +10001094
Damien Miller13f97b22014-02-24 15:57:55 +11001095 /* Parse the configuration files */
djm@openbsd.org9e34e0c2018-11-23 05:08:07 +00001096 process_config_files(host_arg, pw, 0, &want_final_pass);
1097 if (want_final_pass)
1098 debug("configuration requests final Match pass");
Ben Lindstrom83f07d12001-10-03 17:22:29 +00001099
Damien Miller13f97b22014-02-24 15:57:55 +11001100 /* Hostname canonicalisation needs a few options filled. */
1101 fill_default_options_for_canonicalization(&options);
1102
1103 /* If the user has replaced the hostname then take it into use now */
1104 if (options.hostname != NULL) {
1105 /* NB. Please keep in sync with readconf.c:match_cfg_line() */
1106 cp = percent_expand(options.hostname,
1107 "h", host, (char *)NULL);
1108 free(host);
1109 host = cp;
djm@openbsd.org957fbce2014-10-08 22:20:25 +00001110 free(options.hostname);
1111 options.hostname = xstrdup(host);
Damien Miller13f97b22014-02-24 15:57:55 +11001112 }
1113
djm@openbsd.orgfc21ea92018-01-23 05:06:25 +00001114 /* Don't lowercase addresses, they will be explicitly canonicalised */
1115 if ((was_addr = is_addr(host)) == 0)
1116 lowercase(host);
1117
1118 /*
1119 * Try to canonicalize if requested by configuration or the
1120 * hostname is an address.
1121 */
1122 if (options.canonicalize_hostname != SSH_CANONICALISE_NO || was_addr)
Damien Miller13f97b22014-02-24 15:57:55 +11001123 addrs = resolve_canonicalize(&host, options.port);
1124
1125 /*
Damien Miller08b57c62014-02-27 10:17:13 +11001126 * If CanonicalizePermittedCNAMEs have been specified but
1127 * other canonicalization did not happen (by not being requested
1128 * or by failing with fallback) then the hostname may still be changed
djm@openbsd.org@openbsd.orgdbe06622017-10-27 01:57:06 +00001129 * as a result of CNAME following.
Damien Miller08b57c62014-02-27 10:17:13 +11001130 *
1131 * Try to resolve the bare hostname name using the system resolver's
1132 * usual search rules and then apply the CNAME follow rules.
1133 *
1134 * Skip the lookup if a ProxyCommand is being used unless the user
1135 * has specifically requested canonicalisation for this case via
1136 * CanonicalizeHostname=always
Damien Miller13f97b22014-02-24 15:57:55 +11001137 */
djm@openbsd.orged877ef2016-07-15 00:24:30 +00001138 direct = option_clear_or_none(options.proxy_command) &&
1139 options.jump_host == NULL;
1140 if (addrs == NULL && options.num_permitted_cnames != 0 && (direct ||
1141 options.canonicalize_hostname == SSH_CANONICALISE_ALWAYS)) {
Damien Miller19439e92014-07-02 15:28:40 +10001142 if ((addrs = resolve_host(host, options.port,
djm@openbsd.org383a33d2018-09-21 03:11:36 +00001143 direct, cname, sizeof(cname))) == NULL) {
Damien Miller19439e92014-07-02 15:28:40 +10001144 /* Don't fatal proxied host names not in the DNS */
djm@openbsd.org383a33d2018-09-21 03:11:36 +00001145 if (direct)
Damien Miller19439e92014-07-02 15:28:40 +10001146 cleanup_exit(255); /* logged in resolve_host */
1147 } else
djm@openbsd.orged877ef2016-07-15 00:24:30 +00001148 check_follow_cname(direct, &host, cname);
Damien Miller13f97b22014-02-24 15:57:55 +11001149 }
1150
1151 /*
djm@openbsd.org957fbce2014-10-08 22:20:25 +00001152 * If canonicalisation is enabled then re-parse the configuration
1153 * files as new stanzas may match.
Damien Miller13f97b22014-02-24 15:57:55 +11001154 */
djm@openbsd.org9e34e0c2018-11-23 05:08:07 +00001155 if (options.canonicalize_hostname != 0 && !want_final_pass) {
1156 debug("hostname canonicalisation enabled, "
1157 "will re-parse configuration");
1158 want_final_pass = 1;
1159 }
1160
1161 if (want_final_pass) {
1162 debug("re-parsing configuration");
djm@openbsd.org957fbce2014-10-08 22:20:25 +00001163 free(options.hostname);
1164 options.hostname = xstrdup(host);
djm@openbsd.org9e34e0c2018-11-23 05:08:07 +00001165 process_config_files(host_arg, pw, 1, NULL);
djm@openbsd.org957fbce2014-10-08 22:20:25 +00001166 /*
1167 * Address resolution happens early with canonicalisation
1168 * enabled and the port number may have changed since, so
1169 * reset it in address list
1170 */
1171 if (addrs != NULL && options.port > 0)
1172 set_addrinfo_port(addrs, options.port);
Ben Lindstrom14f31ab2001-09-12 17:48:04 +00001173 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001174
Damien Miller95def091999-11-25 00:26:21 +11001175 /* Fill configuration defaults. */
1176 fill_default_options(&options);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001177
djm@openbsd.orged877ef2016-07-15 00:24:30 +00001178 /*
1179 * If ProxyJump option specified, then construct a ProxyCommand now.
1180 */
1181 if (options.jump_host != NULL) {
1182 char port_s[8];
djm@openbsd.orgd8748b92018-06-01 03:11:49 +00001183 const char *sshbin = argv0;
1184
1185 /*
1186 * Try to use SSH indicated by argv[0], but fall back to
1187 * "ssh" if it appears unavailable.
1188 */
1189 if (strchr(argv0, '/') != NULL && access(argv0, X_OK) != 0)
1190 sshbin = "ssh";
djm@openbsd.orged877ef2016-07-15 00:24:30 +00001191
1192 /* Consistency check */
1193 if (options.proxy_command != NULL)
1194 fatal("inconsistent options: ProxyCommand+ProxyJump");
1195 /* Never use FD passing for ProxyJump */
1196 options.proxy_use_fdpass = 0;
1197 snprintf(port_s, sizeof(port_s), "%d", options.jump_port);
1198 xasprintf(&options.proxy_command,
djm@openbsd.orgd8748b92018-06-01 03:11:49 +00001199 "%s%s%s%s%s%s%s%s%s%s%.*s -W '[%%h]:%%p' %s",
1200 sshbin,
djm@openbsd.orged877ef2016-07-15 00:24:30 +00001201 /* Optional "-l user" argument if jump_user set */
1202 options.jump_user == NULL ? "" : " -l ",
1203 options.jump_user == NULL ? "" : options.jump_user,
1204 /* Optional "-p port" argument if jump_port set */
1205 options.jump_port <= 0 ? "" : " -p ",
1206 options.jump_port <= 0 ? "" : port_s,
1207 /* Optional additional jump hosts ",..." */
1208 options.jump_extra == NULL ? "" : " -J ",
1209 options.jump_extra == NULL ? "" : options.jump_extra,
1210 /* Optional "-F" argumment if -F specified */
1211 config == NULL ? "" : " -F ",
1212 config == NULL ? "" : config,
1213 /* Optional "-v" arguments if -v set */
1214 debug_flag ? " -" : "",
1215 debug_flag, "vvv",
1216 /* Mandatory hostname */
1217 options.jump_host);
1218 debug("Setting implicit ProxyCommand from ProxyJump: %s",
1219 options.proxy_command);
1220 }
1221
Damien Miller13f97b22014-02-24 15:57:55 +11001222 if (options.port == 0)
1223 options.port = default_ssh_port();
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001224 channel_set_af(ssh, options.address_family);
Darren Tucker0a4f04b2003-07-03 20:37:47 +10001225
Damien Millere9fc72e2013-10-15 12:14:12 +11001226 /* Tidy and check options */
1227 if (options.host_key_alias != NULL)
1228 lowercase(options.host_key_alias);
1229 if (options.proxy_command != NULL &&
1230 strcmp(options.proxy_command, "-") == 0 &&
1231 options.proxy_use_fdpass)
1232 fatal("ProxyCommand=- and ProxyUseFDPass are incompatible");
djm@openbsd.org44732de2015-02-20 22:17:21 +00001233 if (options.control_persist &&
1234 options.update_hostkeys == SSH_UPDATE_HOSTKEYS_ASK) {
1235 debug("UpdateHostKeys=ask is incompatible with ControlPersist; "
1236 "disabling");
1237 options.update_hostkeys = 0;
1238 }
djm@openbsd.org88b6fcd2015-11-19 08:23:27 +00001239 if (options.connection_attempts <= 0)
1240 fatal("Invalid number of ConnectionAttempts");
Damien Millere9fc72e2013-10-15 12:14:12 +11001241
markus@openbsd.orgcecee2d2018-07-09 21:03:30 +00001242 if (sshbuf_len(command) != 0 && options.remote_command != NULL)
bluhm@openbsd.org1112b532017-05-30 18:58:37 +00001243 fatal("Cannot execute command-line and remote command.");
1244
1245 /* Cannot fork to background if no command. */
markus@openbsd.orgcecee2d2018-07-09 21:03:30 +00001246 if (fork_after_authentication_flag && sshbuf_len(command) == 0 &&
bluhm@openbsd.org1112b532017-05-30 18:58:37 +00001247 options.remote_command == NULL && !no_shell_flag)
1248 fatal("Cannot fork into background without a command "
1249 "to execute.");
1250
Damien Miller95def091999-11-25 00:26:21 +11001251 /* reinit */
dtucker@openbsd.org68d3a2a2017-04-28 03:20:27 +00001252 log_init(argv0, options.log_level, options.log_facility, !use_syslog);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001253
Damien Millerfff9f092012-07-06 13:45:01 +10001254 if (options.request_tty == REQUEST_TTY_YES ||
1255 options.request_tty == REQUEST_TTY_FORCE)
1256 tty_flag = 1;
1257
1258 /* Allocate a tty by default if no command specified. */
markus@openbsd.orgcecee2d2018-07-09 21:03:30 +00001259 if (sshbuf_len(command) == 0 && options.remote_command == NULL)
Damien Millerfff9f092012-07-06 13:45:01 +10001260 tty_flag = options.request_tty != REQUEST_TTY_NO;
1261
1262 /* Force no tty */
markus@openbsd.org8d057842016-09-30 09:19:13 +00001263 if (options.request_tty == REQUEST_TTY_NO ||
1264 (muxclient_command && muxclient_command != SSHMUX_COMMAND_PROXY))
Damien Millerfff9f092012-07-06 13:45:01 +10001265 tty_flag = 0;
1266 /* Do not allocate a tty if stdin is not a tty. */
1267 if ((!isatty(fileno(stdin)) || stdin_null_flag) &&
1268 options.request_tty != REQUEST_TTY_FORCE) {
1269 if (tty_flag)
1270 logit("Pseudo-terminal will not be allocated because "
1271 "stdin is not a terminal.");
1272 tty_flag = 0;
1273 }
1274
Damien Miller95def091999-11-25 00:26:21 +11001275 if (options.user == NULL)
1276 options.user = xstrdup(pw->pw_name);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001277
djm@openbsd.orgb7548b12017-10-23 05:08:00 +00001278 /* Set up strings used to percent_expand() arguments */
Damien Millerdfc85fa2011-05-15 08:44:02 +10001279 if (gethostname(thishost, sizeof(thishost)) == -1)
1280 fatal("gethostname: %s", strerror(errno));
1281 strlcpy(shorthost, thishost, sizeof(shorthost));
1282 shorthost[strcspn(thishost, ".")] = '\0';
1283 snprintf(portstr, sizeof(portstr), "%d", options.port);
djm@openbsd.org9c935dd2018-06-01 03:33:53 +00001284 snprintf(uidstr, sizeof(uidstr), "%llu",
1285 (unsigned long long)pw->pw_uid);
Darren Tuckerf6b01b72008-06-13 04:56:37 +10001286
Damien Miller9c386432014-07-03 21:27:46 +10001287 if ((md = ssh_digest_start(SSH_DIGEST_SHA1)) == NULL ||
1288 ssh_digest_update(md, thishost, strlen(thishost)) < 0 ||
1289 ssh_digest_update(md, host, strlen(host)) < 0 ||
1290 ssh_digest_update(md, portstr, strlen(portstr)) < 0 ||
1291 ssh_digest_update(md, options.user, strlen(options.user)) < 0 ||
1292 ssh_digest_final(md, conn_hash, sizeof(conn_hash)) < 0)
1293 fatal("%s: mux digest failed", __func__);
1294 ssh_digest_free(md);
1295 conn_hash_hex = tohex(conn_hash, ssh_digest_bytes(SSH_DIGEST_SHA1));
1296
djm@openbsd.orgb7548b12017-10-23 05:08:00 +00001297 /*
1298 * Expand tokens in arguments. NB. LocalCommand is expanded later,
1299 * after port-forwarding is set up, so it may pick up any local
1300 * tunnel interface name allocated.
1301 */
bluhm@openbsd.org1112b532017-05-30 18:58:37 +00001302 if (options.remote_command != NULL) {
1303 debug3("expanding RemoteCommand: %s", options.remote_command);
1304 cp = options.remote_command;
1305 options.remote_command = percent_expand(cp,
1306 "C", conn_hash_hex,
1307 "L", shorthost,
1308 "d", pw->pw_dir,
1309 "h", host,
djm@openbsd.org9c935dd2018-06-01 03:33:53 +00001310 "i", uidstr,
bluhm@openbsd.org1112b532017-05-30 18:58:37 +00001311 "l", thishost,
1312 "n", host_arg,
1313 "p", portstr,
1314 "r", options.user,
1315 "u", pw->pw_name,
1316 (char *)NULL);
1317 debug3("expanded RemoteCommand: %s", options.remote_command);
1318 free(cp);
markus@openbsd.orgcecee2d2018-07-09 21:03:30 +00001319 if ((r = sshbuf_put(command, options.remote_command,
1320 strlen(options.remote_command))) != 0)
1321 fatal("%s: buffer error: %s", __func__, ssh_err(r));
bluhm@openbsd.org1112b532017-05-30 18:58:37 +00001322 }
1323
Damien Miller0e220db2004-06-15 10:34:08 +10001324 if (options.control_path != NULL) {
dtucker@openbsd.orge655ee02018-07-27 05:34:42 +00001325 cp = tilde_expand_filename(options.control_path, getuid());
Darren Tuckera627d422013-06-02 07:31:17 +10001326 free(options.control_path);
Damien Miller9c386432014-07-03 21:27:46 +10001327 options.control_path = percent_expand(cp,
1328 "C", conn_hash_hex,
1329 "L", shorthost,
1330 "h", host,
djm@openbsd.org9c935dd2018-06-01 03:33:53 +00001331 "i", uidstr,
Damien Miller9c386432014-07-03 21:27:46 +10001332 "l", thishost,
1333 "n", host_arg,
1334 "p", portstr,
1335 "r", options.user,
1336 "u", pw->pw_name,
djm@openbsd.org674b3b62015-09-11 03:47:28 +00001337 "i", uidstr,
Damien Millerdfc85fa2011-05-15 08:44:02 +10001338 (char *)NULL);
Darren Tuckera627d422013-06-02 07:31:17 +10001339 free(cp);
Damien Miller0e220db2004-06-15 10:34:08 +10001340 }
Damien Miller9c386432014-07-03 21:27:46 +10001341
djm@openbsd.org957fbce2014-10-08 22:20:25 +00001342 if (config_test) {
1343 dump_client_config(&options, host);
1344 exit(0);
1345 }
1346
Damien Millerb1cbfa22008-05-19 16:00:08 +10001347 if (muxclient_command != 0 && options.control_path == NULL)
Darren Tucker0814d312005-06-01 23:08:51 +10001348 fatal("No ControlPath specified for \"-O\" command");
markus@openbsd.org8d057842016-09-30 09:19:13 +00001349 if (options.control_path != NULL) {
1350 int sock;
1351 if ((sock = muxclient(options.control_path)) >= 0) {
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001352 ssh_packet_set_connection(ssh, sock, sock);
djm@openbsd.org25b2ed62019-01-19 21:36:06 +00001353 ssh_packet_set_mux(ssh);
markus@openbsd.org8d057842016-09-30 09:19:13 +00001354 goto skip_connect;
1355 }
1356 }
Damien Miller0e220db2004-06-15 10:34:08 +10001357
Damien Miller08b57c62014-02-27 10:17:13 +11001358 /*
1359 * If hostname canonicalisation was not enabled, then we may not
1360 * have yet resolved the hostname. Do so now.
1361 */
1362 if (addrs == NULL && options.proxy_command == NULL) {
djm@openbsd.orga85768a2015-09-04 04:56:09 +00001363 debug2("resolving \"%s\" port %d", host, options.port);
Damien Miller08b57c62014-02-27 10:17:13 +11001364 if ((addrs = resolve_host(host, options.port, 1,
1365 cname, sizeof(cname))) == NULL)
1366 cleanup_exit(255); /* resolve_host logs the error */
1367 }
1368
Damien Miller67bd0622007-09-17 12:06:57 +10001369 timeout_ms = options.connection_timeout * 1000;
1370
Kevin Stevesfcec7f82000-12-15 19:55:48 +00001371 /* Open a connection to the remote host. */
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001372 if (ssh_connect(ssh, host, addrs, &hostaddr, options.port,
Damien Miller0faf7472013-10-17 11:47:23 +11001373 options.address_family, options.connection_attempts,
dtucker@openbsd.org95d41e92018-07-19 10:28:47 +00001374 &timeout_ms, options.tcp_keep_alive) != 0)
Damien Miller0faf7472013-10-17 11:47:23 +11001375 exit(255);
1376
Damien Miller28631ce2013-10-26 10:07:56 +11001377 if (addrs != NULL)
1378 freeaddrinfo(addrs);
1379
djm@openbsd.org25b2ed62019-01-19 21:36:06 +00001380 ssh_packet_set_timeout(ssh, options.server_alive_interval,
Damien Miller0faf7472013-10-17 11:47:23 +11001381 options.server_alive_count_max);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001382
Damien Miller67bd0622007-09-17 12:06:57 +10001383 if (timeout_ms > 0)
1384 debug3("timeout: %d ms remain after connect", timeout_ms);
1385
Damien Miller5428f641999-11-25 11:54:57 +11001386 /*
dtucker@openbsd.org26efc2f2018-07-16 11:05:41 +00001387 * If we successfully made the connection and we have hostbased auth
1388 * enabled, load the public keys so we can later use the ssh-keysign
1389 * helper to sign challenges.
Damien Miller5428f641999-11-25 11:54:57 +11001390 */
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001391 sensitive_data.nkeys = 0;
1392 sensitive_data.keys = NULL;
djm@openbsd.org873d3e72017-04-30 23:18:44 +00001393 if (options.hostbased_authentication) {
dtucker@openbsd.orgac590762018-07-16 22:25:01 +00001394 sensitive_data.nkeys = 10;
Damien Millerddd63ab2006-03-31 23:10:51 +11001395 sensitive_data.keys = xcalloc(sensitive_data.nkeys,
markus@openbsd.org5467fbc2018-07-11 18:53:29 +00001396 sizeof(struct sshkey));
1397
1398 /* XXX check errors? */
dtucker@openbsd.orgac590762018-07-16 22:25:01 +00001399#define L_PUBKEY(p,o) do { \
1400 if ((o) >= sensitive_data.nkeys) \
1401 fatal("%s pubkey out of array bounds", __func__); \
markus@openbsd.org5467fbc2018-07-11 18:53:29 +00001402 check_load(sshkey_load_public(p, &(sensitive_data.keys[o]), NULL), \
dtucker@openbsd.orgac590762018-07-16 22:25:01 +00001403 p, "pubkey"); \
1404} while (0)
1405#define L_CERT(p,o) do { \
1406 if ((o) >= sensitive_data.nkeys) \
1407 fatal("%s cert out of array bounds", __func__); \
1408 check_load(sshkey_load_cert(p, &(sensitive_data.keys[o])), p, "cert"); \
1409} while (0)
Ben Lindstromf9c48842002-06-11 16:37:51 +00001410
dtucker@openbsd.org26efc2f2018-07-16 11:05:41 +00001411 if (options.hostbased_authentication == 1) {
dtucker@openbsd.orgac590762018-07-16 22:25:01 +00001412 L_CERT(_PATH_HOST_ECDSA_KEY_FILE, 0);
1413 L_CERT(_PATH_HOST_ED25519_KEY_FILE, 1);
1414 L_CERT(_PATH_HOST_RSA_KEY_FILE, 2);
1415 L_CERT(_PATH_HOST_DSA_KEY_FILE, 3);
1416 L_PUBKEY(_PATH_HOST_ECDSA_KEY_FILE, 4);
1417 L_PUBKEY(_PATH_HOST_ED25519_KEY_FILE, 5);
1418 L_PUBKEY(_PATH_HOST_RSA_KEY_FILE, 6);
1419 L_PUBKEY(_PATH_HOST_DSA_KEY_FILE, 7);
1420 L_CERT(_PATH_HOST_XMSS_KEY_FILE, 8);
1421 L_PUBKEY(_PATH_HOST_XMSS_KEY_FILE, 9);
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001422 }
Damien Miller95def091999-11-25 00:26:21 +11001423 }
Damien Miller95def091999-11-25 00:26:21 +11001424
dtucker@openbsd.org258dc8b2018-07-18 11:34:04 +00001425 /* Create ~/.ssh * directory if it doesn't already exist. */
Darren Tucker45c66d72011-11-04 10:50:40 +11001426 if (config == NULL) {
1427 r = snprintf(buf, sizeof buf, "%s%s%s", pw->pw_dir,
1428 strcmp(pw->pw_dir, "/") ? "/" : "", _PATH_SSH_USER_DIR);
1429 if (r > 0 && (size_t)r < sizeof(buf) && stat(buf, &st) < 0) {
Darren Tucker8ccb7392010-09-10 12:28:24 +10001430#ifdef WITH_SELINUX
Darren Tucker45c66d72011-11-04 10:50:40 +11001431 ssh_selinux_setfscreatecon(buf);
Darren Tucker8ccb7392010-09-10 12:28:24 +10001432#endif
Darren Tucker45c66d72011-11-04 10:50:40 +11001433 if (mkdir(buf, 0700) < 0)
1434 error("Could not create directory '%.200s'.",
1435 buf);
Darren Tucker8ccb7392010-09-10 12:28:24 +10001436#ifdef WITH_SELINUX
Darren Tucker45c66d72011-11-04 10:50:40 +11001437 ssh_selinux_setfscreatecon(NULL);
Darren Tucker8ccb7392010-09-10 12:28:24 +10001438#endif
Darren Tucker45c66d72011-11-04 10:50:40 +11001439 }
Darren Tucker8ccb7392010-09-10 12:28:24 +10001440 }
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001441 /* load options.identity_files */
djm@openbsd.orgb7548b12017-10-23 05:08:00 +00001442 load_public_identity_files(pw);
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001443
djm@openbsd.org001aa552018-04-10 00:10:49 +00001444 /* optionally set the SSH_AUTHSOCKET_ENV_NAME variable */
markus@openbsd.org1a75d142016-05-04 14:29:58 +00001445 if (options.identity_agent &&
1446 strcmp(options.identity_agent, SSH_AUTHSOCKET_ENV_NAME) != 0) {
markus@openbsd.orgb02ad1c2016-05-04 12:21:53 +00001447 if (strcmp(options.identity_agent, "none") == 0) {
1448 unsetenv(SSH_AUTHSOCKET_ENV_NAME);
1449 } else {
1450 p = tilde_expand_filename(options.identity_agent,
dtucker@openbsd.orge655ee02018-07-27 05:34:42 +00001451 getuid());
djm@openbsd.org9c935dd2018-06-01 03:33:53 +00001452 cp = percent_expand(p,
1453 "d", pw->pw_dir,
1454 "h", host,
1455 "i", uidstr,
1456 "l", thishost,
1457 "r", options.user,
1458 "u", pw->pw_name,
1459 (char *)NULL);
markus@openbsd.orgb02ad1c2016-05-04 12:21:53 +00001460 free(p);
djm@openbsd.org5eff5b82018-10-03 06:38:35 +00001461 /*
1462 * If identity_agent represents an environment variable
1463 * then recheck that it is valid (since processing with
1464 * percent_expand() may have changed it) and substitute
1465 * its value.
1466 */
1467 if (cp[0] == '$') {
1468 if (!valid_env_name(cp + 1)) {
1469 fatal("Invalid IdentityAgent "
1470 "environment variable name %s", cp);
1471 }
1472 if ((p = getenv(cp + 1)) == NULL)
1473 unsetenv(SSH_AUTHSOCKET_ENV_NAME);
1474 else
1475 setenv(SSH_AUTHSOCKET_ENV_NAME, p, 1);
1476 } else {
1477 /* identity_agent specifies a path directly */
1478 setenv(SSH_AUTHSOCKET_ENV_NAME, cp, 1);
1479 }
1480 free(cp);
markus@openbsd.orgb02ad1c2016-05-04 12:21:53 +00001481 }
1482 }
1483
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001484 /* Expand ~ in known host file names. */
Damien Miller295ee632011-05-29 21:42:31 +10001485 tilde_expand_paths(options.system_hostfiles,
1486 options.num_system_hostfiles);
1487 tilde_expand_paths(options.user_hostfiles, options.num_user_hostfiles);
Damien Miller95def091999-11-25 00:26:21 +11001488
Damien Miller07cd5892001-11-12 10:52:03 +11001489 signal(SIGPIPE, SIG_IGN); /* ignore SIGPIPE early */
Damien Miller857b02e2010-09-24 22:02:56 +10001490 signal(SIGCHLD, main_sigchld_handler);
Damien Miller07cd5892001-11-12 10:52:03 +11001491
Darren Tuckerd6173c02008-06-13 04:52:53 +10001492 /* Log into the remote system. Never returns if the login fails. */
djm@openbsd.org0a843d92018-12-27 03:25:24 +00001493 ssh_login(ssh, &sensitive_data, host, (struct sockaddr *)&hostaddr,
Damien Millerd925dcd2010-12-01 12:21:51 +11001494 options.port, pw, timeout_ms);
Damien Miller95def091999-11-25 00:26:21 +11001495
djm@openbsd.org25b2ed62019-01-19 21:36:06 +00001496 if (ssh_packet_connection_is_on_socket(ssh)) {
Damien Miller383ffe62010-06-26 10:02:03 +10001497 verbose("Authenticated to %s ([%s]:%d).", host,
djm@openbsd.org95767262016-03-07 19:02:43 +00001498 ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));
Damien Miller383ffe62010-06-26 10:02:03 +10001499 } else {
1500 verbose("Authenticated to %s (via proxy).", host);
1501 }
1502
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001503 /* We no longer need the private host keys. Clear them now. */
1504 if (sensitive_data.nkeys != 0) {
1505 for (i = 0; i < sensitive_data.nkeys; i++) {
1506 if (sensitive_data.keys[i] != NULL) {
1507 /* Destroys contents safely */
1508 debug3("clear hostkey %d", i);
markus@openbsd.org5467fbc2018-07-11 18:53:29 +00001509 sshkey_free(sensitive_data.keys[i]);
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001510 sensitive_data.keys[i] = NULL;
1511 }
1512 }
Darren Tuckera627d422013-06-02 07:31:17 +10001513 free(sensitive_data.keys);
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001514 }
Ben Lindstroma6c8a8d2001-08-06 21:42:00 +00001515 for (i = 0; i < options.num_identity_files; i++) {
Darren Tuckera627d422013-06-02 07:31:17 +10001516 free(options.identity_files[i]);
1517 options.identity_files[i] = NULL;
Ben Lindstroma6c8a8d2001-08-06 21:42:00 +00001518 if (options.identity_keys[i]) {
markus@openbsd.org5467fbc2018-07-11 18:53:29 +00001519 sshkey_free(options.identity_keys[i]);
Ben Lindstroma6c8a8d2001-08-06 21:42:00 +00001520 options.identity_keys[i] = NULL;
1521 }
1522 }
djm@openbsd.org4e44a792015-09-24 06:15:11 +00001523 for (i = 0; i < options.num_certificate_files; i++) {
1524 free(options.certificate_files[i]);
1525 options.certificate_files[i] = NULL;
1526 }
Damien Miller95def091999-11-25 00:26:21 +11001527
markus@openbsd.org8d057842016-09-30 09:19:13 +00001528 skip_connect:
djm@openbsd.orgb7548b12017-10-23 05:08:00 +00001529 exit_status = ssh_session2(ssh, pw);
djm@openbsd.org25b2ed62019-01-19 21:36:06 +00001530 ssh_packet_close(ssh);
Damien Miller8c4e18a2002-09-19 12:05:02 +10001531
Damien Millerb1cbfa22008-05-19 16:00:08 +10001532 if (options.control_path != NULL && muxserver_sock != -1)
Damien Miller0e220db2004-06-15 10:34:08 +10001533 unlink(options.control_path);
1534
Damien Millera41ccca2010-10-07 22:07:32 +11001535 /* Kill ProxyCommand if it is running. */
1536 ssh_kill_proxy_command();
Damien Miller8c4e18a2002-09-19 12:05:02 +10001537
Damien Miller1383bd82000-04-06 12:32:37 +10001538 return exit_status;
1539}
1540
Damien Millere11e1ea2010-08-03 16:04:46 +10001541static void
1542control_persist_detach(void)
1543{
1544 pid_t pid;
djm@openbsd.orgd2d6bf82016-04-29 08:07:53 +00001545 int devnull, keep_stderr;
Damien Millere11e1ea2010-08-03 16:04:46 +10001546
1547 debug("%s: backgrounding master process", __func__);
1548
djm@openbsd.orgb8bbff32018-02-13 03:36:56 +00001549 /*
1550 * master (current process) into the background, and make the
1551 * foreground process a client of the backgrounded master.
1552 */
Damien Millere11e1ea2010-08-03 16:04:46 +10001553 switch ((pid = fork())) {
1554 case -1:
1555 fatal("%s: fork: %s", __func__, strerror(errno));
1556 case 0:
1557 /* Child: master process continues mainloop */
djm@openbsd.orgb8bbff32018-02-13 03:36:56 +00001558 break;
1559 default:
Damien Millere11e1ea2010-08-03 16:04:46 +10001560 /* Parent: set up mux slave to connect to backgrounded master */
1561 debug2("%s: background process is %ld", __func__, (long)pid);
1562 stdin_null_flag = ostdin_null_flag;
Damien Miller21771e22011-05-15 08:45:50 +10001563 options.request_tty = orequest_tty;
Damien Millere11e1ea2010-08-03 16:04:46 +10001564 tty_flag = otty_flag;
djm@openbsd.orgb8bbff32018-02-13 03:36:56 +00001565 close(muxserver_sock);
1566 muxserver_sock = -1;
Damien Miller5929c522010-09-10 11:17:02 +10001567 options.control_master = SSHCTL_MASTER_NO;
djm@openbsd.orgb8bbff32018-02-13 03:36:56 +00001568 muxclient(options.control_path);
Damien Millere11e1ea2010-08-03 16:04:46 +10001569 /* muxclient() doesn't return on success. */
djm@openbsd.orgb8bbff32018-02-13 03:36:56 +00001570 fatal("Failed to connect to new control master");
1571 }
Damien Miller00d9ae22010-08-17 01:59:31 +10001572 if ((devnull = open(_PATH_DEVNULL, O_RDWR)) == -1) {
1573 error("%s: open(\"/dev/null\"): %s", __func__,
1574 strerror(errno));
1575 } else {
djm@openbsd.orgd2d6bf82016-04-29 08:07:53 +00001576 keep_stderr = log_is_on_stderr() && debug_flag;
Damien Miller00d9ae22010-08-17 01:59:31 +10001577 if (dup2(devnull, STDIN_FILENO) == -1 ||
djm@openbsd.orgd2d6bf82016-04-29 08:07:53 +00001578 dup2(devnull, STDOUT_FILENO) == -1 ||
1579 (!keep_stderr && dup2(devnull, STDERR_FILENO) == -1))
Damien Miller00d9ae22010-08-17 01:59:31 +10001580 error("%s: dup2: %s", __func__, strerror(errno));
1581 if (devnull > STDERR_FILENO)
1582 close(devnull);
1583 }
Damien Miller98e27dc2013-07-25 11:55:52 +10001584 daemon(1, 1);
Damien Millerea2c1a42011-06-03 12:10:22 +10001585 setproctitle("%s [mux]", options.control_path);
Damien Millere11e1ea2010-08-03 16:04:46 +10001586}
1587
1588/* Do fork() after authentication. Used by "ssh -f" */
1589static void
1590fork_postauth(void)
1591{
1592 if (need_controlpersist_detach)
1593 control_persist_detach();
1594 debug("forking to background");
1595 fork_after_authentication_flag = 0;
1596 if (daemon(1, 1) < 0)
1597 fatal("daemon() failed: %.200s", strerror(errno));
1598}
1599
Darren Tucker9f407c42008-06-13 04:50:27 +10001600/* Callback for remote forward global requests */
1601static void
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001602ssh_confirm_remote_forward(struct ssh *ssh, int type, u_int32_t seq, void *ctxt)
Darren Tucker9f407c42008-06-13 04:50:27 +10001603{
Damien Miller7acefbb2014-07-18 14:11:24 +10001604 struct Forward *rfwd = (struct Forward *)ctxt;
djm@openbsd.org25b2ed62019-01-19 21:36:06 +00001605 u_int port;
1606 int r;
Darren Tucker9f407c42008-06-13 04:50:27 +10001607
Damien Miller4bf648f2009-02-14 16:28:21 +11001608 /* XXX verbose() on failure? */
Damien Miller4b3ed642014-07-02 15:29:40 +10001609 debug("remote forward %s for: listen %s%s%d, connect %s:%d",
Darren Tucker9f407c42008-06-13 04:50:27 +10001610 type == SSH2_MSG_REQUEST_SUCCESS ? "success" : "failure",
Damien Miller7acefbb2014-07-18 14:11:24 +10001611 rfwd->listen_path ? rfwd->listen_path :
1612 rfwd->listen_host ? rfwd->listen_host : "",
1613 (rfwd->listen_path || rfwd->listen_host) ? ":" : "",
1614 rfwd->listen_port, rfwd->connect_path ? rfwd->connect_path :
1615 rfwd->connect_host, rfwd->connect_port);
1616 if (rfwd->listen_path == NULL && rfwd->listen_port == 0) {
Darren Tucker68afb8c2011-10-02 18:59:03 +11001617 if (type == SSH2_MSG_REQUEST_SUCCESS) {
djm@openbsd.org25b2ed62019-01-19 21:36:06 +00001618 if ((r = sshpkt_get_u32(ssh, &port)) != 0)
1619 fatal("%s: %s", __func__, ssh_err(r));
1620 if (port > 65535) {
1621 error("Invalid allocated port %u for remote "
1622 "forward to %s:%d", port,
1623 rfwd->connect_host, rfwd->connect_port);
1624 /* Ensure failure processing runs below */
1625 type = SSH2_MSG_REQUEST_FAILURE;
1626 channel_update_permission(ssh,
1627 rfwd->handle, -1);
1628 } else {
1629 rfwd->allocated_port = (int)port;
1630 logit("Allocated port %u for remote "
1631 "forward to %s:%d",
1632 rfwd->allocated_port, rfwd->connect_host,
1633 rfwd->connect_port);
1634 channel_update_permission(ssh,
1635 rfwd->handle, rfwd->allocated_port);
1636 }
Darren Tucker68afb8c2011-10-02 18:59:03 +11001637 } else {
djm@openbsd.org115063a2018-06-06 18:22:41 +00001638 channel_update_permission(ssh, rfwd->handle, -1);
Darren Tucker68afb8c2011-10-02 18:59:03 +11001639 }
Damien Miller4bf648f2009-02-14 16:28:21 +11001640 }
djm@openbsd.org@openbsd.orgdbe06622017-10-27 01:57:06 +00001641
Darren Tucker9f407c42008-06-13 04:50:27 +10001642 if (type == SSH2_MSG_REQUEST_FAILURE) {
Damien Miller7acefbb2014-07-18 14:11:24 +10001643 if (options.exit_on_forward_failure) {
1644 if (rfwd->listen_path != NULL)
1645 fatal("Error: remote port forwarding failed "
1646 "for listen path %s", rfwd->listen_path);
1647 else
1648 fatal("Error: remote port forwarding failed "
1649 "for listen port %d", rfwd->listen_port);
1650 } else {
1651 if (rfwd->listen_path != NULL)
1652 logit("Warning: remote port forwarding failed "
1653 "for listen path %s", rfwd->listen_path);
1654 else
1655 logit("Warning: remote port forwarding failed "
1656 "for listen port %d", rfwd->listen_port);
1657 }
Darren Tucker9f407c42008-06-13 04:50:27 +10001658 }
Darren Tucker9a2a6092008-07-04 12:53:50 +10001659 if (++remote_forward_confirms_received == options.num_remote_forwards) {
Darren Tucker9f407c42008-06-13 04:50:27 +10001660 debug("All remote forwarding requests processed");
Damien Millere11e1ea2010-08-03 16:04:46 +10001661 if (fork_after_authentication_flag)
1662 fork_postauth();
Darren Tucker9a2a6092008-07-04 12:53:50 +10001663 }
Darren Tucker9f407c42008-06-13 04:50:27 +10001664}
1665
Ben Lindstrombba81212001-06-25 05:01:22 +00001666static void
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001667client_cleanup_stdio_fwd(struct ssh *ssh, int id, void *arg)
Darren Tucker7ad8dd22010-01-12 19:40:27 +11001668{
1669 debug("stdio forwarding: done");
1670 cleanup_exit(0);
1671}
1672
Darren Tucker2d6665d2011-11-04 10:54:22 +11001673static void
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001674ssh_stdio_confirm(struct ssh *ssh, int id, int success, void *arg)
Damien Miller357610d2014-07-18 15:04:10 +10001675{
1676 if (!success)
1677 fatal("stdio forwarding failed");
1678}
1679
1680static void
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001681ssh_init_stdio_forwarding(struct ssh *ssh)
Darren Tucker7ad8dd22010-01-12 19:40:27 +11001682{
1683 Channel *c;
Damien Millere1537f92010-01-26 13:26:22 +11001684 int in, out;
Darren Tucker7ad8dd22010-01-12 19:40:27 +11001685
dtucker@openbsd.org8543ff32016-06-03 03:14:41 +00001686 if (options.stdio_forward_host == NULL)
Darren Tucker2d6665d2011-11-04 10:54:22 +11001687 return;
Damien Millere1537f92010-01-26 13:26:22 +11001688
dtucker@openbsd.org8543ff32016-06-03 03:14:41 +00001689 debug3("%s: %s:%d", __func__, options.stdio_forward_host,
1690 options.stdio_forward_port);
Darren Tucker2d6665d2011-11-04 10:54:22 +11001691
1692 if ((in = dup(STDIN_FILENO)) < 0 ||
1693 (out = dup(STDOUT_FILENO)) < 0)
Damien Millere1537f92010-01-26 13:26:22 +11001694 fatal("channel_connect_stdio_fwd: dup() in/out failed");
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001695 if ((c = channel_connect_stdio_fwd(ssh, options.stdio_forward_host,
dtucker@openbsd.org8543ff32016-06-03 03:14:41 +00001696 options.stdio_forward_port, in, out)) == NULL)
Darren Tucker2d6665d2011-11-04 10:54:22 +11001697 fatal("%s: channel_connect_stdio_fwd failed", __func__);
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001698 channel_register_cleanup(ssh, c->self, client_cleanup_stdio_fwd, 0);
1699 channel_register_open_confirm(ssh, c->self, ssh_stdio_confirm, NULL);
Darren Tucker7ad8dd22010-01-12 19:40:27 +11001700}
1701
1702static void
djm@openbsd.orgb7548b12017-10-23 05:08:00 +00001703ssh_init_forwarding(struct ssh *ssh, char **ifname)
Damien Miller0bc1bd82000-11-13 22:57:25 +11001704{
Kevin Steves12057502001-02-05 14:54:34 +00001705 int success = 0;
Damien Miller0bc1bd82000-11-13 22:57:25 +11001706 int i;
Kevin Steves12057502001-02-05 14:54:34 +00001707
Damien Miller0bc1bd82000-11-13 22:57:25 +11001708 /* Initiate local TCP/IP port forwardings. */
1709 for (i = 0; i < options.num_local_forwards; i++) {
Damien Millerf91ee4c2005-03-01 21:24:33 +11001710 debug("Local connections to %.200s:%d forwarded to remote "
1711 "address %.200s:%d",
Damien Miller7acefbb2014-07-18 14:11:24 +10001712 (options.local_forwards[i].listen_path != NULL) ?
1713 options.local_forwards[i].listen_path :
Darren Tucker47eede72005-03-14 23:08:12 +11001714 (options.local_forwards[i].listen_host == NULL) ?
Damien Miller7acefbb2014-07-18 14:11:24 +10001715 (options.fwd_opts.gateway_ports ? "*" : "LOCALHOST") :
Damien Millerf91ee4c2005-03-01 21:24:33 +11001716 options.local_forwards[i].listen_host,
1717 options.local_forwards[i].listen_port,
Damien Miller7acefbb2014-07-18 14:11:24 +10001718 (options.local_forwards[i].connect_path != NULL) ?
1719 options.local_forwards[i].connect_path :
Damien Millerf91ee4c2005-03-01 21:24:33 +11001720 options.local_forwards[i].connect_host,
1721 options.local_forwards[i].connect_port);
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001722 success += channel_setup_local_fwd_listener(ssh,
Damien Miller7acefbb2014-07-18 14:11:24 +10001723 &options.local_forwards[i], &options.fwd_opts);
Damien Miller0bc1bd82000-11-13 22:57:25 +11001724 }
Darren Tuckere7d4b192006-07-12 22:17:10 +10001725 if (i > 0 && success != i && options.exit_on_forward_failure)
1726 fatal("Could not request local forwarding.");
Kevin Steves12057502001-02-05 14:54:34 +00001727 if (i > 0 && success == 0)
1728 error("Could not request local forwarding.");
Damien Miller0bc1bd82000-11-13 22:57:25 +11001729
1730 /* Initiate remote TCP/IP port forwardings. */
1731 for (i = 0; i < options.num_remote_forwards; i++) {
Damien Millerf91ee4c2005-03-01 21:24:33 +11001732 debug("Remote connections from %.200s:%d forwarded to "
1733 "local address %.200s:%d",
Damien Miller7acefbb2014-07-18 14:11:24 +10001734 (options.remote_forwards[i].listen_path != NULL) ?
1735 options.remote_forwards[i].listen_path :
Damien Miller46d38de2005-07-17 17:02:09 +10001736 (options.remote_forwards[i].listen_host == NULL) ?
Damien Milleraa3bb102005-11-05 15:12:59 +11001737 "LOCALHOST" : options.remote_forwards[i].listen_host,
Damien Millerf91ee4c2005-03-01 21:24:33 +11001738 options.remote_forwards[i].listen_port,
Damien Miller7acefbb2014-07-18 14:11:24 +10001739 (options.remote_forwards[i].connect_path != NULL) ?
1740 options.remote_forwards[i].connect_path :
Damien Millerf91ee4c2005-03-01 21:24:33 +11001741 options.remote_forwards[i].connect_host,
1742 options.remote_forwards[i].connect_port);
Darren Tucker68afb8c2011-10-02 18:59:03 +11001743 options.remote_forwards[i].handle =
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001744 channel_request_remote_forwarding(ssh,
Damien Miller7acefbb2014-07-18 14:11:24 +10001745 &options.remote_forwards[i]);
Darren Tucker68afb8c2011-10-02 18:59:03 +11001746 if (options.remote_forwards[i].handle < 0) {
Darren Tuckere7d4b192006-07-12 22:17:10 +10001747 if (options.exit_on_forward_failure)
1748 fatal("Could not request remote forwarding.");
1749 else
1750 logit("Warning: Could not request remote "
1751 "forwarding.");
Darren Tucker68afb8c2011-10-02 18:59:03 +11001752 } else {
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001753 client_register_global_confirm(
1754 ssh_confirm_remote_forward,
Darren Tucker68afb8c2011-10-02 18:59:03 +11001755 &options.remote_forwards[i]);
Darren Tuckere7d4b192006-07-12 22:17:10 +10001756 }
Damien Miller0bc1bd82000-11-13 22:57:25 +11001757 }
Damien Millerb3ce9fe2007-08-08 14:32:41 +10001758
1759 /* Initiate tunnel forwarding. */
1760 if (options.tun_open != SSH_TUNMODE_NO) {
djm@openbsd.orgb7548b12017-10-23 05:08:00 +00001761 if ((*ifname = client_request_tun_fwd(ssh,
1762 options.tun_open, options.tun_local,
1763 options.tun_remote)) == NULL) {
Damien Millerb3ce9fe2007-08-08 14:32:41 +10001764 if (options.exit_on_forward_failure)
1765 fatal("Could not request tunnel forwarding.");
1766 else
1767 error("Could not request tunnel forwarding.");
1768 }
djm@openbsd.org@openbsd.orgdbe06622017-10-27 01:57:06 +00001769 }
Damien Miller0bc1bd82000-11-13 22:57:25 +11001770}
1771
Ben Lindstrombba81212001-06-25 05:01:22 +00001772static void
Damien Miller0bc1bd82000-11-13 22:57:25 +11001773check_agent_present(void)
1774{
djm@openbsd.org141efe42015-01-14 20:05:27 +00001775 int r;
1776
Damien Miller0bc1bd82000-11-13 22:57:25 +11001777 if (options.forward_agent) {
Damien Miller788f2122005-11-05 15:14:59 +11001778 /* Clear agent forwarding if we don't have an agent. */
djm@openbsd.org141efe42015-01-14 20:05:27 +00001779 if ((r = ssh_get_authentication_socket(NULL)) != 0) {
Damien Miller0bc1bd82000-11-13 22:57:25 +11001780 options.forward_agent = 0;
djm@openbsd.org141efe42015-01-14 20:05:27 +00001781 if (r != SSH_ERR_AGENT_NOT_PRESENT)
1782 debug("ssh_get_authentication_socket: %s",
1783 ssh_err(r));
1784 }
Damien Miller0bc1bd82000-11-13 22:57:25 +11001785 }
1786}
1787
Ben Lindstrombba81212001-06-25 05:01:22 +00001788static void
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001789ssh_session2_setup(struct ssh *ssh, int id, int success, void *arg)
Damien Miller1383bd82000-04-06 12:32:37 +10001790{
Damien Miller3756dce2004-06-18 01:17:29 +10001791 extern char **environ;
Damien Miller17e7ed02005-06-17 12:54:33 +10001792 const char *display;
djm@openbsd.org25b2ed62019-01-19 21:36:06 +00001793 int r, interactive = tty_flag;
djm@openbsd.orged4ce822016-01-13 23:04:47 +00001794 char *proto = NULL, *data = NULL;
Damien Miller17e7ed02005-06-17 12:54:33 +10001795
Damien Millerd530f5f2010-05-21 14:57:10 +10001796 if (!success)
1797 return; /* No need for error message, channels code sens one */
1798
Damien Miller46d38de2005-07-17 17:02:09 +10001799 display = getenv("DISPLAY");
djm@openbsd.orga58be332015-04-17 13:16:48 +00001800 if (display == NULL && options.forward_x11)
1801 debug("X11 forwarding requested but DISPLAY not set");
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001802 if (options.forward_x11 && client_x11_get_proto(ssh, display,
djm@openbsd.orged4ce822016-01-13 23:04:47 +00001803 options.xauth_location, options.forward_x11_trusted,
1804 options.forward_x11_timeout, &proto, &data) == 0) {
Damien Millerbd483e72000-04-30 10:00:53 +10001805 /* Request forwarding with authentication spoofing. */
Darren Tuckerd6173c02008-06-13 04:52:53 +10001806 debug("Requesting X11 forwarding with authentication "
1807 "spoofing.");
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001808 x11_request_forwarding_with_spoofing(ssh, id, display, proto,
Damien Miller6d7b4372011-06-23 08:31:57 +10001809 data, 1);
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001810 client_expect_confirm(ssh, id, "X11 forwarding", CONFIRM_WARN);
Damien Miller6d7b4372011-06-23 08:31:57 +10001811 /* XXX exit_on_forward_failure */
Ben Lindstrombf555ba2001-01-18 02:04:35 +00001812 interactive = 1;
Damien Millerbd483e72000-04-30 10:00:53 +10001813 }
1814
Damien Miller0bc1bd82000-11-13 22:57:25 +11001815 check_agent_present();
1816 if (options.forward_agent) {
1817 debug("Requesting authentication agent forwarding.");
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001818 channel_request_start(ssh, id, "auth-agent-req@openssh.com", 0);
djm@openbsd.org25b2ed62019-01-19 21:36:06 +00001819 if ((r = sshpkt_send(ssh)) != 0)
1820 fatal("%s: %s", __func__, ssh_err(r));
Damien Miller0bc1bd82000-11-13 22:57:25 +11001821 }
1822
Darren Tucker7b305012012-07-02 18:55:09 +10001823 /* Tell the packet module whether this is an interactive session. */
djm@openbsd.org25b2ed62019-01-19 21:36:06 +00001824 ssh_packet_set_interactive(ssh, interactive,
Darren Tucker7b305012012-07-02 18:55:09 +10001825 options.ip_qos_interactive, options.ip_qos_bulk);
1826
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001827 client_session2_setup(ssh, id, tty_flag, subsystem_flag, getenv("TERM"),
markus@openbsd.orgcecee2d2018-07-09 21:03:30 +00001828 NULL, fileno(stdin), command, environ);
Damien Miller1383bd82000-04-06 12:32:37 +10001829}
1830
Ben Lindstromf558cf62001-09-20 23:13:49 +00001831/* open new channel for a session */
Ben Lindstrombba81212001-06-25 05:01:22 +00001832static int
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001833ssh_session2_open(struct ssh *ssh)
Damien Miller1383bd82000-04-06 12:32:37 +10001834{
Ben Lindstrom99c73b32001-05-05 04:09:47 +00001835 Channel *c;
1836 int window, packetmax, in, out, err;
Damien Millerad833b32000-08-23 10:46:23 +10001837
Damien Millercaf6dd62000-08-29 11:33:50 +11001838 if (stdin_null_flag) {
Ben Lindstrom31ca54a2001-02-09 02:11:24 +00001839 in = open(_PATH_DEVNULL, O_RDONLY);
Damien Millercaf6dd62000-08-29 11:33:50 +11001840 } else {
1841 in = dup(STDIN_FILENO);
1842 }
1843 out = dup(STDOUT_FILENO);
1844 err = dup(STDERR_FILENO);
1845
1846 if (in < 0 || out < 0 || err < 0)
1847 fatal("dup() in/out/err failed");
1848
Damien Miller69b69aa2000-10-28 14:19:58 +11001849 /* enable nonblocking unless tty */
1850 if (!isatty(in))
1851 set_nonblock(in);
1852 if (!isatty(out))
1853 set_nonblock(out);
1854 if (!isatty(err))
1855 set_nonblock(err);
1856
Damien Millere4340be2000-09-16 13:29:08 +11001857 window = CHAN_SES_WINDOW_DEFAULT;
1858 packetmax = CHAN_SES_PACKET_DEFAULT;
Damien Miller19a59452002-02-19 15:20:57 +11001859 if (tty_flag) {
1860 window >>= 1;
1861 packetmax >>= 1;
Damien Miller1383bd82000-04-06 12:32:37 +10001862 }
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001863 c = channel_new(ssh,
Damien Miller1383bd82000-04-06 12:32:37 +10001864 "session", SSH_CHANNEL_OPENING, in, out, err,
Damien Millere4340be2000-09-16 13:29:08 +11001865 window, packetmax, CHAN_EXTENDED_WRITE,
Damien Millerb1ca8bb2003-05-14 13:45:42 +10001866 "client-session", /*nonblock*/0);
Damien Miller1383bd82000-04-06 12:32:37 +10001867
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001868 debug3("%s: channel_new: %d", __func__, c->self);
Ben Lindstrom4c3f77d2001-04-05 23:37:36 +00001869
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001870 channel_send_open(ssh, c->self);
Ben Lindstromf558cf62001-09-20 23:13:49 +00001871 if (!no_shell_flag)
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001872 channel_register_open_confirm(ssh, c->self,
Damien Millerb84886b2008-05-19 15:05:07 +10001873 ssh_session2_setup, NULL);
Damien Miller1383bd82000-04-06 12:32:37 +10001874
Ben Lindstrom99c73b32001-05-05 04:09:47 +00001875 return c->self;
Ben Lindstrom4c3f77d2001-04-05 23:37:36 +00001876}
1877
Ben Lindstrombba81212001-06-25 05:01:22 +00001878static int
djm@openbsd.orgb7548b12017-10-23 05:08:00 +00001879ssh_session2(struct ssh *ssh, struct passwd *pw)
Ben Lindstrom4c3f77d2001-04-05 23:37:36 +00001880{
djm@openbsd.org25b2ed62019-01-19 21:36:06 +00001881 int r, devnull, id = -1;
djm@openbsd.orgb7548b12017-10-23 05:08:00 +00001882 char *cp, *tun_fwd_ifname = NULL;
Ben Lindstrom4c3f77d2001-04-05 23:37:36 +00001883
1884 /* XXX should be pre-session */
Darren Tucker2d6665d2011-11-04 10:54:22 +11001885 if (!options.control_persist)
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001886 ssh_init_stdio_forwarding(ssh);
djm@openbsd.orgb7548b12017-10-23 05:08:00 +00001887
1888 ssh_init_forwarding(ssh, &tun_fwd_ifname);
1889
1890 if (options.local_command != NULL) {
1891 debug3("expanding LocalCommand: %s", options.local_command);
1892 cp = options.local_command;
1893 options.local_command = percent_expand(cp,
1894 "C", conn_hash_hex,
1895 "L", shorthost,
1896 "d", pw->pw_dir,
1897 "h", host,
djm@openbsd.org9c935dd2018-06-01 03:33:53 +00001898 "i", uidstr,
djm@openbsd.orgb7548b12017-10-23 05:08:00 +00001899 "l", thishost,
1900 "n", host_arg,
1901 "p", portstr,
1902 "r", options.user,
1903 "u", pw->pw_name,
1904 "T", tun_fwd_ifname == NULL ? "NONE" : tun_fwd_ifname,
1905 (char *)NULL);
1906 debug3("expanded LocalCommand: %s", options.local_command);
1907 free(cp);
1908 }
Ben Lindstrom4c3f77d2001-04-05 23:37:36 +00001909
Damien Millere11e1ea2010-08-03 16:04:46 +10001910 /* Start listening for multiplex clients */
djm@openbsd.org25b2ed62019-01-19 21:36:06 +00001911 if (!ssh_packet_get_mux(ssh))
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001912 muxserver_listen(ssh);
Damien Millere11e1ea2010-08-03 16:04:46 +10001913
djm@openbsd.orgb8bbff32018-02-13 03:36:56 +00001914 /*
Darren Tucker2d6665d2011-11-04 10:54:22 +11001915 * If we are in control persist mode and have a working mux listen
1916 * socket, then prepare to background ourselves and have a foreground
1917 * client attach as a control slave.
1918 * NB. we must save copies of the flags that we override for
Damien Millere11e1ea2010-08-03 16:04:46 +10001919 * the backgrounding, since we defer attachment of the slave until
1920 * after the connection is fully established (in particular,
1921 * async rfwd replies have been received for ExitOnForwardFailure).
1922 */
djm@openbsd.orgb8bbff32018-02-13 03:36:56 +00001923 if (options.control_persist && muxserver_sock != -1) {
Damien Millere11e1ea2010-08-03 16:04:46 +10001924 ostdin_null_flag = stdin_null_flag;
1925 ono_shell_flag = no_shell_flag;
Damien Miller21771e22011-05-15 08:45:50 +10001926 orequest_tty = options.request_tty;
Damien Millere11e1ea2010-08-03 16:04:46 +10001927 otty_flag = tty_flag;
djm@openbsd.orgb8bbff32018-02-13 03:36:56 +00001928 stdin_null_flag = 1;
1929 no_shell_flag = 1;
1930 tty_flag = 0;
Damien Millere11e1ea2010-08-03 16:04:46 +10001931 if (!fork_after_authentication_flag)
1932 need_controlpersist_detach = 1;
1933 fork_after_authentication_flag = 1;
djm@openbsd.orgb8bbff32018-02-13 03:36:56 +00001934 }
Darren Tucker2d6665d2011-11-04 10:54:22 +11001935 /*
1936 * ControlPersist mux listen socket setup failed, attempt the
1937 * stdio forward setup that we skipped earlier.
1938 */
1939 if (options.control_persist && muxserver_sock == -1)
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001940 ssh_init_stdio_forwarding(ssh);
Damien Millere11e1ea2010-08-03 16:04:46 +10001941
djm@openbsd.org14b5c632018-01-23 05:27:21 +00001942 if (!no_shell_flag)
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001943 id = ssh_session2_open(ssh);
Damien Miller649fe022013-07-18 16:13:55 +10001944 else {
djm@openbsd.org25b2ed62019-01-19 21:36:06 +00001945 ssh_packet_set_interactive(ssh,
Damien Miller649fe022013-07-18 16:13:55 +10001946 options.control_master == SSHCTL_MASTER_NO,
1947 options.ip_qos_interactive, options.ip_qos_bulk);
1948 }
Ben Lindstrom4c3f77d2001-04-05 23:37:36 +00001949
Darren Tucker8901fa92008-06-11 09:34:01 +10001950 /* If we don't expect to open a new session, then disallow it */
Damien Miller456e6f02008-11-03 19:20:10 +11001951 if (options.control_master == SSHCTL_MASTER_NO &&
1952 (datafellows & SSH_NEW_OPENSSH)) {
Darren Tucker8901fa92008-06-11 09:34:01 +10001953 debug("Requesting no-more-sessions@openssh.com");
djm@openbsd.org25b2ed62019-01-19 21:36:06 +00001954 if ((r = sshpkt_start(ssh, SSH2_MSG_GLOBAL_REQUEST)) != 0 ||
1955 (r = sshpkt_put_cstring(ssh,
1956 "no-more-sessions@openssh.com")) != 0 ||
1957 (r = sshpkt_put_u8(ssh, 0)) != 0 ||
1958 (r = sshpkt_send(ssh)) != 0)
1959 fatal("%s: %s", __func__, ssh_err(r));
Darren Tucker8901fa92008-06-11 09:34:01 +10001960 }
1961
Damien Millerd27b9472005-12-13 19:29:02 +11001962 /* Execute a local command */
1963 if (options.local_command != NULL &&
1964 options.permit_local_command)
1965 ssh_local_cmd(options.local_command);
1966
Damien Miller1f25ab42010-07-16 13:56:23 +10001967 /*
djm@openbsd.org4d5456c2017-10-25 00:21:37 +00001968 * stdout is now owned by the session channel; clobber it here
1969 * so future channel closes are propagated to the local fd.
1970 * NB. this can only happen after LocalCommand has completed,
1971 * as it may want to write to stdout.
1972 */
djm@openbsd.org@openbsd.org939b30b2017-11-01 00:04:15 +00001973 if (!need_controlpersist_detach) {
1974 if ((devnull = open(_PATH_DEVNULL, O_WRONLY)) == -1)
1975 error("%s: open %s: %s", __func__,
1976 _PATH_DEVNULL, strerror(errno));
1977 if (dup2(devnull, STDOUT_FILENO) < 0)
1978 fatal("%s: dup2() stdout failed", __func__);
1979 if (devnull > STDERR_FILENO)
1980 close(devnull);
1981 }
djm@openbsd.org4d5456c2017-10-25 00:21:37 +00001982
1983 /*
Damien Miller1f25ab42010-07-16 13:56:23 +10001984 * If requested and we are not interested in replies to remote
1985 * forwarding requests, then let ssh continue in the background.
1986 */
Damien Millere11e1ea2010-08-03 16:04:46 +10001987 if (fork_after_authentication_flag) {
1988 if (options.exit_on_forward_failure &&
1989 options.num_remote_forwards > 0) {
1990 debug("deferring postauth fork until remote forward "
1991 "confirmation received");
1992 } else
1993 fork_postauth();
Darren Tucker9a2a6092008-07-04 12:53:50 +10001994 }
Ben Lindstrom4c3f77d2001-04-05 23:37:36 +00001995
djm@openbsd.orgdbee4112017-09-12 06:32:07 +00001996 return client_loop(ssh, tty_flag, tty_flag ?
Ben Lindstrom2b1f71b2001-06-05 20:32:21 +00001997 options.escape_char : SSH_ESCAPECHAR_NONE, id);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001998}
Damien Miller0bc1bd82000-11-13 22:57:25 +11001999
djm@openbsd.org4e44a792015-09-24 06:15:11 +00002000/* Loads all IdentityFile and CertificateFile keys */
Ben Lindstrombba81212001-06-25 05:01:22 +00002001static void
djm@openbsd.orgb7548b12017-10-23 05:08:00 +00002002load_public_identity_files(struct passwd *pw)
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00002003{
djm@openbsd.orgb7548b12017-10-23 05:08:00 +00002004 char *filename, *cp;
markus@openbsd.org54d90ac2017-05-30 08:52:19 +00002005 struct sshkey *public;
djm@openbsd.org4e44a792015-09-24 06:15:11 +00002006 int i;
2007 u_int n_ids, n_certs;
Damien Miller0a80ca12010-02-27 07:55:05 +11002008 char *identity_files[SSH_MAX_IDENTITY_FILES];
markus@openbsd.org54d90ac2017-05-30 08:52:19 +00002009 struct sshkey *identity_keys[SSH_MAX_IDENTITY_FILES];
djm@openbsd.org3eb7f102018-07-16 07:06:50 +00002010 int identity_file_userprovided[SSH_MAX_IDENTITY_FILES];
djm@openbsd.org4e44a792015-09-24 06:15:11 +00002011 char *certificate_files[SSH_MAX_CERTIFICATE_FILES];
2012 struct sshkey *certificates[SSH_MAX_CERTIFICATE_FILES];
djm@openbsd.org3eb7f102018-07-16 07:06:50 +00002013 int certificate_file_userprovided[SSH_MAX_CERTIFICATE_FILES];
Damien Miller7ea845e2010-02-12 09:21:02 +11002014#ifdef ENABLE_PKCS11
markus@openbsd.org54d90ac2017-05-30 08:52:19 +00002015 struct sshkey **keys;
Damien Miller7ea845e2010-02-12 09:21:02 +11002016 int nkeys;
Damien Miller0a80ca12010-02-27 07:55:05 +11002017#endif /* PKCS11 */
Ben Lindstrom0936a5b2002-03-26 03:17:42 +00002018
djm@openbsd.org4e44a792015-09-24 06:15:11 +00002019 n_ids = n_certs = 0;
Damien Miller1d2c4562014-02-04 11:18:20 +11002020 memset(identity_files, 0, sizeof(identity_files));
2021 memset(identity_keys, 0, sizeof(identity_keys));
djm@openbsd.org3eb7f102018-07-16 07:06:50 +00002022 memset(identity_file_userprovided, 0,
2023 sizeof(identity_file_userprovided));
djm@openbsd.org4e44a792015-09-24 06:15:11 +00002024 memset(certificate_files, 0, sizeof(certificate_files));
2025 memset(certificates, 0, sizeof(certificates));
djm@openbsd.org3eb7f102018-07-16 07:06:50 +00002026 memset(certificate_file_userprovided, 0,
2027 sizeof(certificate_file_userprovided));
Damien Miller0a80ca12010-02-27 07:55:05 +11002028
2029#ifdef ENABLE_PKCS11
Damien Miller7ea845e2010-02-12 09:21:02 +11002030 if (options.pkcs11_provider != NULL &&
Ben Lindstrom0936a5b2002-03-26 03:17:42 +00002031 options.num_identity_files < SSH_MAX_IDENTITY_FILES &&
Damien Miller7ea845e2010-02-12 09:21:02 +11002032 (pkcs11_init(!options.batch_mode) == 0) &&
2033 (nkeys = pkcs11_add_provider(options.pkcs11_provider, NULL,
2034 &keys)) > 0) {
Damien Miller7ea845e2010-02-12 09:21:02 +11002035 for (i = 0; i < nkeys; i++) {
Damien Miller0a80ca12010-02-27 07:55:05 +11002036 if (n_ids >= SSH_MAX_IDENTITY_FILES) {
markus@openbsd.org5467fbc2018-07-11 18:53:29 +00002037 sshkey_free(keys[i]);
Damien Miller0a80ca12010-02-27 07:55:05 +11002038 continue;
2039 }
2040 identity_keys[n_ids] = keys[i];
2041 identity_files[n_ids] =
Damien Miller7ea845e2010-02-12 09:21:02 +11002042 xstrdup(options.pkcs11_provider); /* XXX */
Damien Miller0a80ca12010-02-27 07:55:05 +11002043 n_ids++;
Ben Lindstrom0936a5b2002-03-26 03:17:42 +00002044 }
Darren Tuckera627d422013-06-02 07:31:17 +10002045 free(keys);
Ben Lindstrom711b04a2001-08-06 21:12:42 +00002046 }
Damien Miller7ea845e2010-02-12 09:21:02 +11002047#endif /* ENABLE_PKCS11 */
Damien Miller0a80ca12010-02-27 07:55:05 +11002048 for (i = 0; i < options.num_identity_files; i++) {
Darren Tucker15fd19c2013-04-05 11:22:26 +11002049 if (n_ids >= SSH_MAX_IDENTITY_FILES ||
2050 strcasecmp(options.identity_files[i], "none") == 0) {
Darren Tuckera627d422013-06-02 07:31:17 +10002051 free(options.identity_files[i]);
djm@openbsd.org4e44a792015-09-24 06:15:11 +00002052 options.identity_files[i] = NULL;
Damien Miller0a80ca12010-02-27 07:55:05 +11002053 continue;
2054 }
dtucker@openbsd.orge655ee02018-07-27 05:34:42 +00002055 cp = tilde_expand_filename(options.identity_files[i], getuid());
djm@openbsd.orgb7548b12017-10-23 05:08:00 +00002056 filename = percent_expand(cp, "d", pw->pw_dir,
2057 "u", pw->pw_name, "l", thishost, "h", host,
Damien Miller6b1d53c2006-03-31 23:13:21 +11002058 "r", options.user, (char *)NULL);
Darren Tuckera627d422013-06-02 07:31:17 +10002059 free(cp);
markus@openbsd.org5467fbc2018-07-11 18:53:29 +00002060 check_load(sshkey_load_public(filename, &public, NULL),
2061 filename, "pubkey");
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00002062 debug("identity file %s type %d", filename,
2063 public ? public->type : -1);
Darren Tuckera627d422013-06-02 07:31:17 +10002064 free(options.identity_files[i]);
Damien Miller0a80ca12010-02-27 07:55:05 +11002065 identity_files[n_ids] = filename;
2066 identity_keys[n_ids] = public;
djm@openbsd.org3eb7f102018-07-16 07:06:50 +00002067 identity_file_userprovided[n_ids] =
2068 options.identity_file_userprovided[i];
Damien Miller0a80ca12010-02-27 07:55:05 +11002069 if (++n_ids >= SSH_MAX_IDENTITY_FILES)
2070 continue;
2071
djm@openbsd.org4e44a792015-09-24 06:15:11 +00002072 /*
2073 * If no certificates have been explicitly listed then try
2074 * to add the default certificate variant too.
2075 */
2076 if (options.num_certificate_files != 0)
2077 continue;
Damien Miller0a80ca12010-02-27 07:55:05 +11002078 xasprintf(&cp, "%s-cert", filename);
markus@openbsd.org5467fbc2018-07-11 18:53:29 +00002079 check_load(sshkey_load_public(cp, &public, NULL),
2080 filename, "pubkey");
Damien Miller0a80ca12010-02-27 07:55:05 +11002081 debug("identity file %s type %d", cp,
2082 public ? public->type : -1);
2083 if (public == NULL) {
Darren Tuckera627d422013-06-02 07:31:17 +10002084 free(cp);
Damien Miller0a80ca12010-02-27 07:55:05 +11002085 continue;
2086 }
markus@openbsd.org5467fbc2018-07-11 18:53:29 +00002087 if (!sshkey_is_cert(public)) {
Damien Miller0a80ca12010-02-27 07:55:05 +11002088 debug("%s: key %s type %s is not a certificate",
markus@openbsd.org5467fbc2018-07-11 18:53:29 +00002089 __func__, cp, sshkey_type(public));
2090 sshkey_free(public);
Darren Tuckera627d422013-06-02 07:31:17 +10002091 free(cp);
Damien Miller0a80ca12010-02-27 07:55:05 +11002092 continue;
2093 }
djm@openbsd.orgb4867e02016-12-06 07:48:01 +00002094 /* NB. leave filename pointing to private key */
2095 identity_files[n_ids] = xstrdup(filename);
Damien Miller0a80ca12010-02-27 07:55:05 +11002096 identity_keys[n_ids] = public;
djm@openbsd.org3eb7f102018-07-16 07:06:50 +00002097 identity_file_userprovided[n_ids] =
2098 options.identity_file_userprovided[i];
Damien Miller0a80ca12010-02-27 07:55:05 +11002099 n_ids++;
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00002100 }
djm@openbsd.org4e44a792015-09-24 06:15:11 +00002101
2102 if (options.num_certificate_files > SSH_MAX_CERTIFICATE_FILES)
2103 fatal("%s: too many certificates", __func__);
2104 for (i = 0; i < options.num_certificate_files; i++) {
2105 cp = tilde_expand_filename(options.certificate_files[i],
dtucker@openbsd.orge655ee02018-07-27 05:34:42 +00002106 getuid());
djm@openbsd.org9c935dd2018-06-01 03:33:53 +00002107 filename = percent_expand(cp,
2108 "d", pw->pw_dir,
2109 "h", host,
djm@openbsd.org03688892018-06-08 03:35:36 +00002110 "i", uidstr,
djm@openbsd.org9c935dd2018-06-01 03:33:53 +00002111 "l", thishost,
2112 "r", options.user,
2113 "u", pw->pw_name,
2114 (char *)NULL);
djm@openbsd.org4e44a792015-09-24 06:15:11 +00002115 free(cp);
2116
markus@openbsd.org5467fbc2018-07-11 18:53:29 +00002117 check_load(sshkey_load_public(filename, &public, NULL),
2118 filename, "certificate");
djm@openbsd.org4e44a792015-09-24 06:15:11 +00002119 debug("certificate file %s type %d", filename,
2120 public ? public->type : -1);
2121 free(options.certificate_files[i]);
2122 options.certificate_files[i] = NULL;
2123 if (public == NULL) {
2124 free(filename);
2125 continue;
2126 }
markus@openbsd.org5467fbc2018-07-11 18:53:29 +00002127 if (!sshkey_is_cert(public)) {
djm@openbsd.org4e44a792015-09-24 06:15:11 +00002128 debug("%s: key %s type %s is not a certificate",
markus@openbsd.org5467fbc2018-07-11 18:53:29 +00002129 __func__, filename, sshkey_type(public));
2130 sshkey_free(public);
djm@openbsd.org4e44a792015-09-24 06:15:11 +00002131 free(filename);
2132 continue;
2133 }
2134 certificate_files[n_certs] = filename;
2135 certificates[n_certs] = public;
djm@openbsd.org3eb7f102018-07-16 07:06:50 +00002136 certificate_file_userprovided[n_certs] =
2137 options.certificate_file_userprovided[i];
djm@openbsd.org4e44a792015-09-24 06:15:11 +00002138 ++n_certs;
2139 }
2140
Damien Miller0a80ca12010-02-27 07:55:05 +11002141 options.num_identity_files = n_ids;
2142 memcpy(options.identity_files, identity_files, sizeof(identity_files));
2143 memcpy(options.identity_keys, identity_keys, sizeof(identity_keys));
djm@openbsd.org3eb7f102018-07-16 07:06:50 +00002144 memcpy(options.identity_file_userprovided,
2145 identity_file_userprovided, sizeof(identity_file_userprovided));
Damien Miller0a80ca12010-02-27 07:55:05 +11002146
djm@openbsd.org4e44a792015-09-24 06:15:11 +00002147 options.num_certificate_files = n_certs;
2148 memcpy(options.certificate_files,
2149 certificate_files, sizeof(certificate_files));
2150 memcpy(options.certificates, certificates, sizeof(certificates));
djm@openbsd.org3eb7f102018-07-16 07:06:50 +00002151 memcpy(options.certificate_file_userprovided,
2152 certificate_file_userprovided,
2153 sizeof(certificate_file_userprovided));
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00002154}
Damien Miller857b02e2010-09-24 22:02:56 +10002155
2156static void
2157main_sigchld_handler(int sig)
2158{
2159 int save_errno = errno;
2160 pid_t pid;
2161 int status;
2162
2163 while ((pid = waitpid(-1, &status, WNOHANG)) > 0 ||
2164 (pid < 0 && errno == EINTR))
2165 ;
Damien Miller857b02e2010-09-24 22:02:56 +10002166 errno = save_errno;
2167}