sshconnect.c revision 256281
133965Sjdp/* $OpenBSD: sshconnect.c,v 1.238 2013/05/17 00:13:14 djm Exp $ */ 2130561Sobrien/* $FreeBSD: stable/10/crypto/openssh/sshconnect.c 255767 2013-09-21 21:36:09Z des $ */ 378828Sobrien/* 433965Sjdp * Author: Tatu Ylonen <ylo@cs.hut.fi> 533965Sjdp * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland 633965Sjdp * All rights reserved 733965Sjdp * Code to connect to a remote host, and to perform the client side of the 833965Sjdp * login (authentication) dialog. 933965Sjdp * 1033965Sjdp * As far as I am concerned, the code I have written for this software 1133965Sjdp * can be used freely for any purpose. Any derived versions of this 1233965Sjdp * software must be clearly marked as such, and if the derived work is 1333965Sjdp * incompatible with the protocol description in the RFC file, it must be 1433965Sjdp * called by a name other than "ssh" or "Secure Shell". 1533965Sjdp */ 1633965Sjdp 1733965Sjdp#include "includes.h" 1833965Sjdp 1933965Sjdp#include <sys/types.h> 2033965Sjdp#include <sys/wait.h> 2133965Sjdp#include <sys/stat.h> 2233965Sjdp#include <sys/socket.h> 2333965Sjdp#ifdef HAVE_SYS_TIME_H 2433965Sjdp# include <sys/time.h> 2533965Sjdp#endif 2633965Sjdp 2733965Sjdp#include <netinet/in.h> 2833965Sjdp#include <arpa/inet.h> 2933965Sjdp 3033965Sjdp#include <ctype.h> 3133965Sjdp#include <errno.h> 3233965Sjdp#include <fcntl.h> 3333965Sjdp#include <netdb.h> 3433965Sjdp#ifdef HAVE_PATHS_H 3533965Sjdp#include <paths.h> 3633965Sjdp#endif 3733965Sjdp#include <pwd.h> 3833965Sjdp#include <signal.h> 3933965Sjdp#include <stdarg.h> 4033965Sjdp#include <stdio.h> 4133965Sjdp#include <stdlib.h> 4233965Sjdp#include <string.h> 4333965Sjdp#include <unistd.h> 4433965Sjdp 4533965Sjdp#include "xmalloc.h" 4633965Sjdp#include "key.h" 4733965Sjdp#include "hostfile.h" 4833965Sjdp#include "ssh.h" 4933965Sjdp#include "rsa.h" 5033965Sjdp#include "buffer.h" 5133965Sjdp#include "packet.h" 5233965Sjdp#include "uidswap.h" 5333965Sjdp#include "compat.h" 5433965Sjdp#include "key.h" 5533965Sjdp#include "sshconnect.h" 5633965Sjdp#include "hostfile.h" 5733965Sjdp#include "log.h" 5833965Sjdp#include "readconf.h" 5933965Sjdp#include "atomicio.h" 6033965Sjdp#include "misc.h" 6133965Sjdp#include "dns.h" 6233965Sjdp#include "roaming.h" 6333965Sjdp#include "ssh2.h" 6433965Sjdp#include "version.h" 6533965Sjdp 6633965Sjdpchar *client_version_string = NULL; 6733965Sjdpchar *server_version_string = NULL; 6833965Sjdp 6933965Sjdpstatic int matching_host_key_dns = 0; 70130561Sobrien 7133965Sjdpstatic pid_t proxy_command_pid = 0; 7233965Sjdp 7333965Sjdp/* import */ 7433965Sjdpextern Options options; 7533965Sjdpextern char *__progname; 7633965Sjdpextern uid_t original_real_uid; 7760484Sobrienextern uid_t original_effective_uid; 7833965Sjdp 7933965Sjdpstatic int show_other_keys(struct hostkeys *, Key *); 8033965Sjdpstatic void warn_changed_key(Key *); 8133965Sjdp 8233965Sjdp/* 8333965Sjdp * Connect to the given ssh server using a proxy command. 8433965Sjdp */ 8533965Sjdpstatic int 8633965Sjdpssh_proxy_connect(const char *host, u_short port, const char *proxy_command) 8733965Sjdp{ 8833965Sjdp char *command_string, *tmp; 8933965Sjdp int pin[2], pout[2]; 9033965Sjdp pid_t pid; 9133965Sjdp char *shell, strport[NI_MAXSERV]; 9233965Sjdp 9333965Sjdp if (!strcmp(proxy_command, "-")) { 9433965Sjdp packet_set_connection(STDIN_FILENO, STDOUT_FILENO); 9533965Sjdp packet_set_timeout(options.server_alive_interval, 9633965Sjdp options.server_alive_count_max); 9733965Sjdp return 0; 9833965Sjdp } 99130561Sobrien 10033965Sjdp if ((shell = getenv("SHELL")) == NULL || *shell == '\0') 10133965Sjdp shell = _PATH_BSHELL; 10233965Sjdp 10333965Sjdp /* Convert the port number into a string. */ 10433965Sjdp snprintf(strport, sizeof strport, "%hu", port); 10533965Sjdp 106130561Sobrien /* 10733965Sjdp * Build the final command string in the buffer by making the 10833965Sjdp * appropriate substitutions to the given proxy command. 10933965Sjdp * 11033965Sjdp * Use "exec" to avoid "sh -c" processes on some platforms 11133965Sjdp * (e.g. Solaris) 11233965Sjdp */ 113130561Sobrien xasprintf(&tmp, "exec %s", proxy_command); 11433965Sjdp command_string = percent_expand(tmp, "h", host, "p", strport, 11533965Sjdp "r", options.user, (char *)NULL); 116130561Sobrien free(tmp); 11733965Sjdp 11833965Sjdp /* Create pipes for communicating with the proxy. */ 11933965Sjdp if (pipe(pin) < 0 || pipe(pout) < 0) 12033965Sjdp fatal("Could not create pipes to communicate with the proxy: %.100s", 12133965Sjdp strerror(errno)); 12233965Sjdp 12333965Sjdp debug("Executing proxy command: %.500s", command_string); 12433965Sjdp 12533965Sjdp /* Fork and execute the proxy command. */ 12633965Sjdp if ((pid = fork()) == 0) { 12733965Sjdp char *argv[10]; 12833965Sjdp 12933965Sjdp /* Child. Permanently give up superuser privileges. */ 13033965Sjdp permanently_drop_suid(original_real_uid); 13133965Sjdp 13233965Sjdp /* Redirect stdin and stdout. */ 13333965Sjdp close(pin[1]); 13433965Sjdp if (pin[0] != 0) { 13533965Sjdp if (dup2(pin[0], 0) < 0) 136130561Sobrien perror("dup2 stdin"); 13733965Sjdp close(pin[0]); 13833965Sjdp } 13933965Sjdp close(pout[0]); 14033965Sjdp if (dup2(pout[1], 1) < 0) 14133965Sjdp perror("dup2 stdout"); 14233965Sjdp /* Cannot be 1 because pin allocated two descriptors. */ 14333965Sjdp close(pout[1]); 14433965Sjdp 14533965Sjdp /* Stderr is left as it is so that error messages get 14633965Sjdp printed on the user's terminal. */ 14733965Sjdp argv[0] = shell; 14833965Sjdp argv[1] = "-c"; 14933965Sjdp argv[2] = command_string; 15033965Sjdp argv[3] = NULL; 15133965Sjdp 15233965Sjdp /* Execute the proxy command. Note that we gave up any 15333965Sjdp extra privileges above. */ 15433965Sjdp signal(SIGPIPE, SIG_DFL); 15533965Sjdp execv(argv[0], argv); 15633965Sjdp perror(argv[0]); 15733965Sjdp exit(1); 15833965Sjdp } 15933965Sjdp /* Parent. */ 16033965Sjdp if (pid < 0) 16133965Sjdp fatal("fork failed: %.100s", strerror(errno)); 16233965Sjdp else 16333965Sjdp proxy_command_pid = pid; /* save pid to clean up later */ 16433965Sjdp 16533965Sjdp /* Close child side of the descriptors. */ 16633965Sjdp close(pin[0]); 16733965Sjdp close(pout[1]); 16833965Sjdp 16933965Sjdp /* Free the command name. */ 17033965Sjdp free(command_string); 17133965Sjdp 17233965Sjdp /* Set the connection file descriptors. */ 17333965Sjdp packet_set_connection(pout[0], pin[1]); 17433965Sjdp packet_set_timeout(options.server_alive_interval, 17533965Sjdp options.server_alive_count_max); 17633965Sjdp 17733965Sjdp /* Indicate OK return */ 17833965Sjdp return 0; 17933965Sjdp} 18033965Sjdp 18133965Sjdpvoid 18233965Sjdpssh_kill_proxy_command(void) 18333965Sjdp{ 18433965Sjdp /* 18533965Sjdp * Send SIGHUP to proxy command if used. We don't wait() in 18633965Sjdp * case it hangs and instead rely on init to reap the child 18733965Sjdp */ 18833965Sjdp if (proxy_command_pid > 1) 18933965Sjdp kill(proxy_command_pid, SIGHUP); 19033965Sjdp} 19133965Sjdp 19233965Sjdp/* 19333965Sjdp * Set TCP receive buffer if requested. 19433965Sjdp * Note: tuning needs to happen after the socket is created but before the 19533965Sjdp * connection happens so winscale is negotiated properly. 19633965Sjdp */ 19733965Sjdpstatic void 19833965Sjdpssh_set_socket_recvbuf(int sock) 19933965Sjdp{ 20033965Sjdp void *buf = (void *)&options.tcp_rcv_buf; 20133965Sjdp int socksize, sz = sizeof(options.tcp_rcv_buf); 20233965Sjdp socklen_t len = sizeof(int); 20333965Sjdp 20433965Sjdp debug("setsockopt attempting to set SO_RCVBUF to %d", 20533965Sjdp options.tcp_rcv_buf); 20633965Sjdp if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, buf, sz) >= 0) { 20733965Sjdp getsockopt(sock, SOL_SOCKET, SO_RCVBUF, &socksize, &len); 20833965Sjdp debug("setsockopt SO_RCVBUF: %.100s %d", strerror(errno), 20933965Sjdp socksize); 21033965Sjdp } else 21133965Sjdp error("Couldn't set socket receive buffer to %d: %.100s", 21233965Sjdp options.tcp_rcv_buf, strerror(errno)); 21333965Sjdp} 21433965Sjdp 21533965Sjdp/* 21633965Sjdp * Creates a (possibly privileged) socket for use as the ssh connection. 21733965Sjdp */ 21833965Sjdpstatic int 21933965Sjdpssh_create_socket(int privileged, struct addrinfo *ai) 22033965Sjdp{ 22133965Sjdp int sock, gaierr; 22233965Sjdp struct addrinfo hints, *res; 22333965Sjdp 22433965Sjdp /* 22533965Sjdp * If we are running as root and want to connect to a privileged 22633965Sjdp * port, bind our own socket to a privileged port. 22733965Sjdp */ 22833965Sjdp if (privileged) { 22933965Sjdp int p = IPPORT_RESERVED - 1; 23033965Sjdp PRIV_START; 23133965Sjdp sock = rresvport_af(&p, ai->ai_family); 23233965Sjdp PRIV_END; 23333965Sjdp if (sock < 0) 23433965Sjdp error("rresvport: af=%d %.100s", ai->ai_family, 23533965Sjdp strerror(errno)); 23633965Sjdp else 23733965Sjdp debug("Allocated local port %d.", p); 23833965Sjdp if (options.tcp_rcv_buf > 0) 23933965Sjdp ssh_set_socket_recvbuf(sock); 24033965Sjdp return sock; 24133965Sjdp } 24233965Sjdp sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol); 24333965Sjdp if (sock < 0) { 24433965Sjdp error("socket: %.100s", strerror(errno)); 24533965Sjdp return -1; 24633965Sjdp } 24733965Sjdp fcntl(sock, F_SETFD, FD_CLOEXEC); 24833965Sjdp 24933965Sjdp if (options.tcp_rcv_buf > 0) 25033965Sjdp ssh_set_socket_recvbuf(sock); 25133965Sjdp 25233965Sjdp /* Bind the socket to an alternative local IP address */ 25333965Sjdp if (options.bind_address == NULL) 25433965Sjdp return sock; 25533965Sjdp 25633965Sjdp memset(&hints, 0, sizeof(hints)); 25733965Sjdp hints.ai_family = ai->ai_family; 25833965Sjdp hints.ai_socktype = ai->ai_socktype; 25933965Sjdp hints.ai_protocol = ai->ai_protocol; 26033965Sjdp hints.ai_flags = AI_PASSIVE; 26133965Sjdp gaierr = getaddrinfo(options.bind_address, NULL, &hints, &res); 26233965Sjdp if (gaierr) { 26333965Sjdp error("getaddrinfo: %s: %s", options.bind_address, 26433965Sjdp ssh_gai_strerror(gaierr)); 26533965Sjdp close(sock); 26633965Sjdp return -1; 26733965Sjdp } 26833965Sjdp if (bind(sock, res->ai_addr, res->ai_addrlen) < 0) { 26933965Sjdp error("bind: %s: %s", options.bind_address, strerror(errno)); 27033965Sjdp close(sock); 27133965Sjdp freeaddrinfo(res); 27277298Sobrien return -1; 27333965Sjdp } 27433965Sjdp freeaddrinfo(res); 27533965Sjdp return sock; 27633965Sjdp} 27733965Sjdp 27833965Sjdpstatic int 27933965Sjdptimeout_connect(int sockfd, const struct sockaddr *serv_addr, 28033965Sjdp socklen_t addrlen, int *timeoutp) 28133965Sjdp{ 28233965Sjdp fd_set *fdset; 28333965Sjdp struct timeval tv, t_start; 28433965Sjdp socklen_t optlen; 28533965Sjdp int optval, rc, result = -1; 28633965Sjdp 28733965Sjdp gettimeofday(&t_start, NULL); 28833965Sjdp 28933965Sjdp if (*timeoutp <= 0) { 29033965Sjdp result = connect(sockfd, serv_addr, addrlen); 29133965Sjdp goto done; 29233965Sjdp } 29333965Sjdp 29433965Sjdp set_nonblock(sockfd); 29533965Sjdp rc = connect(sockfd, serv_addr, addrlen); 29633965Sjdp if (rc == 0) { 29733965Sjdp unset_nonblock(sockfd); 29833965Sjdp result = 0; 29933965Sjdp goto done; 30033965Sjdp } 30133965Sjdp if (errno != EINPROGRESS) { 302130561Sobrien result = -1; 30333965Sjdp goto done; 30433965Sjdp } 30533965Sjdp 30633965Sjdp fdset = (fd_set *)xcalloc(howmany(sockfd + 1, NFDBITS), 30733965Sjdp sizeof(fd_mask)); 30833965Sjdp FD_SET(sockfd, fdset); 30933965Sjdp ms_to_timeval(&tv, *timeoutp); 31033965Sjdp 31133965Sjdp for (;;) { 31233965Sjdp rc = select(sockfd + 1, NULL, fdset, NULL, &tv); 31333965Sjdp if (rc != -1 || errno != EINTR) 31433965Sjdp break; 31533965Sjdp } 31633965Sjdp 31733965Sjdp switch (rc) { 318130561Sobrien case 0: 31933965Sjdp /* Timed out */ 32033965Sjdp errno = ETIMEDOUT; 32133965Sjdp break; 32233965Sjdp case -1: 32333965Sjdp /* Select error */ 32433965Sjdp debug("select: %s", strerror(errno)); 325130561Sobrien break; 32633965Sjdp case 1: 32733965Sjdp /* Completed or failed */ 32833965Sjdp optval = 0; 32933965Sjdp optlen = sizeof(optval); 330130561Sobrien if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &optval, 33133965Sjdp &optlen) == -1) { 33233965Sjdp debug("getsockopt: %s", strerror(errno)); 33333965Sjdp break; 33433965Sjdp } 335130561Sobrien if (optval != 0) { 33633965Sjdp errno = optval; 33733965Sjdp break; 33833965Sjdp } 33933965Sjdp result = 0; 34033965Sjdp unset_nonblock(sockfd); 34133965Sjdp break; 34233965Sjdp default: 34333965Sjdp /* Should not occur */ 34433965Sjdp fatal("Bogus return (%d) from select()", rc); 34533965Sjdp } 34633965Sjdp 34733965Sjdp free(fdset); 34833965Sjdp 34933965Sjdp done: 35033965Sjdp if (result == 0 && *timeoutp > 0) { 35133965Sjdp ms_subtract_diff(&t_start, timeoutp); 35233965Sjdp if (*timeoutp <= 0) { 35333965Sjdp errno = ETIMEDOUT; 35433965Sjdp result = -1; 35533965Sjdp } 35633965Sjdp } 35733965Sjdp 35833965Sjdp return (result); 35933965Sjdp} 36033965Sjdp 361130561Sobrien/* 362130561Sobrien * Opens a TCP/IP connection to the remote server on the given host. 36333965Sjdp * The address of the remote host will be returned in hostaddr. 36433965Sjdp * If port is 0, the default port will be used. If needpriv is true, 36533965Sjdp * a privileged port will be allocated to make the connection. 36633965Sjdp * This requires super-user privileges if needpriv is true. 36733965Sjdp * Connection_attempts specifies the maximum number of tries (one per 36833965Sjdp * second). If proxy_command is non-NULL, it specifies the command (with %h 36933965Sjdp * and %p substituted for host and port, respectively) to use to contact 37077298Sobrien * the daemon. 37133965Sjdp */ 37233965Sjdpint 37333965Sjdpssh_connect(const char *host, struct sockaddr_storage * hostaddr, 37433965Sjdp u_short port, int family, int connection_attempts, int *timeout_ms, 37533965Sjdp int want_keepalive, int needpriv, const char *proxy_command) 37633965Sjdp{ 37733965Sjdp int gaierr; 37833965Sjdp int on = 1; 379104834Sobrien int sock = -1, attempt; 38033965Sjdp char ntop[NI_MAXHOST], strport[NI_MAXSERV]; 38133965Sjdp struct addrinfo hints, *ai, *aitop; 38233965Sjdp 38333965Sjdp debug2("ssh_connect: needpriv %d", needpriv); 38433965Sjdp 38533965Sjdp /* If a proxy command is given, connect using it. */ 38633965Sjdp if (proxy_command != NULL) 38733965Sjdp return ssh_proxy_connect(host, port, proxy_command); 38833965Sjdp 38933965Sjdp /* No proxy command. */ 39033965Sjdp 39133965Sjdp memset(&hints, 0, sizeof(hints)); 39233965Sjdp hints.ai_family = family; 39333965Sjdp hints.ai_socktype = SOCK_STREAM; 39433965Sjdp snprintf(strport, sizeof strport, "%u", port); 39533965Sjdp if ((gaierr = getaddrinfo(host, strport, &hints, &aitop)) != 0) 39633965Sjdp fatal("%s: Could not resolve hostname %.100s: %s", __progname, 39733965Sjdp host, ssh_gai_strerror(gaierr)); 39833965Sjdp 39933965Sjdp for (attempt = 0; attempt < connection_attempts; attempt++) { 40033965Sjdp if (attempt > 0) { 40133965Sjdp /* Sleep a moment before retrying. */ 40233965Sjdp sleep(1); 40333965Sjdp debug("Trying again..."); 40433965Sjdp } 40533965Sjdp /* 40633965Sjdp * Loop through addresses for this host, and try each one in 40733965Sjdp * sequence until the connection succeeds. 40833965Sjdp */ 40933965Sjdp for (ai = aitop; ai; ai = ai->ai_next) { 410104834Sobrien if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6) 41133965Sjdp continue; 41233965Sjdp if (getnameinfo(ai->ai_addr, ai->ai_addrlen, 41333965Sjdp ntop, sizeof(ntop), strport, sizeof(strport), 41433965Sjdp NI_NUMERICHOST|NI_NUMERICSERV) != 0) { 41533965Sjdp error("ssh_connect: getnameinfo failed"); 41633965Sjdp continue; 41733965Sjdp } 41833965Sjdp debug("Connecting to %.200s [%.100s] port %s.", 41933965Sjdp host, ntop, strport); 42033965Sjdp 42133965Sjdp /* Create a socket for connecting. */ 42233965Sjdp sock = ssh_create_socket(needpriv, ai); 42333965Sjdp if (sock < 0) 42433965Sjdp /* Any error is already output */ 42533965Sjdp continue; 42633965Sjdp 42733965Sjdp if (timeout_connect(sock, ai->ai_addr, ai->ai_addrlen, 42833965Sjdp timeout_ms) >= 0) { 42933965Sjdp /* Successful connection. */ 43033965Sjdp memcpy(hostaddr, ai->ai_addr, ai->ai_addrlen); 43133965Sjdp break; 43233965Sjdp } else { 43333965Sjdp debug("connect to address %s port %s: %s", 43433965Sjdp ntop, strport, strerror(errno)); 43533965Sjdp close(sock); 43633965Sjdp sock = -1; 43733965Sjdp } 43833965Sjdp } 43933965Sjdp if (sock != -1) 44033965Sjdp break; /* Successful connection. */ 44133965Sjdp } 44233965Sjdp 44333965Sjdp freeaddrinfo(aitop); 44433965Sjdp 44533965Sjdp /* Return failure if we didn't get a successful connection. */ 44633965Sjdp if (sock == -1) { 44733965Sjdp error("ssh: connect to host %s port %s: %s", 44833965Sjdp host, strport, strerror(errno)); 44933965Sjdp return (-1); 45033965Sjdp } 45133965Sjdp 45233965Sjdp debug("Connection established."); 45360484Sobrien 45433965Sjdp /* Set SO_KEEPALIVE if requested. */ 45533965Sjdp if (want_keepalive && 45633965Sjdp setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (void *)&on, 45733965Sjdp sizeof(on)) < 0) 45833965Sjdp error("setsockopt SO_KEEPALIVE: %.100s", strerror(errno)); 45933965Sjdp 46033965Sjdp /* Set the connection. */ 46133965Sjdp packet_set_connection(sock, sock); 46233965Sjdp packet_set_timeout(options.server_alive_interval, 46333965Sjdp options.server_alive_count_max); 46433965Sjdp 46533965Sjdp return 0; 46633965Sjdp} 46733965Sjdp 46833965Sjdpstatic void 46933965Sjdpsend_client_banner(int connection_out, int minor1) 47033965Sjdp{ 47133965Sjdp /* Send our own protocol version identification. */ 47233965Sjdp xasprintf(&client_version_string, "SSH-%d.%d-%.100s%s%s%s%s", 47333965Sjdp compat20 ? PROTOCOL_MAJOR_2 : PROTOCOL_MAJOR_1, 47433965Sjdp compat20 ? PROTOCOL_MINOR_2 : minor1, 47533965Sjdp SSH_VERSION, options.hpn_disabled ? "" : SSH_VERSION_HPN, 47633965Sjdp *options.version_addendum == '\0' ? "" : " ", 47733965Sjdp options.version_addendum, compat20 ? "\r\n" : "\n"); 47833965Sjdp if (roaming_atomicio(vwrite, connection_out, client_version_string, 47933965Sjdp strlen(client_version_string)) != strlen(client_version_string)) 48033965Sjdp fatal("write: %.100s", strerror(errno)); 481130561Sobrien chop(client_version_string); 48233965Sjdp debug("Local version string %.100s", client_version_string); 48333965Sjdp} 48433965Sjdp 48533965Sjdp/* 48633965Sjdp * Waits for the server identification string, and sends our own 48733965Sjdp * identification string. 48833965Sjdp */ 48933965Sjdpvoid 49033965Sjdpssh_exchange_identification(int timeout_ms) 49133965Sjdp{ 49233965Sjdp char buf[256], remote_version[256]; /* must be same size! */ 49333965Sjdp int remote_major, remote_minor, mismatch; 49433965Sjdp int connection_in = packet_get_connection_in(); 49533965Sjdp int connection_out = packet_get_connection_out(); 49633965Sjdp int minor1 = PROTOCOL_MINOR_1, client_banner_sent = 0; 49733965Sjdp u_int i, n; 49833965Sjdp size_t len; 49933965Sjdp int fdsetsz, remaining, rc; 50033965Sjdp struct timeval t_start, t_remaining; 50133965Sjdp fd_set *fdset; 50233965Sjdp 50333965Sjdp fdsetsz = howmany(connection_in + 1, NFDBITS) * sizeof(fd_mask); 50433965Sjdp fdset = xcalloc(1, fdsetsz); 50533965Sjdp 50633965Sjdp /* 50733965Sjdp * If we are SSH2-only then we can send the banner immediately and 50833965Sjdp * save a round-trip. 50933965Sjdp */ 51033965Sjdp if (options.protocol == SSH_PROTO_2) { 51133965Sjdp enable_compat20(); 51233965Sjdp send_client_banner(connection_out, 0); 51333965Sjdp client_banner_sent = 1; 51433965Sjdp } 51533965Sjdp 51633965Sjdp /* Read other side's version identification. */ 51733965Sjdp remaining = timeout_ms; 51833965Sjdp for (n = 0;;) { 51933965Sjdp for (i = 0; i < sizeof(buf) - 1; i++) { 52033965Sjdp if (timeout_ms > 0) { 52133965Sjdp gettimeofday(&t_start, NULL); 52233965Sjdp ms_to_timeval(&t_remaining, remaining); 52333965Sjdp FD_SET(connection_in, fdset); 52433965Sjdp rc = select(connection_in + 1, fdset, NULL, 52533965Sjdp fdset, &t_remaining); 52633965Sjdp ms_subtract_diff(&t_start, &remaining); 52733965Sjdp if (rc == 0 || remaining <= 0) 52833965Sjdp fatal("Connection timed out during " 52933965Sjdp "banner exchange"); 53033965Sjdp if (rc == -1) { 53133965Sjdp if (errno == EINTR) 53233965Sjdp continue; 53333965Sjdp fatal("ssh_exchange_identification: " 534130561Sobrien "select: %s", strerror(errno)); 53533965Sjdp } 53633965Sjdp } 53733965Sjdp 53833965Sjdp len = roaming_atomicio(read, connection_in, &buf[i], 1); 53933965Sjdp 54033965Sjdp if (len != 1 && errno == EPIPE) 54133965Sjdp fatal("ssh_exchange_identification: " 54233965Sjdp "Connection closed by remote host"); 54333965Sjdp else if (len != 1) 54433965Sjdp fatal("ssh_exchange_identification: " 54533965Sjdp "read: %.100s", strerror(errno)); 54633965Sjdp if (buf[i] == '\r') { 54733965Sjdp buf[i] = '\n'; 54833965Sjdp buf[i + 1] = 0; 54933965Sjdp continue; /**XXX wait for \n */ 55033965Sjdp } 55133965Sjdp if (buf[i] == '\n') { 55233965Sjdp buf[i + 1] = 0; 55333965Sjdp break; 55433965Sjdp } 55533965Sjdp if (++n > 65536) 55633965Sjdp fatal("ssh_exchange_identification: " 55733965Sjdp "No banner received"); 55833965Sjdp } 55933965Sjdp buf[sizeof(buf) - 1] = 0; 56033965Sjdp if (strncmp(buf, "SSH-", 4) == 0) 56133965Sjdp break; 56233965Sjdp debug("ssh_exchange_identification: %s", buf); 56333965Sjdp } 56433965Sjdp server_version_string = xstrdup(buf); 56533965Sjdp free(fdset); 56633965Sjdp 56733965Sjdp /* 56833965Sjdp * Check that the versions match. In future this might accept 56933965Sjdp * several versions and set appropriate flags to handle them. 57033965Sjdp */ 57133965Sjdp if (sscanf(server_version_string, "SSH-%d.%d-%[^\n]\n", 57233965Sjdp &remote_major, &remote_minor, remote_version) != 3) 57333965Sjdp fatal("Bad remote protocol version identification: '%.100s'", buf); 57433965Sjdp debug("Remote protocol version %d.%d, remote software version %.100s", 57533965Sjdp remote_major, remote_minor, remote_version); 57633965Sjdp 57733965Sjdp compat_datafellows(remote_version); 57833965Sjdp mismatch = 0; 57933965Sjdp 58033965Sjdp switch (remote_major) { 58133965Sjdp case 1: 58233965Sjdp if (remote_minor == 99 && 58333965Sjdp (options.protocol & SSH_PROTO_2) && 58489857Sobrien !(options.protocol & SSH_PROTO_1_PREFERRED)) { 58533965Sjdp enable_compat20(); 58689857Sobrien break; 58733965Sjdp } 58833965Sjdp if (!(options.protocol & SSH_PROTO_1)) { 58933965Sjdp mismatch = 1; 59033965Sjdp break; 59133965Sjdp } 59233965Sjdp if (remote_minor < 3) { 59333965Sjdp fatal("Remote machine has too old SSH software version."); 59433965Sjdp } else if (remote_minor == 3 || remote_minor == 4) { 59533965Sjdp /* We speak 1.3, too. */ 59633965Sjdp enable_compat13(); 59733965Sjdp minor1 = 3; 59833965Sjdp if (options.forward_agent) { 599130561Sobrien logit("Agent forwarding disabled for protocol 1.3"); 60033965Sjdp options.forward_agent = 0; 60133965Sjdp } 60233965Sjdp } 60333965Sjdp break; 60433965Sjdp case 2: 60533965Sjdp if (options.protocol & SSH_PROTO_2) { 60633965Sjdp enable_compat20(); 60733965Sjdp break; 60833965Sjdp } 60933965Sjdp /* FALLTHROUGH */ 61033965Sjdp default: 61133965Sjdp mismatch = 1; 61233965Sjdp break; 61333965Sjdp } 61433965Sjdp if (mismatch) 615130561Sobrien fatal("Protocol major versions differ: %d vs. %d", 61633965Sjdp (options.protocol & SSH_PROTO_2) ? PROTOCOL_MAJOR_2 : PROTOCOL_MAJOR_1, 61733965Sjdp remote_major); 61833965Sjdp if (!client_banner_sent) 61933965Sjdp send_client_banner(connection_out, minor1); 62033965Sjdp chop(server_version_string); 62133965Sjdp} 62233965Sjdp 62333965Sjdp/* defaults to 'no' */ 62433965Sjdpstatic int 62533965Sjdpconfirm(const char *prompt) 62633965Sjdp{ 62733965Sjdp const char *msg, *again = "Please type 'yes' or 'no': "; 62833965Sjdp char *p; 62933965Sjdp int ret = -1; 630130561Sobrien 63133965Sjdp if (options.batch_mode) 63233965Sjdp return 0; 63333965Sjdp for (msg = prompt;;msg = again) { 63433965Sjdp p = read_passphrase(msg, RP_ECHO); 63533965Sjdp if (p == NULL || 63633965Sjdp (p[0] == '\0') || (p[0] == '\n') || 637130561Sobrien strncasecmp(p, "no", 2) == 0) 638130561Sobrien ret = 0; 63933965Sjdp if (p && strncasecmp(p, "yes", 3) == 0) 64033965Sjdp ret = 1; 64133965Sjdp free(p); 64233965Sjdp if (ret != -1) 64333965Sjdp return ret; 644130561Sobrien } 64533965Sjdp} 64633965Sjdp 64733965Sjdpstatic int 64833965Sjdpcheck_host_cert(const char *host, const Key *host_key) 64933965Sjdp{ 65033965Sjdp const char *reason; 65133965Sjdp 65233965Sjdp if (key_cert_check_authority(host_key, 1, 0, host, &reason) != 0) { 65333965Sjdp error("%s", reason); 65433965Sjdp return 0; 65533965Sjdp } 65633965Sjdp if (buffer_len(&host_key->cert->critical) != 0) { 65733965Sjdp error("Certificate for %s contains unsupported " 65833965Sjdp "critical options(s)", host); 65933965Sjdp return 0; 66033965Sjdp } 66133965Sjdp return 1; 66233965Sjdp} 66333965Sjdp 66433965Sjdpstatic int 66533965Sjdpsockaddr_is_local(struct sockaddr *hostaddr) 66633965Sjdp{ 66733965Sjdp switch (hostaddr->sa_family) { 66833965Sjdp case AF_INET: 66933965Sjdp return (ntohl(((struct sockaddr_in *)hostaddr)-> 67033965Sjdp sin_addr.s_addr) >> 24) == IN_LOOPBACKNET; 67133965Sjdp case AF_INET6: 67233965Sjdp return IN6_IS_ADDR_LOOPBACK( 67333965Sjdp &(((struct sockaddr_in6 *)hostaddr)->sin6_addr)); 67433965Sjdp default: 67533965Sjdp return 0; 67633965Sjdp } 67733965Sjdp} 67833965Sjdp 67933965Sjdp/* 68033965Sjdp * Prepare the hostname and ip address strings that are used to lookup 68133965Sjdp * host keys in known_hosts files. These may have a port number appended. 68233965Sjdp */ 68333965Sjdpvoid 68433965Sjdpget_hostfile_hostname_ipaddr(char *hostname, struct sockaddr *hostaddr, 68533965Sjdp u_short port, char **hostfile_hostname, char **hostfile_ipaddr) 68633965Sjdp{ 68733965Sjdp char ntop[NI_MAXHOST]; 68833965Sjdp socklen_t addrlen; 68933965Sjdp 69033965Sjdp switch (hostaddr == NULL ? -1 : hostaddr->sa_family) { 69133965Sjdp case -1: 69233965Sjdp addrlen = 0; 69333965Sjdp break; 69433965Sjdp case AF_INET: 69533965Sjdp addrlen = sizeof(struct sockaddr_in); 69633965Sjdp break; 69733965Sjdp case AF_INET6: 69833965Sjdp addrlen = sizeof(struct sockaddr_in6); 69933965Sjdp break; 70033965Sjdp default: 701130561Sobrien addrlen = sizeof(struct sockaddr); 70233965Sjdp break; 70333965Sjdp } 70433965Sjdp 70533965Sjdp /* 706130561Sobrien * We don't have the remote ip-address for connections 70733965Sjdp * using a proxy command 70833965Sjdp */ 70933965Sjdp if (hostfile_ipaddr != NULL) { 71033965Sjdp if (options.proxy_command == NULL) { 71133965Sjdp if (getnameinfo(hostaddr, addrlen, 71233965Sjdp ntop, sizeof(ntop), NULL, 0, NI_NUMERICHOST) != 0) 71389857Sobrien fatal("check_host_key: getnameinfo failed"); 71489857Sobrien *hostfile_ipaddr = put_host_port(ntop, port); 71533965Sjdp } else { 71633965Sjdp *hostfile_ipaddr = xstrdup("<no hostip for proxy " 71733965Sjdp "command>"); 71833965Sjdp } 71933965Sjdp } 72033965Sjdp 72133965Sjdp /* 72233965Sjdp * Allow the user to record the key under a different name or 72333965Sjdp * differentiate a non-standard port. This is useful for ssh 72489857Sobrien * tunneling over forwarded connections or if you run multiple 72589857Sobrien * sshd's on different ports on the same machine. 726130561Sobrien */ 72733965Sjdp if (hostfile_hostname != NULL) { 72833965Sjdp if (options.host_key_alias != NULL) { 72989857Sobrien *hostfile_hostname = xstrdup(options.host_key_alias); 730130561Sobrien debug("using hostkeyalias: %s", *hostfile_hostname); 73133965Sjdp } else { 73233965Sjdp *hostfile_hostname = put_host_port(hostname, port); 733130561Sobrien } 73433965Sjdp } 735} 736 737/* 738 * check whether the supplied host key is valid, return -1 if the key 739 * is not valid. user_hostfile[0] will not be updated if 'readonly' is true. 740 */ 741#define RDRW 0 742#define RDONLY 1 743#define ROQUIET 2 744static int 745check_host_key(char *hostname, struct sockaddr *hostaddr, u_short port, 746 Key *host_key, int readonly, 747 char **user_hostfiles, u_int num_user_hostfiles, 748 char **system_hostfiles, u_int num_system_hostfiles) 749{ 750 HostStatus host_status; 751 HostStatus ip_status; 752 Key *raw_key = NULL; 753 char *ip = NULL, *host = NULL; 754 char hostline[1000], *hostp, *fp, *ra; 755 char msg[1024]; 756 const char *type; 757 const struct hostkey_entry *host_found, *ip_found; 758 int len, cancelled_forwarding = 0; 759 int local = sockaddr_is_local(hostaddr); 760 int r, want_cert = key_is_cert(host_key), host_ip_differ = 0; 761 struct hostkeys *host_hostkeys, *ip_hostkeys; 762 u_int i; 763 764 /* 765 * Force accepting of the host key for loopback/localhost. The 766 * problem is that if the home directory is NFS-mounted to multiple 767 * machines, localhost will refer to a different machine in each of 768 * them, and the user will get bogus HOST_CHANGED warnings. This 769 * essentially disables host authentication for localhost; however, 770 * this is probably not a real problem. 771 */ 772 if (options.no_host_authentication_for_localhost == 1 && local && 773 options.host_key_alias == NULL) { 774 debug("Forcing accepting of host key for " 775 "loopback/localhost."); 776 return 0; 777 } 778 779 /* 780 * Prepare the hostname and address strings used for hostkey lookup. 781 * In some cases, these will have a port number appended. 782 */ 783 get_hostfile_hostname_ipaddr(hostname, hostaddr, port, &host, &ip); 784 785 /* 786 * Turn off check_host_ip if the connection is to localhost, via proxy 787 * command or if we don't have a hostname to compare with 788 */ 789 if (options.check_host_ip && (local || 790 strcmp(hostname, ip) == 0 || options.proxy_command != NULL)) 791 options.check_host_ip = 0; 792 793 host_hostkeys = init_hostkeys(); 794 for (i = 0; i < num_user_hostfiles; i++) 795 load_hostkeys(host_hostkeys, host, user_hostfiles[i]); 796 for (i = 0; i < num_system_hostfiles; i++) 797 load_hostkeys(host_hostkeys, host, system_hostfiles[i]); 798 799 ip_hostkeys = NULL; 800 if (!want_cert && options.check_host_ip) { 801 ip_hostkeys = init_hostkeys(); 802 for (i = 0; i < num_user_hostfiles; i++) 803 load_hostkeys(ip_hostkeys, ip, user_hostfiles[i]); 804 for (i = 0; i < num_system_hostfiles; i++) 805 load_hostkeys(ip_hostkeys, ip, system_hostfiles[i]); 806 } 807 808 retry: 809 /* Reload these as they may have changed on cert->key downgrade */ 810 want_cert = key_is_cert(host_key); 811 type = key_type(host_key); 812 813 /* 814 * Check if the host key is present in the user's list of known 815 * hosts or in the systemwide list. 816 */ 817 host_status = check_key_in_hostkeys(host_hostkeys, host_key, 818 &host_found); 819 820 /* 821 * Also perform check for the ip address, skip the check if we are 822 * localhost, looking for a certificate, or the hostname was an ip 823 * address to begin with. 824 */ 825 if (!want_cert && ip_hostkeys != NULL) { 826 ip_status = check_key_in_hostkeys(ip_hostkeys, host_key, 827 &ip_found); 828 if (host_status == HOST_CHANGED && 829 (ip_status != HOST_CHANGED || 830 (ip_found != NULL && 831 !key_equal(ip_found->key, host_found->key)))) 832 host_ip_differ = 1; 833 } else 834 ip_status = host_status; 835 836 switch (host_status) { 837 case HOST_OK: 838 /* The host is known and the key matches. */ 839 debug("Host '%.200s' is known and matches the %s host %s.", 840 host, type, want_cert ? "certificate" : "key"); 841 debug("Found %s in %s:%lu", want_cert ? "CA key" : "key", 842 host_found->file, host_found->line); 843 if (want_cert && !check_host_cert(hostname, host_key)) 844 goto fail; 845 if (options.check_host_ip && ip_status == HOST_NEW) { 846 if (readonly || want_cert) 847 logit("%s host key for IP address " 848 "'%.128s' not in list of known hosts.", 849 type, ip); 850 else if (!add_host_to_hostfile(user_hostfiles[0], ip, 851 host_key, options.hash_known_hosts)) 852 logit("Failed to add the %s host key for IP " 853 "address '%.128s' to the list of known " 854 "hosts (%.30s).", type, ip, 855 user_hostfiles[0]); 856 else 857 logit("Warning: Permanently added the %s host " 858 "key for IP address '%.128s' to the list " 859 "of known hosts.", type, ip); 860 } else if (options.visual_host_key) { 861 fp = key_fingerprint(host_key, SSH_FP_MD5, SSH_FP_HEX); 862 ra = key_fingerprint(host_key, SSH_FP_MD5, 863 SSH_FP_RANDOMART); 864 logit("Host key fingerprint is %s\n%s\n", fp, ra); 865 free(ra); 866 free(fp); 867 } 868 break; 869 case HOST_NEW: 870 if (options.host_key_alias == NULL && port != 0 && 871 port != SSH_DEFAULT_PORT) { 872 debug("checking without port identifier"); 873 if (check_host_key(hostname, hostaddr, 0, host_key, 874 ROQUIET, user_hostfiles, num_user_hostfiles, 875 system_hostfiles, num_system_hostfiles) == 0) { 876 debug("found matching key w/out port"); 877 break; 878 } 879 } 880 if (readonly || want_cert) 881 goto fail; 882 /* The host is new. */ 883 if (options.strict_host_key_checking == 1) { 884 /* 885 * User has requested strict host key checking. We 886 * will not add the host key automatically. The only 887 * alternative left is to abort. 888 */ 889 error("No %s host key is known for %.200s and you " 890 "have requested strict checking.", type, host); 891 goto fail; 892 } else if (options.strict_host_key_checking == 2) { 893 char msg1[1024], msg2[1024]; 894 895 if (show_other_keys(host_hostkeys, host_key)) 896 snprintf(msg1, sizeof(msg1), 897 "\nbut keys of different type are already" 898 " known for this host."); 899 else 900 snprintf(msg1, sizeof(msg1), "."); 901 /* The default */ 902 fp = key_fingerprint(host_key, SSH_FP_MD5, SSH_FP_HEX); 903 ra = key_fingerprint(host_key, SSH_FP_MD5, 904 SSH_FP_RANDOMART); 905 msg2[0] = '\0'; 906 if (options.verify_host_key_dns) { 907 if (matching_host_key_dns) 908 snprintf(msg2, sizeof(msg2), 909 "Matching host key fingerprint" 910 " found in DNS.\n"); 911 else 912 snprintf(msg2, sizeof(msg2), 913 "No matching host key fingerprint" 914 " found in DNS.\n"); 915 } 916 snprintf(msg, sizeof(msg), 917 "The authenticity of host '%.200s (%s)' can't be " 918 "established%s\n" 919 "%s key fingerprint is %s.%s%s\n%s" 920 "Are you sure you want to continue connecting " 921 "(yes/no)? ", 922 host, ip, msg1, type, fp, 923 options.visual_host_key ? "\n" : "", 924 options.visual_host_key ? ra : "", 925 msg2); 926 free(ra); 927 free(fp); 928 if (!confirm(msg)) 929 goto fail; 930 } 931 /* 932 * If not in strict mode, add the key automatically to the 933 * local known_hosts file. 934 */ 935 if (options.check_host_ip && ip_status == HOST_NEW) { 936 snprintf(hostline, sizeof(hostline), "%s,%s", host, ip); 937 hostp = hostline; 938 if (options.hash_known_hosts) { 939 /* Add hash of host and IP separately */ 940 r = add_host_to_hostfile(user_hostfiles[0], 941 host, host_key, options.hash_known_hosts) && 942 add_host_to_hostfile(user_hostfiles[0], ip, 943 host_key, options.hash_known_hosts); 944 } else { 945 /* Add unhashed "host,ip" */ 946 r = add_host_to_hostfile(user_hostfiles[0], 947 hostline, host_key, 948 options.hash_known_hosts); 949 } 950 } else { 951 r = add_host_to_hostfile(user_hostfiles[0], host, 952 host_key, options.hash_known_hosts); 953 hostp = host; 954 } 955 956 if (!r) 957 logit("Failed to add the host to the list of known " 958 "hosts (%.500s).", user_hostfiles[0]); 959 else 960 logit("Warning: Permanently added '%.200s' (%s) to the " 961 "list of known hosts.", hostp, type); 962 break; 963 case HOST_REVOKED: 964 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); 965 error("@ WARNING: REVOKED HOST KEY DETECTED! @"); 966 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); 967 error("The %s host key for %s is marked as revoked.", type, host); 968 error("This could mean that a stolen key is being used to"); 969 error("impersonate this host."); 970 971 /* 972 * If strict host key checking is in use, the user will have 973 * to edit the key manually and we can only abort. 974 */ 975 if (options.strict_host_key_checking) { 976 error("%s host key for %.200s was revoked and you have " 977 "requested strict checking.", type, host); 978 goto fail; 979 } 980 goto continue_unsafe; 981 982 case HOST_CHANGED: 983 if (want_cert) { 984 /* 985 * This is only a debug() since it is valid to have 986 * CAs with wildcard DNS matches that don't match 987 * all hosts that one might visit. 988 */ 989 debug("Host certificate authority does not " 990 "match %s in %s:%lu", CA_MARKER, 991 host_found->file, host_found->line); 992 goto fail; 993 } 994 if (readonly == ROQUIET) 995 goto fail; 996 if (options.check_host_ip && host_ip_differ) { 997 char *key_msg; 998 if (ip_status == HOST_NEW) 999 key_msg = "is unknown"; 1000 else if (ip_status == HOST_OK) 1001 key_msg = "is unchanged"; 1002 else 1003 key_msg = "has a different value"; 1004 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); 1005 error("@ WARNING: POSSIBLE DNS SPOOFING DETECTED! @"); 1006 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); 1007 error("The %s host key for %s has changed,", type, host); 1008 error("and the key for the corresponding IP address %s", ip); 1009 error("%s. This could either mean that", key_msg); 1010 error("DNS SPOOFING is happening or the IP address for the host"); 1011 error("and its host key have changed at the same time."); 1012 if (ip_status != HOST_NEW) 1013 error("Offending key for IP in %s:%lu", 1014 ip_found->file, ip_found->line); 1015 } 1016 /* The host key has changed. */ 1017 warn_changed_key(host_key); 1018 error("Add correct host key in %.100s to get rid of this message.", 1019 user_hostfiles[0]); 1020 error("Offending %s key in %s:%lu", key_type(host_found->key), 1021 host_found->file, host_found->line); 1022 1023 /* 1024 * If strict host key checking is in use, the user will have 1025 * to edit the key manually and we can only abort. 1026 */ 1027 if (options.strict_host_key_checking) { 1028 error("%s host key for %.200s has changed and you have " 1029 "requested strict checking.", type, host); 1030 goto fail; 1031 } 1032 1033 continue_unsafe: 1034 /* 1035 * If strict host key checking has not been requested, allow 1036 * the connection but without MITM-able authentication or 1037 * forwarding. 1038 */ 1039 if (options.password_authentication) { 1040 error("Password authentication is disabled to avoid " 1041 "man-in-the-middle attacks."); 1042 options.password_authentication = 0; 1043 cancelled_forwarding = 1; 1044 } 1045 if (options.kbd_interactive_authentication) { 1046 error("Keyboard-interactive authentication is disabled" 1047 " to avoid man-in-the-middle attacks."); 1048 options.kbd_interactive_authentication = 0; 1049 options.challenge_response_authentication = 0; 1050 cancelled_forwarding = 1; 1051 } 1052 if (options.challenge_response_authentication) { 1053 error("Challenge/response authentication is disabled" 1054 " to avoid man-in-the-middle attacks."); 1055 options.challenge_response_authentication = 0; 1056 cancelled_forwarding = 1; 1057 } 1058 if (options.forward_agent) { 1059 error("Agent forwarding is disabled to avoid " 1060 "man-in-the-middle attacks."); 1061 options.forward_agent = 0; 1062 cancelled_forwarding = 1; 1063 } 1064 if (options.forward_x11) { 1065 error("X11 forwarding is disabled to avoid " 1066 "man-in-the-middle attacks."); 1067 options.forward_x11 = 0; 1068 cancelled_forwarding = 1; 1069 } 1070 if (options.num_local_forwards > 0 || 1071 options.num_remote_forwards > 0) { 1072 error("Port forwarding is disabled to avoid " 1073 "man-in-the-middle attacks."); 1074 options.num_local_forwards = 1075 options.num_remote_forwards = 0; 1076 cancelled_forwarding = 1; 1077 } 1078 if (options.tun_open != SSH_TUNMODE_NO) { 1079 error("Tunnel forwarding is disabled to avoid " 1080 "man-in-the-middle attacks."); 1081 options.tun_open = SSH_TUNMODE_NO; 1082 cancelled_forwarding = 1; 1083 } 1084 if (options.exit_on_forward_failure && cancelled_forwarding) 1085 fatal("Error: forwarding disabled due to host key " 1086 "check failure"); 1087 1088 /* 1089 * XXX Should permit the user to change to use the new id. 1090 * This could be done by converting the host key to an 1091 * identifying sentence, tell that the host identifies itself 1092 * by that sentence, and ask the user if he/she wishes to 1093 * accept the authentication. 1094 */ 1095 break; 1096 case HOST_FOUND: 1097 fatal("internal error"); 1098 break; 1099 } 1100 1101 if (options.check_host_ip && host_status != HOST_CHANGED && 1102 ip_status == HOST_CHANGED) { 1103 snprintf(msg, sizeof(msg), 1104 "Warning: the %s host key for '%.200s' " 1105 "differs from the key for the IP address '%.128s'" 1106 "\nOffending key for IP in %s:%lu", 1107 type, host, ip, ip_found->file, ip_found->line); 1108 if (host_status == HOST_OK) { 1109 len = strlen(msg); 1110 snprintf(msg + len, sizeof(msg) - len, 1111 "\nMatching host key in %s:%lu", 1112 host_found->file, host_found->line); 1113 } 1114 if (options.strict_host_key_checking == 1) { 1115 logit("%s", msg); 1116 error("Exiting, you have requested strict checking."); 1117 goto fail; 1118 } else if (options.strict_host_key_checking == 2) { 1119 strlcat(msg, "\nAre you sure you want " 1120 "to continue connecting (yes/no)? ", sizeof(msg)); 1121 if (!confirm(msg)) 1122 goto fail; 1123 } else { 1124 logit("%s", msg); 1125 } 1126 } 1127 1128 free(ip); 1129 free(host); 1130 if (host_hostkeys != NULL) 1131 free_hostkeys(host_hostkeys); 1132 if (ip_hostkeys != NULL) 1133 free_hostkeys(ip_hostkeys); 1134 return 0; 1135 1136fail: 1137 if (want_cert && host_status != HOST_REVOKED) { 1138 /* 1139 * No matching certificate. Downgrade cert to raw key and 1140 * search normally. 1141 */ 1142 debug("No matching CA found. Retry with plain key"); 1143 raw_key = key_from_private(host_key); 1144 if (key_drop_cert(raw_key) != 0) 1145 fatal("Couldn't drop certificate"); 1146 host_key = raw_key; 1147 goto retry; 1148 } 1149 if (raw_key != NULL) 1150 key_free(raw_key); 1151 free(ip); 1152 free(host); 1153 if (host_hostkeys != NULL) 1154 free_hostkeys(host_hostkeys); 1155 if (ip_hostkeys != NULL) 1156 free_hostkeys(ip_hostkeys); 1157 return -1; 1158} 1159 1160/* returns 0 if key verifies or -1 if key does NOT verify */ 1161int 1162verify_host_key(char *host, struct sockaddr *hostaddr, Key *host_key) 1163{ 1164 int flags = 0; 1165 char *fp; 1166 1167 fp = key_fingerprint(host_key, SSH_FP_MD5, SSH_FP_HEX); 1168 debug("Server host key: %s %s", key_type(host_key), fp); 1169 free(fp); 1170 1171 /* XXX certs are not yet supported for DNS */ 1172 if (!key_is_cert(host_key) && options.verify_host_key_dns && 1173 verify_host_key_dns(host, hostaddr, host_key, &flags) == 0) { 1174 if (flags & DNS_VERIFY_FOUND) { 1175 1176 if (options.verify_host_key_dns == 1 && 1177 flags & DNS_VERIFY_MATCH && 1178 flags & DNS_VERIFY_SECURE) 1179 return 0; 1180 1181 if (flags & DNS_VERIFY_MATCH) { 1182 matching_host_key_dns = 1; 1183 } else { 1184 warn_changed_key(host_key); 1185 error("Update the SSHFP RR in DNS with the new " 1186 "host key to get rid of this message."); 1187 } 1188 } 1189 } 1190 1191 return check_host_key(host, hostaddr, options.port, host_key, RDRW, 1192 options.user_hostfiles, options.num_user_hostfiles, 1193 options.system_hostfiles, options.num_system_hostfiles); 1194} 1195 1196/* 1197 * Starts a dialog with the server, and authenticates the current user on the 1198 * server. This does not need any extra privileges. The basic connection 1199 * to the server must already have been established before this is called. 1200 * If login fails, this function prints an error and never returns. 1201 * This function does not require super-user privileges. 1202 */ 1203void 1204ssh_login(Sensitive *sensitive, const char *orighost, 1205 struct sockaddr *hostaddr, u_short port, struct passwd *pw, int timeout_ms) 1206{ 1207 char *host, *cp; 1208 char *server_user, *local_user; 1209 1210 local_user = xstrdup(pw->pw_name); 1211 server_user = options.user ? options.user : local_user; 1212 1213 /* Convert the user-supplied hostname into all lowercase. */ 1214 host = xstrdup(orighost); 1215 for (cp = host; *cp; cp++) 1216 if (isupper(*cp)) 1217 *cp = (char)tolower(*cp); 1218 1219 /* Exchange protocol version identification strings with the server. */ 1220 ssh_exchange_identification(timeout_ms); 1221 1222 /* Put the connection into non-blocking mode. */ 1223 packet_set_nonblocking(); 1224 1225 /* key exchange */ 1226 /* authenticate user */ 1227 if (compat20) { 1228 ssh_kex2(host, hostaddr, port); 1229 ssh_userauth2(local_user, server_user, host, sensitive); 1230 } else { 1231 ssh_kex(host, hostaddr); 1232 ssh_userauth1(local_user, server_user, host, sensitive); 1233 } 1234 free(local_user); 1235} 1236 1237void 1238ssh_put_password(char *password) 1239{ 1240 int size; 1241 char *padded; 1242 1243 if (datafellows & SSH_BUG_PASSWORDPAD) { 1244 packet_put_cstring(password); 1245 return; 1246 } 1247 size = roundup(strlen(password) + 1, 32); 1248 padded = xcalloc(1, size); 1249 strlcpy(padded, password, size); 1250 packet_put_string(padded, size); 1251 memset(padded, 0, size); 1252 free(padded); 1253} 1254 1255/* print all known host keys for a given host, but skip keys of given type */ 1256static int 1257show_other_keys(struct hostkeys *hostkeys, Key *key) 1258{ 1259 int type[] = { KEY_RSA1, KEY_RSA, KEY_DSA, KEY_ECDSA, -1}; 1260 int i, ret = 0; 1261 char *fp, *ra; 1262 const struct hostkey_entry *found; 1263 1264 for (i = 0; type[i] != -1; i++) { 1265 if (type[i] == key->type) 1266 continue; 1267 if (!lookup_key_in_hostkeys_by_type(hostkeys, type[i], &found)) 1268 continue; 1269 fp = key_fingerprint(found->key, SSH_FP_MD5, SSH_FP_HEX); 1270 ra = key_fingerprint(found->key, SSH_FP_MD5, SSH_FP_RANDOMART); 1271 logit("WARNING: %s key found for host %s\n" 1272 "in %s:%lu\n" 1273 "%s key fingerprint %s.", 1274 key_type(found->key), 1275 found->host, found->file, found->line, 1276 key_type(found->key), fp); 1277 if (options.visual_host_key) 1278 logit("%s", ra); 1279 free(ra); 1280 free(fp); 1281 ret = 1; 1282 } 1283 return ret; 1284} 1285 1286static void 1287warn_changed_key(Key *host_key) 1288{ 1289 char *fp; 1290 1291 fp = key_fingerprint(host_key, SSH_FP_MD5, SSH_FP_HEX); 1292 1293 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); 1294 error("@ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @"); 1295 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"); 1296 error("IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!"); 1297 error("Someone could be eavesdropping on you right now (man-in-the-middle attack)!"); 1298 error("It is also possible that a host key has just been changed."); 1299 error("The fingerprint for the %s key sent by the remote host is\n%s.", 1300 key_type(host_key), fp); 1301 error("Please contact your system administrator."); 1302 1303 free(fp); 1304} 1305 1306/* 1307 * Execute a local command 1308 */ 1309int 1310ssh_local_cmd(const char *args) 1311{ 1312 char *shell; 1313 pid_t pid; 1314 int status; 1315 void (*osighand)(int); 1316 1317 if (!options.permit_local_command || 1318 args == NULL || !*args) 1319 return (1); 1320 1321 if ((shell = getenv("SHELL")) == NULL || *shell == '\0') 1322 shell = _PATH_BSHELL; 1323 1324 osighand = signal(SIGCHLD, SIG_DFL); 1325 pid = fork(); 1326 if (pid == 0) { 1327 signal(SIGPIPE, SIG_DFL); 1328 debug3("Executing %s -c \"%s\"", shell, args); 1329 execl(shell, shell, "-c", args, (char *)NULL); 1330 error("Couldn't execute %s -c \"%s\": %s", 1331 shell, args, strerror(errno)); 1332 _exit(1); 1333 } else if (pid == -1) 1334 fatal("fork failed: %.100s", strerror(errno)); 1335 while (waitpid(pid, &status, 0) == -1) 1336 if (errno != EINTR) 1337 fatal("Couldn't wait for child: %s", strerror(errno)); 1338 signal(SIGCHLD, osighand); 1339 1340 if (!WIFEXITED(status)) 1341 return (1); 1342 1343 return (WEXITSTATUS(status)); 1344} 1345