crypto/openssh/sshconnect.c

   1 /* $OpenBSD: sshconnect.c,v 1.314 2019/02/27 19:37:01 markus Exp $ */
   2 /*
   3  * Author: Tatu Ylonen <ylo@cs.hut.fi>
   4  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   5  *                    All rights reserved
   6  * Code to connect to a remote host, and to perform the client side of the
   7  * login (authentication) dialog.
   8  *
   9  * As far as I am concerned, the code I have written for this software
  10  * can be used freely for any purpose.  Any derived versions of this
  11  * software must be clearly marked as such, and if the derived work is
  12  * incompatible with the protocol description in the RFC file, it must be
  13  * called by a name other than "ssh" or "Secure Shell".
  14  */
  15
  16 #include "includes.h"
  17
  18 #include <sys/types.h>
  19 #include <sys/wait.h>
  20 #include <sys/stat.h>
  21 #include <sys/socket.h>
  22 #ifdef HAVE_SYS_TIME_H
  23 # include <sys/time.h>
  24 #endif
  25
  26 #include <net/if.h>
  27 #include <netinet/in.h>
  28 #include <arpa/inet.h>
  29
  30 #include <ctype.h>
  31 #include <errno.h>
  32 #include <fcntl.h>
  33 #include <netdb.h>
  34 #ifdef HAVE_PATHS_H
  35 #include <paths.h>
  36 #endif
  37 #include <pwd.h>
  38 #ifdef HAVE_POLL_H
  39 #include <poll.h>
  40 #endif
  41 #include <signal.h>
  42 #include <stdarg.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <unistd.h>
  47 #ifdef HAVE_IFADDRS_H
  48 # include <ifaddrs.h>
  49 #endif
  50
  51 #include "xmalloc.h"
  52 #include "hostfile.h"
  53 #include "ssh.h"
  54 #include "sshbuf.h"
  55 #include "packet.h"
  56 #include "compat.h"
  57 #include "sshkey.h"
  58 #include "sshconnect.h"
  59 #include "hostfile.h"
  60 #include "log.h"
  61 #include "misc.h"
  62 #include "readconf.h"
  63 #include "atomicio.h"
  64 #include "dns.h"
  65 #include "monitor_fdpass.h"
  66 #include "ssh2.h"
  67 #include "version.h"
  68 #include "authfile.h"
  69 #include "ssherr.h"
  70 #include "authfd.h"
  71 #include "kex.h"
  72
  73 struct sshkey *previous_host_key = NULL;
  74
  75 static int matching_host_key_dns = 0;
  76
  77 static pid_t proxy_command_pid = 0;
  78
  79 /* import */
  80 extern int debug_flag;
  81 extern Options options;
  82 extern char *__progname;
  83
  84 static int show_other_keys(struct hostkeys *, struct sshkey *);
  85 static void warn_changed_key(struct sshkey *);
  86
  87 /* Expand a proxy command */
  88 static char *
  89 expand_proxy_command(const char *proxy_command, const char *user,
  90     const char *host, int port)
  91 {
  92         char *tmp, *ret, strport[NI_MAXSERV];
  93
  94         snprintf(strport, sizeof strport, "%d", port);
  95         xasprintf(&tmp, "exec %s", proxy_command);
  96         ret = percent_expand(tmp, "h", host, "p", strport,
  97             "r", options.user, (char *)NULL);
  98         free(tmp);
  99         return ret;
 100 }
 101
 102 static void
 103 stderr_null(void)
 104 {
 105         int devnull;
 106
 107         if ((devnull = open(_PATH_DEVNULL, O_WRONLY)) == -1) {
 108                 error("Can't open %s for stderr redirection: %s",
 109                     _PATH_DEVNULL, strerror(errno));
 110                 return;
 111         }
 112         if (devnull == STDERR_FILENO)
 113                 return;
 114         if (dup2(devnull, STDERR_FILENO) == -1)
 115                 error("Cannot redirect stderr to %s", _PATH_DEVNULL);
 116         if (devnull > STDERR_FILENO)
 117                 close(devnull);
 118 }
 119
 120 /*
 121  * Connect to the given ssh server using a proxy command that passes a
 122  * a connected fd back to us.
 123  */
 124 static int
 125 ssh_proxy_fdpass_connect(struct ssh *ssh, const char *host, u_short port,
 126     const char *proxy_command)
 127 {
 128         char *command_string;
 129         int sp[2], sock;
 130         pid_t pid;
 131         char *shell;
 132
 133         if ((shell = getenv("SHELL")) == NULL)
 134                 shell = _PATH_BSHELL;
 135
 136         if (socketpair(AF_UNIX, SOCK_STREAM, 0, sp) < 0)
 137                 fatal("Could not create socketpair to communicate with "
 138                     "proxy dialer: %.100s", strerror(errno));
 139
 140         command_string = expand_proxy_command(proxy_command, options.user,
 141             host, port);
 142         debug("Executing proxy dialer command: %.500s", command_string);
 143
 144         /* Fork and execute the proxy command. */
 145         if ((pid = fork()) == 0) {
 146                 char *argv[10];
 147
 148                 close(sp[1]);
 149                 /* Redirect stdin and stdout. */
 150                 if (sp[0] != 0) {
 151                         if (dup2(sp[0], 0) < 0)
 152                                 perror("dup2 stdin");
 153                 }
 154                 if (sp[0] != 1) {
 155                         if (dup2(sp[0], 1) < 0)
 156                                 perror("dup2 stdout");
 157                 }
 158                 if (sp[0] >= 2)
 159                         close(sp[0]);
 160
 161                 /*
 162                  * Stderr is left for non-ControlPersist connections is so
 163                  * error messages may be printed on the user's terminal.
 164                  */
 165                 if (!debug_flag && options.control_path != NULL &&
 166                     options.control_persist)
 167                         stderr_null();
 168
 169                 argv[0] = shell;
 170                 argv[1] = "-c";
 171                 argv[2] = command_string;
 172                 argv[3] = NULL;
 173
 174                 /*
 175                  * Execute the proxy command.
 176                  * Note that we gave up any extra privileges above.
 177                  */
 178                 execv(argv[0], argv);
 179                 perror(argv[0]);
 180                 exit(1);
 181         }
 182         /* Parent. */
 183         if (pid < 0)
 184                 fatal("fork failed: %.100s", strerror(errno));
 185         close(sp[0]);
 186         free(command_string);
 187
 188         if ((sock = mm_receive_fd(sp[1])) == -1)
 189                 fatal("proxy dialer did not pass back a connection");
 190         close(sp[1]);
 191
 192         while (waitpid(pid, NULL, 0) == -1)
 193                 if (errno != EINTR)
 194                         fatal("Couldn't wait for child: %s", strerror(errno));
 195
 196         /* Set the connection file descriptors. */
 197         if (ssh_packet_set_connection(ssh, sock, sock) == NULL)
 198                 return -1; /* ssh_packet_set_connection logs error */
 199
 200         return 0;
 201 }
 202
 203 /*
 204  * Connect to the given ssh server using a proxy command.
 205  */
 206 static int
 207 ssh_proxy_connect(struct ssh *ssh, const char *host, u_short port,
 208     const char *proxy_command)
 209 {
 210         char *command_string;
 211         int pin[2], pout[2];
 212         pid_t pid;
 213         char *shell;
 214
 215         if ((shell = getenv("SHELL")) == NULL || *shell == '\0')
 216                 shell = _PATH_BSHELL;
 217
 218         /* Create pipes for communicating with the proxy. */
 219         if (pipe(pin) < 0 || pipe(pout) < 0)
 220                 fatal("Could not create pipes to communicate with the proxy: %.100s",
 221                     strerror(errno));
 222
 223         command_string = expand_proxy_command(proxy_command, options.user,
 224             host, port);
 225         debug("Executing proxy command: %.500s", command_string);
 226
 227         /* Fork and execute the proxy command. */
 228         if ((pid = fork()) == 0) {
 229                 char *argv[10];
 230
 231                 /* Redirect stdin and stdout. */
 232                 close(pin[1]);
 233                 if (pin[0] != 0) {
 234                         if (dup2(pin[0], 0) < 0)
 235                                 perror("dup2 stdin");
 236                         close(pin[0]);
 237                 }
 238                 close(pout[0]);
 239                 if (dup2(pout[1], 1) < 0)
 240                         perror("dup2 stdout");
 241                 /* Cannot be 1 because pin allocated two descriptors. */
 242                 close(pout[1]);
 243
 244                 /*
 245                  * Stderr is left for non-ControlPersist connections is so
 246                  * error messages may be printed on the user's terminal.
 247                  */
 248                 if (!debug_flag && options.control_path != NULL &&
 249                     options.control_persist)
 250                         stderr_null();
 251
 252                 argv[0] = shell;
 253                 argv[1] = "-c";
 254                 argv[2] = command_string;
 255                 argv[3] = NULL;
 256
 257                 /* Execute the proxy command.  Note that we gave up any
 258                    extra privileges above. */
 259                 signal(SIGPIPE, SIG_DFL);
 260                 execv(argv[0], argv);
 261                 perror(argv[0]);
 262                 exit(1);
 263         }
 264         /* Parent. */
 265         if (pid < 0)
 266                 fatal("fork failed: %.100s", strerror(errno));
 267         else
 268                 proxy_command_pid = pid; /* save pid to clean up later */
 269
 270         /* Close child side of the descriptors. */
 271         close(pin[0]);
 272         close(pout[1]);
 273
 274         /* Free the command name. */
 275         free(command_string);
 276
 277         /* Set the connection file descriptors. */
 278         if (ssh_packet_set_connection(ssh, pout[0], pin[1]) == NULL)
 279                 return -1; /* ssh_packet_set_connection logs error */
 280
 281         return 0;
 282 }
 283
 284 void
 285 ssh_kill_proxy_command(void)
 286 {
 287         /*
 288          * Send SIGHUP to proxy command if used. We don't wait() in
 289          * case it hangs and instead rely on init to reap the child
 290          */
 291         if (proxy_command_pid > 1)
 292                 kill(proxy_command_pid, SIGHUP);
 293 }
 294
 295 #ifdef HAVE_IFADDRS_H
 296 /*
 297  * Search a interface address list (returned from getifaddrs(3)) for an
 298  * address that matches the desired address family on the specified interface.
 299  * Returns 0 and fills in *resultp and *rlenp on success. Returns -1 on failure.
 300  */
 301 static int
 302 check_ifaddrs(const char *ifname, int af, const struct ifaddrs *ifaddrs,
 303     struct sockaddr_storage *resultp, socklen_t *rlenp)
 304 {
 305         struct sockaddr_in6 *sa6;
 306         struct sockaddr_in *sa;
 307         struct in6_addr *v6addr;
 308         const struct ifaddrs *ifa;
 309         int allow_local;
 310
 311         /*
 312          * Prefer addresses that are not loopback or linklocal, but use them
 313          * if nothing else matches.
 314          */
 315         for (allow_local = 0; allow_local < 2; allow_local++) {
 316                 for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
 317                         if (ifa->ifa_addr == NULL || ifa->ifa_name == NULL ||
 318                             (ifa->ifa_flags & IFF_UP) == 0 ||
 319                             ifa->ifa_addr->sa_family != af ||
 320                             strcmp(ifa->ifa_name, options.bind_interface) != 0)
 321                                 continue;
 322                         switch (ifa->ifa_addr->sa_family) {
 323                         case AF_INET:
 324                                 sa = (struct sockaddr_in *)ifa->ifa_addr;
 325                                 if (!allow_local && sa->sin_addr.s_addr ==
 326                                     htonl(INADDR_LOOPBACK))
 327                                         continue;
 328                                 if (*rlenp < sizeof(struct sockaddr_in)) {
 329                                         error("%s: v4 addr doesn't fit",
 330                                             __func__);
 331                                         return -1;
 332                                 }
 333                                 *rlenp = sizeof(struct sockaddr_in);
 334                                 memcpy(resultp, sa, *rlenp);
 335                                 return 0;
 336                         case AF_INET6:
 337                                 sa6 = (struct sockaddr_in6 *)ifa->ifa_addr;
 338                                 v6addr = &sa6->sin6_addr;
 339                                 if (!allow_local &&
 340                                     (IN6_IS_ADDR_LINKLOCAL(v6addr) ||
 341                                     IN6_IS_ADDR_LOOPBACK(v6addr)))
 342                                         continue;
 343                                 if (*rlenp < sizeof(struct sockaddr_in6)) {
 344                                         error("%s: v6 addr doesn't fit",
 345                                             __func__);
 346                                         return -1;
 347                                 }
 348                                 *rlenp = sizeof(struct sockaddr_in6);
 349                                 memcpy(resultp, sa6, *rlenp);
 350                                 return 0;
 351                         }
 352                 }
 353         }
 354         return -1;
 355 }
 356 #endif
 357
 358 /*
 359  * Creates a socket for use as the ssh connection.
 360  */
 361 static int
 362 ssh_create_socket(struct addrinfo *ai)
 363 {
 364         int sock, r;
 365         struct sockaddr_storage bindaddr;
 366         socklen_t bindaddrlen = 0;
 367         struct addrinfo hints, *res = NULL;
 368 #ifdef HAVE_IFADDRS_H
 369         struct ifaddrs *ifaddrs = NULL;
 370 #endif
 371         char ntop[NI_MAXHOST];
 372
 373         sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
 374         if (sock < 0) {
 375                 error("socket: %s", strerror(errno));
 376                 return -1;
 377         }
 378         fcntl(sock, F_SETFD, FD_CLOEXEC);
 379
 380         /* Bind the socket to an alternative local IP address */
 381         if (options.bind_address == NULL && options.bind_interface == NULL)
 382                 return sock;
 383
 384         if (options.bind_address != NULL) {
 385                 memset(&hints, 0, sizeof(hints));
 386                 hints.ai_family = ai->ai_family;
 387                 hints.ai_socktype = ai->ai_socktype;
 388                 hints.ai_protocol = ai->ai_protocol;
 389                 hints.ai_flags = AI_PASSIVE;
 390                 if ((r = getaddrinfo(options.bind_address, NULL,
 391                     &hints, &res)) != 0) {
 392                         error("getaddrinfo: %s: %s", options.bind_address,
 393                             ssh_gai_strerror(r));
 394                         goto fail;
 395                 }
 396                 if (res == NULL) {
 397                         error("getaddrinfo: no addrs");
 398                         goto fail;
 399                 }
 400                 memcpy(&bindaddr, res->ai_addr, res->ai_addrlen);
 401                 bindaddrlen = res->ai_addrlen;
 402         } else if (options.bind_interface != NULL) {
 403 #ifdef HAVE_IFADDRS_H
 404                 if ((r = getifaddrs(&ifaddrs)) != 0) {
 405                         error("getifaddrs: %s: %s", options.bind_interface,
 406                               strerror(errno));
 407                         goto fail;
 408                 }
 409                 bindaddrlen = sizeof(bindaddr);
 410                 if (check_ifaddrs(options.bind_interface, ai->ai_family,
 411                     ifaddrs, &bindaddr, &bindaddrlen) != 0) {
 412                         logit("getifaddrs: %s: no suitable addresses",
 413                               options.bind_interface);
 414                         goto fail;
 415                 }
 416 #else
 417                 error("BindInterface not supported on this platform.");
 418 #endif
 419         }
 420         if ((r = getnameinfo((struct sockaddr *)&bindaddr, bindaddrlen,
 421             ntop, sizeof(ntop), NULL, 0, NI_NUMERICHOST)) != 0) {
 422                 error("%s: getnameinfo failed: %s", __func__,
 423                     ssh_gai_strerror(r));
 424                 goto fail;
 425         }
 426         if (bind(sock, (struct sockaddr *)&bindaddr, bindaddrlen) != 0) {
 427                 error("bind %s: %s", ntop, strerror(errno));
 428                 goto fail;
 429         }
 430         debug("%s: bound to %s", __func__, ntop);
 431         /* success */
 432         goto out;
 433 fail:
 434         close(sock);
 435         sock = -1;
 436  out:
 437         if (res != NULL)
 438                 freeaddrinfo(res);
 439 #ifdef HAVE_IFADDRS_H
 440         if (ifaddrs != NULL)
 441                 freeifaddrs(ifaddrs);
 442 #endif
 443         return sock;
 444 }
 445
 446 /*
 447  * Opens a TCP/IP connection to the remote server on the given host.
 448  * The address of the remote host will be returned in hostaddr.
 449  * If port is 0, the default port will be used.
 450  * Connection_attempts specifies the maximum number of tries (one per
 451  * second).  If proxy_command is non-NULL, it specifies the command (with %h
 452  * and %p substituted for host and port, respectively) to use to contact
 453  * the daemon.
 454  */
 455 static int
 456 ssh_connect_direct(struct ssh *ssh, const char *host, struct addrinfo *aitop,
 457     struct sockaddr_storage *hostaddr, u_short port, int family,
 458     int connection_attempts, int *timeout_ms, int want_keepalive)
 459 {
 460         int on = 1, saved_timeout_ms = *timeout_ms;
 461         int oerrno, sock = -1, attempt;
 462         char ntop[NI_MAXHOST], strport[NI_MAXSERV];
 463         struct addrinfo *ai;
 464
 465         debug2("%s", __func__);
 466         memset(ntop, 0, sizeof(ntop));
 467         memset(strport, 0, sizeof(strport));
 468
 469         for (attempt = 0; attempt < connection_attempts; attempt++) {
 470                 if (attempt > 0) {
 471                         /* Sleep a moment before retrying. */
 472                         sleep(1);
 473                         debug("Trying again...");
 474                 }
 475                 /*
 476                  * Loop through addresses for this host, and try each one in
 477                  * sequence until the connection succeeds.
 478                  */
 479                 for (ai = aitop; ai; ai = ai->ai_next) {
 480                         if (ai->ai_family != AF_INET &&
 481                             ai->ai_family != AF_INET6) {
 482                                 errno = EAFNOSUPPORT;
 483                                 continue;
 484                         }
 485                         if (getnameinfo(ai->ai_addr, ai->ai_addrlen,
 486                             ntop, sizeof(ntop), strport, sizeof(strport),
 487                             NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
 488                                 oerrno = errno;
 489                                 error("%s: getnameinfo failed", __func__);
 490                                 errno = oerrno;
 491                                 continue;
 492                         }
 493                         debug("Connecting to %.200s [%.100s] port %s.",
 494                                 host, ntop, strport);
 495
 496                         /* Create a socket for connecting. */
 497                         sock = ssh_create_socket(ai);
 498                         if (sock < 0) {
 499                                 /* Any error is already output */
 500                                 errno = 0;
 501                                 continue;
 502                         }
 503
 504                         *timeout_ms = saved_timeout_ms;
 505                         if (timeout_connect(sock, ai->ai_addr, ai->ai_addrlen,
 506                             timeout_ms) >= 0) {
 507                                 /* Successful connection. */
 508                                 memcpy(hostaddr, ai->ai_addr, ai->ai_addrlen);
 509                                 break;
 510                         } else {
 511                                 oerrno = errno;
 512                                 debug("connect to address %s port %s: %s",
 513                                     ntop, strport, strerror(errno));
 514                                 close(sock);
 515                                 sock = -1;
 516                                 errno = oerrno;
 517                         }
 518                 }
 519                 if (sock != -1)
 520                         break;  /* Successful connection. */
 521         }
 522
 523         /* Return failure if we didn't get a successful connection. */
 524         if (sock == -1) {
 525                 error("ssh: connect to host %s port %s: %s",
 526                     host, strport, errno == 0 ? "failure" : strerror(errno));
 527                 return -1;
 528         }
 529
 530         debug("Connection established.");
 531
 532         /* Set SO_KEEPALIVE if requested. */
 533         if (want_keepalive &&
 534             setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (void *)&on,
 535             sizeof(on)) < 0)
 536                 error("setsockopt SO_KEEPALIVE: %.100s", strerror(errno));
 537
 538         /* Set the connection. */
 539         if (ssh_packet_set_connection(ssh, sock, sock) == NULL)
 540                 return -1; /* ssh_packet_set_connection logs error */
 541
 542         return 0;
 543 }
 544
 545 int
 546 ssh_connect(struct ssh *ssh, const char *host, struct addrinfo *addrs,
 547     struct sockaddr_storage *hostaddr, u_short port, int family,
 548     int connection_attempts, int *timeout_ms, int want_keepalive)
 549 {
 550         int in, out;
 551
 552         if (options.proxy_command == NULL) {
 553                 return ssh_connect_direct(ssh, host, addrs, hostaddr, port,
 554                     family, connection_attempts, timeout_ms, want_keepalive);
 555         } else if (strcmp(options.proxy_command, "-") == 0) {
 556                 if ((in = dup(STDIN_FILENO)) < 0 ||
 557                     (out = dup(STDOUT_FILENO)) < 0) {
 558                         if (in >= 0)
 559                                 close(in);
 560                         error("%s: dup() in/out failed", __func__);
 561                         return -1; /* ssh_packet_set_connection logs error */
 562                 }
 563                 if ((ssh_packet_set_connection(ssh, in, out)) == NULL)
 564                         return -1; /* ssh_packet_set_connection logs error */
 565                 return 0;
 566         } else if (options.proxy_use_fdpass) {
 567                 return ssh_proxy_fdpass_connect(ssh, host, port,
 568                     options.proxy_command);
 569         }
 570         return ssh_proxy_connect(ssh, host, port, options.proxy_command);
 571 }
 572
 573 /* defaults to 'no' */
 574 static int
 575 confirm(const char *prompt, const char *fingerprint)
 576 {
 577         const char *msg, *again = "Please type 'yes' or 'no': ";
 578         const char *again_fp = "Please type 'yes', 'no' or the fingerprint: ";
 579         char *p;
 580         int ret = -1;
 581
 582         if (options.batch_mode)
 583                 return 0;
 584         for (msg = prompt;;msg = fingerprint ? again_fp : again) {
 585                 p = read_passphrase(msg, RP_ECHO);
 586                 if (p == NULL)
 587                         return 0;
 588                 p[strcspn(p, "\n")] = '\0';
 589                 if (p[0] == '\0' || strcasecmp(p, "no") == 0)
 590                         ret = 0;
 591                 else if (strcasecmp(p, "yes") == 0 || (fingerprint != NULL &&
 592                     strcasecmp(p, fingerprint) == 0))
 593                         ret = 1;
 594                 free(p);
 595                 if (ret != -1)
 596                         return ret;
 597         }
 598 }
 599
 600 static int
 601 check_host_cert(const char *host, const struct sshkey *key)
 602 {
 603         const char *reason;
 604         int r;
 605
 606         if (sshkey_cert_check_authority(key, 1, 0, host, &reason) != 0) {
 607                 error("%s", reason);
 608                 return 0;
 609         }
 610         if (sshbuf_len(key->cert->critical) != 0) {
 611                 error("Certificate for %s contains unsupported "
 612                     "critical options(s)", host);
 613                 return 0;
 614         }
 615         if ((r = sshkey_check_cert_sigtype(key,
 616             options.ca_sign_algorithms)) != 0) {
 617                 logit("%s: certificate signature algorithm %s: %s", __func__,
 618                     (key->cert == NULL || key->cert->signature_type == NULL) ?
 619                     "(null)" : key->cert->signature_type, ssh_err(r));
 620                 return 0;
 621         }
 622
 623         return 1;
 624 }
 625
 626 static int
 627 sockaddr_is_local(struct sockaddr *hostaddr)
 628 {
 629         switch (hostaddr->sa_family) {
 630         case AF_INET:
 631                 return (ntohl(((struct sockaddr_in *)hostaddr)->
 632                     sin_addr.s_addr) >> 24) == IN_LOOPBACKNET;
 633         case AF_INET6:
 634                 return IN6_IS_ADDR_LOOPBACK(
 635                     &(((struct sockaddr_in6 *)hostaddr)->sin6_addr));
 636         default:
 637                 return 0;
 638         }
 639 }
 640
 641 /*
 642  * Prepare the hostname and ip address strings that are used to lookup
 643  * host keys in known_hosts files. These may have a port number appended.
 644  */
 645 void
 646 get_hostfile_hostname_ipaddr(char *hostname, struct sockaddr *hostaddr,
 647     u_short port, char **hostfile_hostname, char **hostfile_ipaddr)
 648 {
 649         char ntop[NI_MAXHOST];
 650         socklen_t addrlen;
 651
 652         switch (hostaddr == NULL ? -1 : hostaddr->sa_family) {
 653         case -1:
 654                 addrlen = 0;
 655                 break;
 656         case AF_INET:
 657                 addrlen = sizeof(struct sockaddr_in);
 658                 break;
 659         case AF_INET6:
 660                 addrlen = sizeof(struct sockaddr_in6);
 661                 break;
 662         default:
 663                 addrlen = sizeof(struct sockaddr);
 664                 break;
 665         }
 666
 667         /*
 668          * We don't have the remote ip-address for connections
 669          * using a proxy command
 670          */
 671         if (hostfile_ipaddr != NULL) {
 672                 if (options.proxy_command == NULL) {
 673                         if (getnameinfo(hostaddr, addrlen,
 674                             ntop, sizeof(ntop), NULL, 0, NI_NUMERICHOST) != 0)
 675                         fatal("%s: getnameinfo failed", __func__);
 676                         *hostfile_ipaddr = put_host_port(ntop, port);
 677                 } else {
 678                         *hostfile_ipaddr = xstrdup("<no hostip for proxy "
 679                             "command>");
 680                 }
 681         }
 682
 683         /*
 684          * Allow the user to record the key under a different name or
 685          * differentiate a non-standard port.  This is useful for ssh
 686          * tunneling over forwarded connections or if you run multiple
 687          * sshd's on different ports on the same machine.
 688          */
 689         if (hostfile_hostname != NULL) {
 690                 if (options.host_key_alias != NULL) {
 691                         *hostfile_hostname = xstrdup(options.host_key_alias);
 692                         debug("using hostkeyalias: %s", *hostfile_hostname);
 693                 } else {
 694                         *hostfile_hostname = put_host_port(hostname, port);
 695                 }
 696         }
 697 }
 698
 699 /*
 700  * check whether the supplied host key is valid, return -1 if the key
 701  * is not valid. user_hostfile[0] will not be updated if 'readonly' is true.
 702  */
 703 #define RDRW    0
 704 #define RDONLY  1
 705 #define ROQUIET 2
 706 static int
 707 check_host_key(char *hostname, struct sockaddr *hostaddr, u_short port,
 708     struct sshkey *host_key, int readonly,
 709     char **user_hostfiles, u_int num_user_hostfiles,
 710     char **system_hostfiles, u_int num_system_hostfiles)
 711 {
 712         HostStatus host_status;
 713         HostStatus ip_status;
 714         struct sshkey *raw_key = NULL;
 715         char *ip = NULL, *host = NULL;
 716         char hostline[1000], *hostp, *fp, *ra;
 717         char msg[1024];
 718         const char *type;
 719         const struct hostkey_entry *host_found, *ip_found;
 720         int len, cancelled_forwarding = 0, confirmed;
 721         int local = sockaddr_is_local(hostaddr);
 722         int r, want_cert = sshkey_is_cert(host_key), host_ip_differ = 0;
 723         int hostkey_trusted = 0; /* Known or explicitly accepted by user */
 724         struct hostkeys *host_hostkeys, *ip_hostkeys;
 725         u_int i;
 726
 727         /*
 728          * Force accepting of the host key for loopback/localhost. The
 729          * problem is that if the home directory is NFS-mounted to multiple
 730          * machines, localhost will refer to a different machine in each of
 731          * them, and the user will get bogus HOST_CHANGED warnings.  This
 732          * essentially disables host authentication for localhost; however,
 733          * this is probably not a real problem.
 734          */
 735         if (options.no_host_authentication_for_localhost == 1 && local &&
 736             options.host_key_alias == NULL) {
 737                 debug("Forcing accepting of host key for "
 738                     "loopback/localhost.");
 739                 return 0;
 740         }
 741
 742         /*
 743          * Prepare the hostname and address strings used for hostkey lookup.
 744          * In some cases, these will have a port number appended.
 745          */
 746         get_hostfile_hostname_ipaddr(hostname, hostaddr, port, &host, &ip);
 747
 748         /*
 749          * Turn off check_host_ip if the connection is to localhost, via proxy
 750          * command or if we don't have a hostname to compare with
 751          */
 752         if (options.check_host_ip && (local ||
 753             strcmp(hostname, ip) == 0 || options.proxy_command != NULL))
 754                 options.check_host_ip = 0;
 755
 756         host_hostkeys = init_hostkeys();
 757         for (i = 0; i < num_user_hostfiles; i++)
 758                 load_hostkeys(host_hostkeys, host, user_hostfiles[i]);
 759         for (i = 0; i < num_system_hostfiles; i++)
 760                 load_hostkeys(host_hostkeys, host, system_hostfiles[i]);
 761
 762         ip_hostkeys = NULL;
 763         if (!want_cert && options.check_host_ip) {
 764                 ip_hostkeys = init_hostkeys();
 765                 for (i = 0; i < num_user_hostfiles; i++)
 766                         load_hostkeys(ip_hostkeys, ip, user_hostfiles[i]);
 767                 for (i = 0; i < num_system_hostfiles; i++)
 768                         load_hostkeys(ip_hostkeys, ip, system_hostfiles[i]);
 769         }
 770
 771  retry:
 772         /* Reload these as they may have changed on cert->key downgrade */
 773         want_cert = sshkey_is_cert(host_key);
 774         type = sshkey_type(host_key);
 775
 776         /*
 777          * Check if the host key is present in the user's list of known
 778          * hosts or in the systemwide list.
 779          */
 780         host_status = check_key_in_hostkeys(host_hostkeys, host_key,
 781             &host_found);
 782
 783         /*
 784          * Also perform check for the ip address, skip the check if we are
 785          * localhost, looking for a certificate, or the hostname was an ip
 786          * address to begin with.
 787          */
 788         if (!want_cert && ip_hostkeys != NULL) {
 789                 ip_status = check_key_in_hostkeys(ip_hostkeys, host_key,
 790                     &ip_found);
 791                 if (host_status == HOST_CHANGED &&
 792                     (ip_status != HOST_CHANGED ||
 793                     (ip_found != NULL &&
 794                     !sshkey_equal(ip_found->key, host_found->key))))
 795                         host_ip_differ = 1;
 796         } else
 797                 ip_status = host_status;
 798
 799         switch (host_status) {
 800         case HOST_OK:
 801                 /* The host is known and the key matches. */
 802                 debug("Host '%.200s' is known and matches the %s host %s.",
 803                     host, type, want_cert ? "certificate" : "key");
 804                 debug("Found %s in %s:%lu", want_cert ? "CA key" : "key",
 805                     host_found->file, host_found->line);
 806                 if (want_cert &&
 807                     !check_host_cert(options.host_key_alias == NULL ?
 808                     hostname : options.host_key_alias, host_key))
 809                         goto fail;
 810                 if (options.check_host_ip && ip_status == HOST_NEW) {
 811                         if (readonly || want_cert)
 812                                 logit("%s host key for IP address "
 813                                     "'%.128s' not in list of known hosts.",
 814                                     type, ip);
 815                         else if (!add_host_to_hostfile(user_hostfiles[0], ip,
 816                             host_key, options.hash_known_hosts))
 817                                 logit("Failed to add the %s host key for IP "
 818                                     "address '%.128s' to the list of known "
 819                                     "hosts (%.500s).", type, ip,
 820                                     user_hostfiles[0]);
 821                         else
 822                                 logit("Warning: Permanently added the %s host "
 823                                     "key for IP address '%.128s' to the list "
 824                                     "of known hosts.", type, ip);
 825                 } else if (options.visual_host_key) {
 826                         fp = sshkey_fingerprint(host_key,
 827                             options.fingerprint_hash, SSH_FP_DEFAULT);
 828                         ra = sshkey_fingerprint(host_key,
 829                             options.fingerprint_hash, SSH_FP_RANDOMART);
 830                         if (fp == NULL || ra == NULL)
 831                                 fatal("%s: sshkey_fingerprint fail", __func__);
 832                         logit("Host key fingerprint is %s\n%s", fp, ra);
 833                         free(ra);
 834                         free(fp);
 835                 }
 836                 hostkey_trusted = 1;
 837                 break;
 838         case HOST_NEW:
 839                 if (options.host_key_alias == NULL && port != 0 &&
 840                     port != SSH_DEFAULT_PORT) {
 841                         debug("checking without port identifier");
 842                         if (check_host_key(hostname, hostaddr, 0, host_key,
 843                             ROQUIET, user_hostfiles, num_user_hostfiles,
 844                             system_hostfiles, num_system_hostfiles) == 0) {
 845                                 debug("found matching key w/out port");
 846                                 break;
 847                         }
 848                 }
 849                 if (readonly || want_cert)
 850                         goto fail;
 851                 /* The host is new. */
 852                 if (options.strict_host_key_checking ==
 853                     SSH_STRICT_HOSTKEY_YES) {
 854                         /*
 855                          * User has requested strict host key checking.  We
 856                          * will not add the host key automatically.  The only
 857                          * alternative left is to abort.
 858                          */
 859                         error("No %s host key is known for %.200s and you "
 860                             "have requested strict checking.", type, host);
 861                         goto fail;
 862                 } else if (options.strict_host_key_checking ==
 863                     SSH_STRICT_HOSTKEY_ASK) {
 864                         char msg1[1024], msg2[1024];
 865
 866                         if (show_other_keys(host_hostkeys, host_key))
 867                                 snprintf(msg1, sizeof(msg1),
 868                                     "\nbut keys of different type are already"
 869                                     " known for this host.");
 870                         else
 871                                 snprintf(msg1, sizeof(msg1), ".");
 872                         /* The default */
 873                         fp = sshkey_fingerprint(host_key,
 874                             options.fingerprint_hash, SSH_FP_DEFAULT);
 875                         ra = sshkey_fingerprint(host_key,
 876                             options.fingerprint_hash, SSH_FP_RANDOMART);
 877                         if (fp == NULL || ra == NULL)
 878                                 fatal("%s: sshkey_fingerprint fail", __func__);
 879                         msg2[0] = '\0';
 880                         if (options.verify_host_key_dns) {
 881                                 if (matching_host_key_dns)
 882                                         snprintf(msg2, sizeof(msg2),
 883                                             "Matching host key fingerprint"
 884                                             " found in DNS.\n");
 885                                 else
 886                                         snprintf(msg2, sizeof(msg2),
 887                                             "No matching host key fingerprint"
 888                                             " found in DNS.\n");
 889                         }
 890                         snprintf(msg, sizeof(msg),
 891                             "The authenticity of host '%.200s (%s)' can't be "
 892                             "established%s\n"
 893                             "%s key fingerprint is %s.%s%s\n%s"
 894                             "Are you sure you want to continue connecting "
 895                             "(yes/no/[fingerprint])? ",
 896                             host, ip, msg1, type, fp,
 897                             options.visual_host_key ? "\n" : "",
 898                             options.visual_host_key ? ra : "",
 899                             msg2);
 900                         free(ra);
 901                         confirmed = confirm(msg, fp);
 902                         free(fp);
 903                         if (!confirmed)
 904                                 goto fail;
 905                         hostkey_trusted = 1; /* user explicitly confirmed */
 906                 }
 907                 /*
 908                  * If in "new" or "off" strict mode, add the key automatically
 909                  * to the local known_hosts file.
 910                  */
 911                 if (options.check_host_ip && ip_status == HOST_NEW) {
 912                         snprintf(hostline, sizeof(hostline), "%s,%s", host, ip);
 913                         hostp = hostline;
 914                         if (options.hash_known_hosts) {
 915                                 /* Add hash of host and IP separately */
 916                                 r = add_host_to_hostfile(user_hostfiles[0],
 917                                     host, host_key, options.hash_known_hosts) &&
 918                                     add_host_to_hostfile(user_hostfiles[0], ip,
 919                                     host_key, options.hash_known_hosts);
 920                         } else {
 921                                 /* Add unhashed "host,ip" */
 922                                 r = add_host_to_hostfile(user_hostfiles[0],
 923                                     hostline, host_key,
 924                                     options.hash_known_hosts);
 925                         }
 926                 } else {
 927                         r = add_host_to_hostfile(user_hostfiles[0], host,
 928                             host_key, options.hash_known_hosts);
 929                         hostp = host;
 930                 }
 931
 932                 if (!r)
 933                         logit("Failed to add the host to the list of known "
 934                             "hosts (%.500s).", user_hostfiles[0]);
 935                 else
 936                         logit("Warning: Permanently added '%.200s' (%s) to the "
 937                             "list of known hosts.", hostp, type);
 938                 break;
 939         case HOST_REVOKED:
 940                 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
 941                 error("@       WARNING: REVOKED HOST KEY DETECTED!               @");
 942                 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
 943                 error("The %s host key for %s is marked as revoked.", type, host);
 944                 error("This could mean that a stolen key is being used to");
 945                 error("impersonate this host.");
 946
 947                 /*
 948                  * If strict host key checking is in use, the user will have
 949                  * to edit the key manually and we can only abort.
 950                  */
 951                 if (options.strict_host_key_checking !=
 952                     SSH_STRICT_HOSTKEY_OFF) {
 953                         error("%s host key for %.200s was revoked and you have "
 954                             "requested strict checking.", type, host);
 955                         goto fail;
 956                 }
 957                 goto continue_unsafe;
 958
 959         case HOST_CHANGED:
 960                 if (want_cert) {
 961                         /*
 962                          * This is only a debug() since it is valid to have
 963                          * CAs with wildcard DNS matches that don't match
 964                          * all hosts that one might visit.
 965                          */
 966                         debug("Host certificate authority does not "
 967                             "match %s in %s:%lu", CA_MARKER,
 968                             host_found->file, host_found->line);
 969                         goto fail;
 970                 }
 971                 if (readonly == ROQUIET)
 972                         goto fail;
 973                 if (options.check_host_ip && host_ip_differ) {
 974                         char *key_msg;
 975                         if (ip_status == HOST_NEW)
 976                                 key_msg = "is unknown";
 977                         else if (ip_status == HOST_OK)
 978                                 key_msg = "is unchanged";
 979                         else
 980                                 key_msg = "has a different value";
 981                         error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
 982                         error("@       WARNING: POSSIBLE DNS SPOOFING DETECTED!          @");
 983                         error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
 984                         error("The %s host key for %s has changed,", type, host);
 985                         error("and the key for the corresponding IP address %s", ip);
 986                         error("%s. This could either mean that", key_msg);
 987                         error("DNS SPOOFING is happening or the IP address for the host");
 988                         error("and its host key have changed at the same time.");
 989                         if (ip_status != HOST_NEW)
 990                                 error("Offending key for IP in %s:%lu",
 991                                     ip_found->file, ip_found->line);
 992                 }
 993                 /* The host key has changed. */
 994                 warn_changed_key(host_key);
 995                 error("Add correct host key in %.100s to get rid of this message.",
 996                     user_hostfiles[0]);
 997                 error("Offending %s key in %s:%lu",
 998                     sshkey_type(host_found->key),
 999                     host_found->file, host_found->line);
1000
1001                 /*
1002                  * If strict host key checking is in use, the user will have
1003                  * to edit the key manually and we can only abort.
1004                  */
1005                 if (options.strict_host_key_checking !=
1006                     SSH_STRICT_HOSTKEY_OFF) {
1007                         error("%s host key for %.200s has changed and you have "
1008                             "requested strict checking.", type, host);
1009                         goto fail;
1010                 }
1011
1012  continue_unsafe:
1013                 /*
1014                  * If strict host key checking has not been requested, allow
1015                  * the connection but without MITM-able authentication or
1016                  * forwarding.
1017                  */
1018                 if (options.password_authentication) {
1019                         error("Password authentication is disabled to avoid "
1020                             "man-in-the-middle attacks.");
1021                         options.password_authentication = 0;
1022                         cancelled_forwarding = 1;
1023                 }
1024                 if (options.kbd_interactive_authentication) {
1025                         error("Keyboard-interactive authentication is disabled"
1026                             " to avoid man-in-the-middle attacks.");
1027                         options.kbd_interactive_authentication = 0;
1028                         options.challenge_response_authentication = 0;
1029                         cancelled_forwarding = 1;
1030                 }
1031                 if (options.challenge_response_authentication) {
1032                         error("Challenge/response authentication is disabled"
1033                             " to avoid man-in-the-middle attacks.");
1034                         options.challenge_response_authentication = 0;
1035                         cancelled_forwarding = 1;
1036                 }
1037                 if (options.forward_agent) {
1038                         error("Agent forwarding is disabled to avoid "
1039                             "man-in-the-middle attacks.");
1040                         options.forward_agent = 0;
1041                         cancelled_forwarding = 1;
1042                 }
1043                 if (options.forward_x11) {
1044                         error("X11 forwarding is disabled to avoid "
1045                             "man-in-the-middle attacks.");
1046                         options.forward_x11 = 0;
1047                         cancelled_forwarding = 1;
1048                 }
1049                 if (options.num_local_forwards > 0 ||
1050                     options.num_remote_forwards > 0) {
1051                         error("Port forwarding is disabled to avoid "
1052                             "man-in-the-middle attacks.");
1053                         options.num_local_forwards =
1054                             options.num_remote_forwards = 0;
1055                         cancelled_forwarding = 1;
1056                 }
1057                 if (options.tun_open != SSH_TUNMODE_NO) {
1058                         error("Tunnel forwarding is disabled to avoid "
1059                             "man-in-the-middle attacks.");
1060                         options.tun_open = SSH_TUNMODE_NO;
1061                         cancelled_forwarding = 1;
1062                 }
1063                 if (options.exit_on_forward_failure && cancelled_forwarding)
1064                         fatal("Error: forwarding disabled due to host key "
1065                             "check failure");
1066
1067                 /*
1068                  * XXX Should permit the user to change to use the new id.
1069                  * This could be done by converting the host key to an
1070                  * identifying sentence, tell that the host identifies itself
1071                  * by that sentence, and ask the user if he/she wishes to
1072                  * accept the authentication.
1073                  */
1074                 break;
1075         case HOST_FOUND:
1076                 fatal("internal error");
1077                 break;
1078         }
1079
1080         if (options.check_host_ip && host_status != HOST_CHANGED &&
1081             ip_status == HOST_CHANGED) {
1082                 snprintf(msg, sizeof(msg),
1083                     "Warning: the %s host key for '%.200s' "
1084                     "differs from the key for the IP address '%.128s'"
1085                     "\nOffending key for IP in %s:%lu",
1086                     type, host, ip, ip_found->file, ip_found->line);
1087                 if (host_status == HOST_OK) {
1088                         len = strlen(msg);
1089                         snprintf(msg + len, sizeof(msg) - len,
1090                             "\nMatching host key in %s:%lu",
1091                             host_found->file, host_found->line);
1092                 }
1093                 if (options.strict_host_key_checking ==
1094                     SSH_STRICT_HOSTKEY_ASK) {
1095                         strlcat(msg, "\nAre you sure you want "
1096                             "to continue connecting (yes/no)? ", sizeof(msg));
1097                         if (!confirm(msg, NULL))
1098                                 goto fail;
1099                 } else if (options.strict_host_key_checking !=
1100                     SSH_STRICT_HOSTKEY_OFF) {
1101                         logit("%s", msg);
1102                         error("Exiting, you have requested strict checking.");
1103                         goto fail;
1104                 } else {
1105                         logit("%s", msg);
1106                 }
1107         }
1108
1109         if (!hostkey_trusted && options.update_hostkeys) {
1110                 debug("%s: hostkey not known or explicitly trusted: "
1111                     "disabling UpdateHostkeys", __func__);
1112                 options.update_hostkeys = 0;
1113         }
1114
1115         free(ip);
1116         free(host);
1117         if (host_hostkeys != NULL)
1118                 free_hostkeys(host_hostkeys);
1119         if (ip_hostkeys != NULL)
1120                 free_hostkeys(ip_hostkeys);
1121         return 0;
1122
1123 fail:
1124         if (want_cert && host_status != HOST_REVOKED) {
1125                 /*
1126                  * No matching certificate. Downgrade cert to raw key and
1127                  * search normally.
1128                  */
1129                 debug("No matching CA found. Retry with plain key");
1130                 if ((r = sshkey_from_private(host_key, &raw_key)) != 0)
1131                         fatal("%s: sshkey_from_private: %s",
1132                             __func__, ssh_err(r));
1133                 if ((r = sshkey_drop_cert(raw_key)) != 0)
1134                         fatal("Couldn't drop certificate: %s", ssh_err(r));
1135                 host_key = raw_key;
1136                 goto retry;
1137         }
1138         sshkey_free(raw_key);
1139         free(ip);
1140         free(host);
1141         if (host_hostkeys != NULL)
1142                 free_hostkeys(host_hostkeys);
1143         if (ip_hostkeys != NULL)
1144                 free_hostkeys(ip_hostkeys);
1145         return -1;
1146 }
1147
1148 /* returns 0 if key verifies or -1 if key does NOT verify */
1149 int
1150 verify_host_key(char *host, struct sockaddr *hostaddr, struct sshkey *host_key)
1151 {
1152         u_int i;
1153         int r = -1, flags = 0;
1154         char valid[64], *fp = NULL, *cafp = NULL;
1155         struct sshkey *plain = NULL;
1156
1157         if ((fp = sshkey_fingerprint(host_key,
1158             options.fingerprint_hash, SSH_FP_DEFAULT)) == NULL) {
1159                 error("%s: fingerprint host key: %s", __func__, ssh_err(r));
1160                 r = -1;
1161                 goto out;
1162         }
1163
1164         if (sshkey_is_cert(host_key)) {
1165                 if ((cafp = sshkey_fingerprint(host_key->cert->signature_key,
1166                     options.fingerprint_hash, SSH_FP_DEFAULT)) == NULL) {
1167                         error("%s: fingerprint CA key: %s",
1168                             __func__, ssh_err(r));
1169                         r = -1;
1170                         goto out;
1171                 }
1172                 sshkey_format_cert_validity(host_key->cert,
1173                     valid, sizeof(valid));
1174                 debug("Server host certificate: %s %s, serial %llu "
1175                     "ID \"%s\" CA %s %s valid %s",
1176                     sshkey_ssh_name(host_key), fp,
1177                     (unsigned long long)host_key->cert->serial,
1178                     host_key->cert->key_id,
1179                     sshkey_ssh_name(host_key->cert->signature_key), cafp,
1180                     valid);
1181                 for (i = 0; i < host_key->cert->nprincipals; i++) {
1182                         debug2("Server host certificate hostname: %s",
1183                             host_key->cert->principals[i]);
1184                 }
1185         } else {
1186                 debug("Server host key: %s %s", sshkey_ssh_name(host_key), fp);
1187         }
1188
1189         if (sshkey_equal(previous_host_key, host_key)) {
1190                 debug2("%s: server host key %s %s matches cached key",
1191                     __func__, sshkey_type(host_key), fp);
1192                 r = 0;
1193                 goto out;
1194         }
1195
1196         /* Check in RevokedHostKeys file if specified */
1197         if (options.revoked_host_keys != NULL) {
1198                 r = sshkey_check_revoked(host_key, options.revoked_host_keys);
1199                 switch (r) {
1200                 case 0:
1201                         break; /* not revoked */
1202                 case SSH_ERR_KEY_REVOKED:
1203                         error("Host key %s %s revoked by file %s",
1204                             sshkey_type(host_key), fp,
1205                             options.revoked_host_keys);
1206                         r = -1;
1207                         goto out;
1208                 default:
1209                         error("Error checking host key %s %s in "
1210                             "revoked keys file %s: %s", sshkey_type(host_key),
1211                             fp, options.revoked_host_keys, ssh_err(r));
1212                         r = -1;
1213                         goto out;
1214                 }
1215         }
1216
1217         if (options.verify_host_key_dns) {
1218                 /*
1219                  * XXX certs are not yet supported for DNS, so downgrade
1220                  * them and try the plain key.
1221                  */
1222                 if ((r = sshkey_from_private(host_key, &plain)) != 0)
1223                         goto out;
1224                 if (sshkey_is_cert(plain))
1225                         sshkey_drop_cert(plain);
1226                 if (verify_host_key_dns(host, hostaddr, plain, &flags) == 0) {
1227                         if (flags & DNS_VERIFY_FOUND) {
1228                                 if (options.verify_host_key_dns == 1 &&
1229                                     flags & DNS_VERIFY_MATCH &&
1230                                     flags & DNS_VERIFY_SECURE) {
1231                                         r = 0;
1232                                         goto out;
1233                                 }
1234                                 if (flags & DNS_VERIFY_MATCH) {
1235                                         matching_host_key_dns = 1;
1236                                 } else {
1237                                         warn_changed_key(plain);
1238                                         error("Update the SSHFP RR in DNS "
1239                                             "with the new host key to get rid "
1240                                             "of this message.");
1241                                 }
1242                         }
1243                 }
1244         }
1245         r = check_host_key(host, hostaddr, options.port, host_key, RDRW,
1246             options.user_hostfiles, options.num_user_hostfiles,
1247             options.system_hostfiles, options.num_system_hostfiles);
1248
1249 out:
1250         sshkey_free(plain);
1251         free(fp);
1252         free(cafp);
1253         if (r == 0 && host_key != NULL) {
1254                 sshkey_free(previous_host_key);
1255                 r = sshkey_from_private(host_key, &previous_host_key);
1256         }
1257
1258         return r;
1259 }
1260
1261 /*
1262  * Starts a dialog with the server, and authenticates the current user on the
1263  * server.  This does not need any extra privileges.  The basic connection
1264  * to the server must already have been established before this is called.
1265  * If login fails, this function prints an error and never returns.
1266  * This function does not require super-user privileges.
1267  */
1268 void
1269 ssh_login(struct ssh *ssh, Sensitive *sensitive, const char *orighost,
1270     struct sockaddr *hostaddr, u_short port, struct passwd *pw, int timeout_ms)
1271 {
1272         char *host;
1273         char *server_user, *local_user;
1274
1275         local_user = xstrdup(pw->pw_name);
1276         server_user = options.user ? options.user : local_user;
1277
1278         /* Convert the user-supplied hostname into all lowercase. */
1279         host = xstrdup(orighost);
1280         lowercase(host);
1281
1282         /* Exchange protocol version identification strings with the server. */
1283         if (kex_exchange_identification(ssh, timeout_ms, NULL) != 0)
1284                 cleanup_exit(255); /* error already logged */
1285
1286         /* Put the connection into non-blocking mode. */
1287         ssh_packet_set_nonblocking(ssh);
1288
1289         /* key exchange */
1290         /* authenticate user */
1291         debug("Authenticating to %s:%d as '%s'", host, port, server_user);
1292         ssh_kex2(ssh, host, hostaddr, port);
1293         ssh_userauth2(ssh, local_user, server_user, host, sensitive);
1294         free(local_user);
1295 }
1296
1297 /* print all known host keys for a given host, but skip keys of given type */
1298 static int
1299 show_other_keys(struct hostkeys *hostkeys, struct sshkey *key)
1300 {
1301         int type[] = {
1302                 KEY_RSA,
1303                 KEY_DSA,
1304                 KEY_ECDSA,
1305                 KEY_ED25519,
1306                 KEY_XMSS,
1307                 -1
1308         };
1309         int i, ret = 0;
1310         char *fp, *ra;
1311         const struct hostkey_entry *found;
1312
1313         for (i = 0; type[i] != -1; i++) {
1314                 if (type[i] == key->type)
1315                         continue;
1316                 if (!lookup_key_in_hostkeys_by_type(hostkeys, type[i], &found))
1317                         continue;
1318                 fp = sshkey_fingerprint(found->key,
1319                     options.fingerprint_hash, SSH_FP_DEFAULT);
1320                 ra = sshkey_fingerprint(found->key,
1321                     options.fingerprint_hash, SSH_FP_RANDOMART);
1322                 if (fp == NULL || ra == NULL)
1323                         fatal("%s: sshkey_fingerprint fail", __func__);
1324                 logit("WARNING: %s key found for host %s\n"
1325                     "in %s:%lu\n"
1326                     "%s key fingerprint %s.",
1327                     sshkey_type(found->key),
1328                     found->host, found->file, found->line,
1329                     sshkey_type(found->key), fp);
1330                 if (options.visual_host_key)
1331                         logit("%s", ra);
1332                 free(ra);
1333                 free(fp);
1334                 ret = 1;
1335         }
1336         return ret;
1337 }
1338
1339 static void
1340 warn_changed_key(struct sshkey *host_key)
1341 {
1342         char *fp;
1343
1344         fp = sshkey_fingerprint(host_key, options.fingerprint_hash,
1345             SSH_FP_DEFAULT);
1346         if (fp == NULL)
1347                 fatal("%s: sshkey_fingerprint fail", __func__);
1348
1349         error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
1350         error("@    WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!     @");
1351         error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
1352         error("IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!");
1353         error("Someone could be eavesdropping on you right now (man-in-the-middle attack)!");
1354         error("It is also possible that a host key has just been changed.");
1355         error("The fingerprint for the %s key sent by the remote host is\n%s.",
1356             sshkey_type(host_key), fp);
1357         error("Please contact your system administrator.");
1358
1359         free(fp);
1360 }
1361
1362 /*
1363  * Execute a local command
1364  */
1365 int
1366 ssh_local_cmd(const char *args)
1367 {
1368         char *shell;
1369         pid_t pid;
1370         int status;
1371         void (*osighand)(int);
1372
1373         if (!options.permit_local_command ||
1374             args == NULL || !*args)
1375                 return (1);
1376
1377         if ((shell = getenv("SHELL")) == NULL || *shell == '\0')
1378                 shell = _PATH_BSHELL;
1379
1380         osighand = signal(SIGCHLD, SIG_DFL);
1381         pid = fork();
1382         if (pid == 0) {
1383                 signal(SIGPIPE, SIG_DFL);
1384                 debug3("Executing %s -c \"%s\"", shell, args);
1385                 execl(shell, shell, "-c", args, (char *)NULL);
1386                 error("Couldn't execute %s -c \"%s\": %s",
1387                     shell, args, strerror(errno));
1388                 _exit(1);
1389         } else if (pid == -1)
1390                 fatal("fork failed: %.100s", strerror(errno));
1391         while (waitpid(pid, &status, 0) == -1)
1392                 if (errno != EINTR)
1393                         fatal("Couldn't wait for child: %s", strerror(errno));
1394         signal(SIGCHLD, osighand);
1395
1396         if (!WIFEXITED(status))
1397                 return (1);
1398
1399         return (WEXITSTATUS(status));
1400 }
1401
1402 void
1403 maybe_add_key_to_agent(char *authfile, const struct sshkey *private,
1404     char *comment, char *passphrase)
1405 {
1406         int auth_sock = -1, r;
1407
1408         if (options.add_keys_to_agent == 0)
1409                 return;
1410
1411         if ((r = ssh_get_authentication_socket(&auth_sock)) != 0) {
1412                 debug3("no authentication agent, not adding key");
1413                 return;
1414         }
1415
1416         if (options.add_keys_to_agent == 2 &&
1417             !ask_permission("Add key %s (%s) to agent?", authfile, comment)) {
1418                 debug3("user denied adding this key");
1419                 close(auth_sock);
1420                 return;
1421         }
1422
1423         if ((r = ssh_add_identity_constrained(auth_sock, private, comment, 0,
1424             (options.add_keys_to_agent == 3), 0)) == 0)
1425                 debug("identity added to agent: %s", authfile);
1426         else
1427                 debug("could not add identity to agent: %s (%d)", authfile, r);
1428         close(auth_sock);
1429 }