openssh/sshd.c

   1 /* $OpenBSD: sshd.c,v 1.366 2009/01/22 10:02:34 djm Exp $ */
   2 /*
   3  * Author: Tatu Ylonen <ylo@cs.hut.fi>
   4  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   5  *                    All rights reserved
   6  * This program is the ssh daemon.  It listens for connections from clients,
   7  * and performs authentication, executes use commands or shell, and forwards
   8  * information to/from the application to the user client over an encrypted
   9  * connection.  This can also handle forwarding of X11, TCP/IP, and
  10  * authentication agent connections.
  11  *
  12  * As far as I am concerned, the code I have written for this software
  13  * can be used freely for any purpose.  Any derived versions of this
  14  * software must be clearly marked as such, and if the derived work is
  15  * incompatible with the protocol description in the RFC file, it must be
  16  * called by a name other than "ssh" or "Secure Shell".
  17  *
  18  * SSH2 implementation:
  19  * Privilege Separation:
  20  *
  21  * Copyright (c) 2000, 2001, 2002 Markus Friedl.  All rights reserved.
  22  * Copyright (c) 2002 Niels Provos.  All rights reserved.
  23  *
  24  * Redistribution and use in source and binary forms, with or without
  25  * modification, are permitted provided that the following conditions
  26  * are met:
  27  * 1. Redistributions of source code must retain the above copyright
  28  *    notice, this list of conditions and the following disclaimer.
  29  * 2. Redistributions in binary form must reproduce the above copyright
  30  *    notice, this list of conditions and the following disclaimer in the
  31  *    documentation and/or other materials provided with the distribution.
  32  *
  33  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  34  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  35  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  36  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  37  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  38  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  39  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  40  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  41  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  42  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  43  */
  44
  45 #include "includes.h"
  46
  47 #include <sys/types.h>
  48 #include <sys/ioctl.h>
  49 #include <sys/socket.h>
  50 #ifdef HAVE_SYS_STAT_H
  51 # include <sys/stat.h>
  52 #endif
  53 #ifdef HAVE_SYS_TIME_H
  54 # include <sys/time.h>
  55 #endif
  56 #include "openbsd-compat/sys-tree.h"
  57 #include "openbsd-compat/sys-queue.h"
  58 #include <sys/wait.h>
  59
  60 #include <errno.h>
  61 #include <fcntl.h>
  62 #include <netdb.h>
  63 #ifdef HAVE_PATHS_H
  64 #include <paths.h>
  65 #endif
  66 #include <grp.h>
  67 #include <pwd.h>
  68 #include <signal.h>
  69 #include <stdarg.h>
  70 #include <stdio.h>
  71 #include <stdlib.h>
  72 #include <string.h>
  73 #include <unistd.h>
  74
  75 #include <openssl/dh.h>
  76 #include <openssl/bn.h>
  77 #include <openssl/md5.h>
  78 #include <openssl/rand.h>
  79 #include "openbsd-compat/openssl-compat.h"
  80
  81 #ifdef HAVE_SECUREWARE
  82 #include <sys/security.h>
  83 #include <prot.h>
  84 #endif
  85
  86 #include "xmalloc.h"
  87 #include "ssh.h"
  88 #include "ssh1.h"
  89 #include "ssh2.h"
  90 #include "rsa.h"
  91 #include "sshpty.h"
  92 #include "packet.h"
  93 #include "log.h"
  94 #include "buffer.h"
  95 #include "servconf.h"
  96 #include "uidswap.h"
  97 #include "compat.h"
  98 #include "cipher.h"
  99 #include "key.h"
 100 #include "kex.h"
 101 #include "dh.h"
 102 #include "myproposal.h"
 103 #include "authfile.h"
 104 #include "pathnames.h"
 105 #include "atomicio.h"
 106 #include "canohost.h"
 107 #include "hostfile.h"
 108 #include "auth.h"
 109 #include "misc.h"
 110 #include "msg.h"
 111 #include "dispatch.h"
 112 #include "channels.h"
 113 #include "session.h"
 114 #include "monitor_mm.h"
 115 #include "monitor.h"
 116 #ifdef GSSAPI
 117 #include "ssh-gss.h"
 118 #endif
 119 #include "monitor_wrap.h"
 120 #include "version.h"
 121
 122 #ifdef USE_SECURITY_SESSION_API
 123 #include <Security/AuthSession.h>
 124 #endif
 125
 126 #ifdef LIBWRAP
 127 #include <tcpd.h>
 128 #include <syslog.h>
 129 int allow_severity;
 130 int deny_severity;
 131 #endif /* LIBWRAP */
 132
 133 #ifndef O_NOCTTY
 134 #define O_NOCTTY        0
 135 #endif
 136
 137 /* Re-exec fds */
 138 #define REEXEC_DEVCRYPTO_RESERVED_FD    (STDERR_FILENO + 1)
 139 #define REEXEC_STARTUP_PIPE_FD          (STDERR_FILENO + 2)
 140 #define REEXEC_CONFIG_PASS_FD           (STDERR_FILENO + 3)
 141 #define REEXEC_MIN_FREE_FD              (STDERR_FILENO + 4)
 142
 143 extern char *__progname;
 144
 145 /* Server configuration options. */
 146 ServerOptions options;
 147
 148 /* Name of the server configuration file. */
 149 char *config_file_name = _PATH_SERVER_CONFIG_FILE;
 150
 151 /*
 152  * Debug mode flag.  This can be set on the command line.  If debug
 153  * mode is enabled, extra debugging output will be sent to the system
 154  * log, the daemon will not go to background, and will exit after processing
 155  * the first connection.
 156  */
 157 int debug_flag = 0;
 158
 159 /* Flag indicating that the daemon should only test the configuration and keys. */
 160 int test_flag = 0;
 161
 162 /* Flag indicating that the daemon is being started from inetd. */
 163 int inetd_flag = 0;
 164
 165 /* Flag indicating that sshd should not detach and become a daemon. */
 166 int no_daemon_flag = 0;
 167
 168 /* debug goes to stderr unless inetd_flag is set */
 169 int log_stderr = 0;
 170
 171 /* Saved arguments to main(). */
 172 char **saved_argv;
 173 int saved_argc;
 174
 175 /* re-exec */
 176 int rexeced_flag = 0;
 177 int rexec_flag = 1;
 178 int rexec_argc = 0;
 179 char **rexec_argv;
 180
 181 /*
 182  * The sockets that the server is listening; this is used in the SIGHUP
 183  * signal handler.
 184  */
 185 #define MAX_LISTEN_SOCKS        16
 186 int listen_socks[MAX_LISTEN_SOCKS];
 187 int num_listen_socks = 0;
 188
 189 /*
 190  * the client's version string, passed by sshd2 in compat mode. if != NULL,
 191  * sshd will skip the version-number exchange
 192  */
 193 char *client_version_string = NULL;
 194 char *server_version_string = NULL;
 195
 196 /* for rekeying XXX fixme */
 197 Kex *xxx_kex;
 198
 199 /*
 200  * Any really sensitive data in the application is contained in this
 201  * structure. The idea is that this structure could be locked into memory so
 202  * that the pages do not get written into swap.  However, there are some
 203  * problems. The private key contains BIGNUMs, and we do not (in principle)
 204  * have access to the internals of them, and locking just the structure is
 205  * not very useful.  Currently, memory locking is not implemented.
 206  */
 207 struct {
 208         Key     *server_key;            /* ephemeral server key */
 209         Key     *ssh1_host_key;         /* ssh1 host key */
 210         Key     **host_keys;            /* all private host keys */
 211         int     have_ssh1_key;
 212         int     have_ssh2_key;
 213         u_char  ssh1_cookie[SSH_SESSION_KEY_LENGTH];
 214 } sensitive_data;
 215
 216 /*
 217  * Flag indicating whether the RSA server key needs to be regenerated.
 218  * Is set in the SIGALRM handler and cleared when the key is regenerated.
 219  */
 220 static volatile sig_atomic_t key_do_regen = 0;
 221
 222 /* This is set to true when a signal is received. */
 223 static volatile sig_atomic_t received_sighup = 0;
 224 static volatile sig_atomic_t received_sigterm = 0;
 225
 226 /* session identifier, used by RSA-auth */
 227 u_char session_id[16];
 228
 229 /* same for ssh2 */
 230 u_char *session_id2 = NULL;
 231 u_int session_id2_len = 0;
 232
 233 /* record remote hostname or ip */
 234 u_int utmp_len = MAXHOSTNAMELEN;
 235
 236 /* options.max_startup sized array of fd ints */
 237 int *startup_pipes = NULL;
 238 int startup_pipe;               /* in child */
 239
 240 /* variables used for privilege separation */
 241 int use_privsep = -1;
 242 struct monitor *pmonitor = NULL;
 243
 244 /* global authentication context */
 245 Authctxt *the_authctxt = NULL;
 246
 247 /* sshd_config buffer */
 248 Buffer cfg;
 249
 250 /* message to be displayed after login */
 251 Buffer loginmsg;
 252
 253 /* Unprivileged user */
 254 struct passwd *privsep_pw = NULL;
 255
 256 /* Prototypes for various functions defined later in this file. */
 257 void destroy_sensitive_data(void);
 258 void demote_sensitive_data(void);
 259
 260 static void do_ssh1_kex(void);
 261 static void do_ssh2_kex(void);
 262
 263 /*
 264  * Close all listening sockets
 265  */
 266 static void
 267 close_listen_socks(void)
 268 {
 269         int i;
 270
 271         for (i = 0; i < num_listen_socks; i++)
 272                 close(listen_socks[i]);
 273         num_listen_socks = -1;
 274 }
 275
 276 static void
 277 close_startup_pipes(void)
 278 {
 279         int i;
 280
 281         if (startup_pipes)
 282                 for (i = 0; i < options.max_startups; i++)
 283                         if (startup_pipes[i] != -1)
 284                                 close(startup_pipes[i]);
 285 }
 286
 287 /*
 288  * Signal handler for SIGHUP.  Sshd execs itself when it receives SIGHUP;
 289  * the effect is to reread the configuration file (and to regenerate
 290  * the server key).
 291  */
 292
 293 /*ARGSUSED*/
 294 static void
 295 sighup_handler(int sig)
 296 {
 297         int save_errno = errno;
 298
 299         received_sighup = 1;
 300         signal(SIGHUP, sighup_handler);
 301         errno = save_errno;
 302 }
 303
 304 /*
 305  * Called from the main program after receiving SIGHUP.
 306  * Restarts the server.
 307  */
 308 static void
 309 sighup_restart(void)
 310 {
 311         logit("Received SIGHUP; restarting.");
 312         close_listen_socks();
 313         close_startup_pipes();
 314         alarm(0);  /* alarm timer persists across exec */
 315         execv(saved_argv[0], saved_argv);
 316         logit("RESTART FAILED: av[0]='%.100s', error: %.100s.", saved_argv[0],
 317             strerror(errno));
 318         exit(1);
 319 }
 320
 321 /*
 322  * Generic signal handler for terminating signals in the master daemon.
 323  */
 324 /*ARGSUSED*/
 325 static void
 326 sigterm_handler(int sig)
 327 {
 328         received_sigterm = sig;
 329 }
 330
 331 /*
 332  * SIGCHLD handler.  This is called whenever a child dies.  This will then
 333  * reap any zombies left by exited children.
 334  */
 335 /*ARGSUSED*/
 336 static void
 337 main_sigchld_handler(int sig)
 338 {
 339         int save_errno = errno;
 340         pid_t pid;
 341         int status;
 342
 343         while ((pid = waitpid(-1, &status, WNOHANG)) > 0 ||
 344             (pid < 0 && errno == EINTR))
 345                 ;
 346
 347         signal(SIGCHLD, main_sigchld_handler);
 348         errno = save_errno;
 349 }
 350
 351 /*
 352  * Signal handler for the alarm after the login grace period has expired.
 353  */
 354 /*ARGSUSED*/
 355 static void
 356 grace_alarm_handler(int sig)
 357 {
 358         if (use_privsep && pmonitor != NULL && pmonitor->m_pid > 0)
 359                 kill(pmonitor->m_pid, SIGALRM);
 360
 361         /* Log error and exit. */
 362         sigdie("Timeout before authentication for %s", get_remote_ipaddr());
 363 }
 364
 365 /*
 366  * Signal handler for the key regeneration alarm.  Note that this
 367  * alarm only occurs in the daemon waiting for connections, and it does not
 368  * do anything with the private key or random state before forking.
 369  * Thus there should be no concurrency control/asynchronous execution
 370  * problems.
 371  */
 372 static void
 373 generate_ephemeral_server_key(void)
 374 {
 375         verbose("Generating %s%d bit RSA key.",
 376             sensitive_data.server_key ? "new " : "", options.server_key_bits);
 377         if (sensitive_data.server_key != NULL)
 378                 key_free(sensitive_data.server_key);
 379         sensitive_data.server_key = key_generate(KEY_RSA1,
 380             options.server_key_bits);
 381         verbose("RSA key generation complete.");
 382
 383         arc4random_buf(sensitive_data.ssh1_cookie, SSH_SESSION_KEY_LENGTH);
 384         arc4random_stir();
 385 }
 386
 387 /*ARGSUSED*/
 388 static void
 389 key_regeneration_alarm(int sig)
 390 {
 391         int save_errno = errno;
 392
 393         signal(SIGALRM, SIG_DFL);
 394         errno = save_errno;
 395         key_do_regen = 1;
 396 }
 397
 398 static void
 399 sshd_exchange_identification(int sock_in, int sock_out)
 400 {
 401         u_int i;
 402         int mismatch;
 403         int remote_major, remote_minor;
 404         int major, minor;
 405         char *s, *newline = "\n";
 406         char buf[256];                  /* Must not be larger than remote_version. */
 407         char remote_version[256];       /* Must be at least as big as buf. */
 408
 409         if ((options.protocol & SSH_PROTO_1) &&
 410             (options.protocol & SSH_PROTO_2)) {
 411                 major = PROTOCOL_MAJOR_1;
 412                 minor = 99;
 413         } else if (options.protocol & SSH_PROTO_2) {
 414                 major = PROTOCOL_MAJOR_2;
 415                 minor = PROTOCOL_MINOR_2;
 416                 newline = "\r\n";
 417         } else {
 418                 major = PROTOCOL_MAJOR_1;
 419                 minor = PROTOCOL_MINOR_1;
 420         }
 421         snprintf(buf, sizeof buf, "SSH-%d.%d-%.100s%s", major, minor,
 422             SSH_VERSION, newline);
 423         server_version_string = xstrdup(buf);
 424
 425         /* Send our protocol version identification. */
 426         if (atomicio(vwrite, sock_out, server_version_string,
 427             strlen(server_version_string))
 428             != strlen(server_version_string)) {
 429                 logit("Could not write ident string to %s", get_remote_ipaddr());
 430                 cleanup_exit(255);
 431         }
 432
 433         /* Read other sides version identification. */
 434         memset(buf, 0, sizeof(buf));
 435         for (i = 0; i < sizeof(buf) - 1; i++) {
 436                 if (atomicio(read, sock_in, &buf[i], 1) != 1) {
 437                         logit("Did not receive identification string from %s",
 438                             get_remote_ipaddr());
 439                         cleanup_exit(255);
 440                 }
 441                 if (buf[i] == '\r') {
 442                         buf[i] = 0;
 443                         /* Kludge for F-Secure Macintosh < 1.0.2 */
 444                         if (i == 12 &&
 445                             strncmp(buf, "SSH-1.5-W1.0", 12) == 0)
 446                                 break;
 447                         continue;
 448                 }
 449                 if (buf[i] == '\n') {
 450                         buf[i] = 0;
 451                         break;
 452                 }
 453         }
 454         buf[sizeof(buf) - 1] = 0;
 455         client_version_string = xstrdup(buf);
 456
 457         /*
 458          * Check that the versions match.  In future this might accept
 459          * several versions and set appropriate flags to handle them.
 460          */
 461         if (sscanf(client_version_string, "SSH-%d.%d-%[^\n]\n",
 462             &remote_major, &remote_minor, remote_version) != 3) {
 463                 s = "Protocol mismatch.\n";
 464                 (void) atomicio(vwrite, sock_out, s, strlen(s));
 465                 close(sock_in);
 466                 close(sock_out);
 467                 logit("Bad protocol version identification '%.100s' from %s",
 468                     client_version_string, get_remote_ipaddr());
 469                 cleanup_exit(255);
 470         }
 471         debug("Client protocol version %d.%d; client software version %.100s",
 472             remote_major, remote_minor, remote_version);
 473
 474         compat_datafellows(remote_version);
 475
 476         if (datafellows & SSH_BUG_PROBE) {
 477                 logit("probed from %s with %s.  Don't panic.",
 478                     get_remote_ipaddr(), client_version_string);
 479                 cleanup_exit(255);
 480         }
 481
 482         if (datafellows & SSH_BUG_SCANNER) {
 483                 logit("scanned from %s with %s.  Don't panic.",
 484                     get_remote_ipaddr(), client_version_string);
 485                 cleanup_exit(255);
 486         }
 487
 488         mismatch = 0;
 489         switch (remote_major) {
 490         case 1:
 491                 if (remote_minor == 99) {
 492                         if (options.protocol & SSH_PROTO_2)
 493                                 enable_compat20();
 494                         else
 495                                 mismatch = 1;
 496                         break;
 497                 }
 498                 if (!(options.protocol & SSH_PROTO_1)) {
 499                         mismatch = 1;
 500                         break;
 501                 }
 502                 if (remote_minor < 3) {
 503                         packet_disconnect("Your ssh version is too old and "
 504                             "is no longer supported.  Please install a newer version.");
 505                 } else if (remote_minor == 3) {
 506                         /* note that this disables agent-forwarding */
 507                         enable_compat13();
 508                 }
 509                 break;
 510         case 2:
 511                 if (options.protocol & SSH_PROTO_2) {
 512                         enable_compat20();
 513                         break;
 514                 }
 515                 /* FALLTHROUGH */
 516         default:
 517                 mismatch = 1;
 518                 break;
 519         }
 520         chop(server_version_string);
 521         debug("Local version string %.200s", server_version_string);
 522
 523         if (mismatch) {
 524                 s = "Protocol major versions differ.\n";
 525                 (void) atomicio(vwrite, sock_out, s, strlen(s));
 526                 close(sock_in);
 527                 close(sock_out);
 528                 logit("Protocol major versions differ for %s: %.200s vs. %.200s",
 529                     get_remote_ipaddr(),
 530                     server_version_string, client_version_string);
 531                 cleanup_exit(255);
 532         }
 533 }
 534
 535 /* Destroy the host and server keys.  They will no longer be needed. */
 536 void
 537 destroy_sensitive_data(void)
 538 {
 539         int i;
 540
 541         if (sensitive_data.server_key) {
 542                 key_free(sensitive_data.server_key);
 543                 sensitive_data.server_key = NULL;
 544         }
 545         for (i = 0; i < options.num_host_key_files; i++) {
 546                 if (sensitive_data.host_keys[i]) {
 547                         key_free(sensitive_data.host_keys[i]);
 548                         sensitive_data.host_keys[i] = NULL;
 549                 }
 550         }
 551         sensitive_data.ssh1_host_key = NULL;
 552         memset(sensitive_data.ssh1_cookie, 0, SSH_SESSION_KEY_LENGTH);
 553 }
 554
 555 /* Demote private to public keys for network child */
 556 void
 557 demote_sensitive_data(void)
 558 {
 559         Key *tmp;
 560         int i;
 561
 562         if (sensitive_data.server_key) {
 563                 tmp = key_demote(sensitive_data.server_key);
 564                 key_free(sensitive_data.server_key);
 565                 sensitive_data.server_key = tmp;
 566         }
 567
 568         for (i = 0; i < options.num_host_key_files; i++) {
 569                 if (sensitive_data.host_keys[i]) {
 570                         tmp = key_demote(sensitive_data.host_keys[i]);
 571                         key_free(sensitive_data.host_keys[i]);
 572                         sensitive_data.host_keys[i] = tmp;
 573                         if (tmp->type == KEY_RSA1)
 574                                 sensitive_data.ssh1_host_key = tmp;
 575                 }
 576         }
 577
 578         /* We do not clear ssh1_host key and cookie.  XXX - Okay Niels? */
 579 }
 580
 581 static void
 582 privsep_preauth_child(void)
 583 {
 584         u_int32_t rnd[256];
 585         gid_t gidset[1];
 586
 587         /* Enable challenge-response authentication for privilege separation */
 588         privsep_challenge_enable();
 589
 590         arc4random_stir();
 591         arc4random_buf(rnd, sizeof(rnd));
 592         RAND_seed(rnd, sizeof(rnd));
 593
 594         /* Demote the private keys to public keys. */
 595         demote_sensitive_data();
 596
 597         /* Change our root directory */
 598         if (chroot(_PATH_PRIVSEP_CHROOT_DIR) == -1)
 599                 fatal("chroot(\"%s\"): %s", _PATH_PRIVSEP_CHROOT_DIR,
 600                     strerror(errno));
 601         if (chdir("/") == -1)
 602                 fatal("chdir(\"/\"): %s", strerror(errno));
 603
 604         /* Drop our privileges */
 605         debug3("privsep user:group %u:%u", (u_int)privsep_pw->pw_uid,
 606             (u_int)privsep_pw->pw_gid);
 607 #if 0
 608         /* XXX not ready, too heavy after chroot */
 609         do_setusercontext(privsep_pw);
 610 #else
 611         gidset[0] = privsep_pw->pw_gid;
 612         if (setgroups(1, gidset) < 0)
 613                 fatal("setgroups: %.100s", strerror(errno));
 614         permanently_set_uid(privsep_pw);
 615 #endif
 616 }
 617
 618 static int
 619 privsep_preauth(Authctxt *authctxt)
 620 {
 621         int status;
 622         pid_t pid;
 623
 624         /* Set up unprivileged child process to deal with network data */
 625         pmonitor = monitor_init();
 626         /* Store a pointer to the kex for later rekeying */
 627         pmonitor->m_pkex = &xxx_kex;
 628
 629         pid = fork();
 630         if (pid == -1) {
 631                 fatal("fork of unprivileged child failed");
 632         } else if (pid != 0) {
 633                 debug2("Network child is on pid %ld", (long)pid);
 634
 635                 close(pmonitor->m_recvfd);
 636                 pmonitor->m_pid = pid;
 637                 monitor_child_preauth(authctxt, pmonitor);
 638                 close(pmonitor->m_sendfd);
 639
 640                 /* Sync memory */
 641                 monitor_sync(pmonitor);
 642
 643                 /* Wait for the child's exit status */
 644                 while (waitpid(pid, &status, 0) < 0)
 645                         if (errno != EINTR)
 646                                 break;
 647                 return (1);
 648         } else {
 649                 /* child */
 650
 651                 close(pmonitor->m_sendfd);
 652
 653                 /* Demote the child */
 654                 if (getuid() == 0 || geteuid() == 0)
 655                         privsep_preauth_child();
 656                 setproctitle("%s", "[net]");
 657         }
 658         return (0);
 659 }
 660
 661 static void
 662 privsep_postauth(Authctxt *authctxt)
 663 {
 664         u_int32_t rnd[256];
 665
 666 #ifdef DISABLE_FD_PASSING
 667         if (1) {
 668 #else
 669         if (authctxt->pw->pw_uid == 0 || options.use_login) {
 670 #endif
 671                 /* File descriptor passing is broken or root login */
 672                 use_privsep = 0;
 673                 goto skip;
 674         }
 675
 676         /* New socket pair */
 677         monitor_reinit(pmonitor);
 678
 679         pmonitor->m_pid = fork();
 680         if (pmonitor->m_pid == -1)
 681                 fatal("fork of unprivileged child failed");
 682         else if (pmonitor->m_pid != 0) {
 683                 verbose("User child is on pid %ld", (long)pmonitor->m_pid);
 684                 close(pmonitor->m_recvfd);
 685                 buffer_clear(&loginmsg);
 686                 monitor_child_postauth(pmonitor);
 687
 688                 /* NEVERREACHED */
 689                 exit(0);
 690         }
 691
 692         close(pmonitor->m_sendfd);
 693
 694         /* Demote the private keys to public keys. */
 695         demote_sensitive_data();
 696
 697         arc4random_stir();
 698         arc4random_buf(rnd, sizeof(rnd));
 699         RAND_seed(rnd, sizeof(rnd));
 700
 701         /* Drop privileges */
 702         do_setusercontext(authctxt->pw);
 703
 704  skip:
 705         /* It is safe now to apply the key state */
 706         monitor_apply_keystate(pmonitor);
 707
 708         /*
 709          * Tell the packet layer that authentication was successful, since
 710          * this information is not part of the key state.
 711          */
 712         packet_set_authenticated();
 713 }
 714
 715 static char *
 716 list_hostkey_types(void)
 717 {
 718         Buffer b;
 719         const char *p;
 720         char *ret;
 721         int i;
 722
 723         buffer_init(&b);
 724         for (i = 0; i < options.num_host_key_files; i++) {
 725                 Key *key = sensitive_data.host_keys[i];
 726                 if (key == NULL)
 727                         continue;
 728                 switch (key->type) {
 729                 case KEY_RSA:
 730                 case KEY_DSA:
 731                         if (buffer_len(&b) > 0)
 732                                 buffer_append(&b, ",", 1);
 733                         p = key_ssh_name(key);
 734                         buffer_append(&b, p, strlen(p));
 735                         break;
 736                 }
 737         }
 738         buffer_append(&b, "\0", 1);
 739         ret = xstrdup(buffer_ptr(&b));
 740         buffer_free(&b);
 741         debug("list_hostkey_types: %s", ret);
 742         return ret;
 743 }
 744
 745 Key *
 746 get_hostkey_by_type(int type)
 747 {
 748         int i;
 749
 750         for (i = 0; i < options.num_host_key_files; i++) {
 751                 Key *key = sensitive_data.host_keys[i];
 752                 if (key != NULL && key->type == type)
 753                         return key;
 754         }
 755         return NULL;
 756 }
 757
 758 Key *
 759 get_hostkey_by_index(int ind)
 760 {
 761         if (ind < 0 || ind >= options.num_host_key_files)
 762                 return (NULL);
 763         return (sensitive_data.host_keys[ind]);
 764 }
 765
 766 int
 767 get_hostkey_index(Key *key)
 768 {
 769         int i;
 770
 771         for (i = 0; i < options.num_host_key_files; i++) {
 772                 if (key == sensitive_data.host_keys[i])
 773                         return (i);
 774         }
 775         return (-1);
 776 }
 777
 778 /*
 779  * returns 1 if connection should be dropped, 0 otherwise.
 780  * dropping starts at connection #max_startups_begin with a probability
 781  * of (max_startups_rate/100). the probability increases linearly until
 782  * all connections are dropped for startups > max_startups
 783  */
 784 static int
 785 drop_connection(int startups)
 786 {
 787         int p, r;
 788
 789         if (startups < options.max_startups_begin)
 790                 return 0;
 791         if (startups >= options.max_startups)
 792                 return 1;
 793         if (options.max_startups_rate == 100)
 794                 return 1;
 795
 796         p  = 100 - options.max_startups_rate;
 797         p *= startups - options.max_startups_begin;
 798         p /= options.max_startups - options.max_startups_begin;
 799         p += options.max_startups_rate;
 800         r = arc4random_uniform(100);
 801
 802         debug("drop_connection: p %d, r %d", p, r);
 803         return (r < p) ? 1 : 0;
 804 }
 805
 806 static void
 807 usage(void)
 808 {
 809         fprintf(stderr, "%s, %s\n",
 810             SSH_RELEASE, SSLeay_version(SSLEAY_VERSION));
 811         fprintf(stderr,
 812 "usage: sshd [-46DdeiqTt] [-b bits] [-C connection_spec] [-f config_file]\n"
 813 "            [-g login_grace_time] [-h host_key_file] [-k key_gen_time]\n"
 814 "            [-o option] [-p port] [-u len]\n"
 815         );
 816         exit(1);
 817 }
 818
 819 static void
 820 send_rexec_state(int fd, Buffer *conf)
 821 {
 822         Buffer m;
 823
 824         debug3("%s: entering fd = %d config len %d", __func__, fd,
 825             buffer_len(conf));
 826
 827         /*
 828          * Protocol from reexec master to child:
 829          *      string  configuration
 830          *      u_int   ephemeral_key_follows
 831          *      bignum  e               (only if ephemeral_key_follows == 1)
 832          *      bignum  n                       "
 833          *      bignum  d                       "
 834          *      bignum  iqmp                    "
 835          *      bignum  p                       "
 836          *      bignum  q                       "
 837          *      string rngseed          (only if OpenSSL is not self-seeded)
 838          */
 839         buffer_init(&m);
 840         buffer_put_cstring(&m, buffer_ptr(conf));
 841
 842         if (sensitive_data.server_key != NULL &&
 843             sensitive_data.server_key->type == KEY_RSA1) {
 844                 buffer_put_int(&m, 1);
 845                 buffer_put_bignum(&m, sensitive_data.server_key->rsa->e);
 846                 buffer_put_bignum(&m, sensitive_data.server_key->rsa->n);
 847                 buffer_put_bignum(&m, sensitive_data.server_key->rsa->d);
 848                 buffer_put_bignum(&m, sensitive_data.server_key->rsa->iqmp);
 849                 buffer_put_bignum(&m, sensitive_data.server_key->rsa->p);
 850                 buffer_put_bignum(&m, sensitive_data.server_key->rsa->q);
 851         } else
 852                 buffer_put_int(&m, 0);
 853
 854 #ifndef OPENSSL_PRNG_ONLY
 855         rexec_send_rng_seed(&m);
 856 #endif
 857
 858         if (ssh_msg_send(fd, 0, &m) == -1)
 859                 fatal("%s: ssh_msg_send failed", __func__);
 860
 861         buffer_free(&m);
 862
 863         debug3("%s: done", __func__);
 864 }
 865
 866 static void
 867 recv_rexec_state(int fd, Buffer *conf)
 868 {
 869         Buffer m;
 870         char *cp;
 871         u_int len;
 872
 873         debug3("%s: entering fd = %d", __func__, fd);
 874
 875         buffer_init(&m);
 876
 877         if (ssh_msg_recv(fd, &m) == -1)
 878                 fatal("%s: ssh_msg_recv failed", __func__);
 879         if (buffer_get_char(&m) != 0)
 880                 fatal("%s: rexec version mismatch", __func__);
 881
 882         cp = buffer_get_string(&m, &len);
 883         if (conf != NULL)
 884                 buffer_append(conf, cp, len + 1);
 885         xfree(cp);
 886
 887         if (buffer_get_int(&m)) {
 888                 if (sensitive_data.server_key != NULL)
 889                         key_free(sensitive_data.server_key);
 890                 sensitive_data.server_key = key_new_private(KEY_RSA1);
 891                 buffer_get_bignum(&m, sensitive_data.server_key->rsa->e);
 892                 buffer_get_bignum(&m, sensitive_data.server_key->rsa->n);
 893                 buffer_get_bignum(&m, sensitive_data.server_key->rsa->d);
 894                 buffer_get_bignum(&m, sensitive_data.server_key->rsa->iqmp);
 895                 buffer_get_bignum(&m, sensitive_data.server_key->rsa->p);
 896                 buffer_get_bignum(&m, sensitive_data.server_key->rsa->q);
 897                 rsa_generate_additional_parameters(
 898                     sensitive_data.server_key->rsa);
 899         }
 900
 901 #ifndef OPENSSL_PRNG_ONLY
 902         rexec_recv_rng_seed(&m);
 903 #endif
 904
 905         buffer_free(&m);
 906
 907         debug3("%s: done", __func__);
 908 }
 909
 910 /* Accept a connection from inetd */
 911 static void
 912 server_accept_inetd(int *sock_in, int *sock_out)
 913 {
 914         int fd;
 915
 916         startup_pipe = -1;
 917         if (rexeced_flag) {
 918                 close(REEXEC_CONFIG_PASS_FD);
 919                 *sock_in = *sock_out = dup(STDIN_FILENO);
 920                 if (!debug_flag) {
 921                         startup_pipe = dup(REEXEC_STARTUP_PIPE_FD);
 922                         close(REEXEC_STARTUP_PIPE_FD);
 923                 }
 924         } else {
 925                 *sock_in = dup(STDIN_FILENO);
 926                 *sock_out = dup(STDOUT_FILENO);
 927         }
 928         /*
 929          * We intentionally do not close the descriptors 0, 1, and 2
 930          * as our code for setting the descriptors won't work if
 931          * ttyfd happens to be one of those.
 932          */
 933         if ((fd = open(_PATH_DEVNULL, O_RDWR, 0)) != -1) {
 934                 dup2(fd, STDIN_FILENO);
 935                 dup2(fd, STDOUT_FILENO);
 936                 if (fd > STDOUT_FILENO)
 937                         close(fd);
 938         }
 939         debug("inetd sockets after dupping: %d, %d", *sock_in, *sock_out);
 940 }
 941
 942 /*
 943  * Listen for TCP connections
 944  */
 945 static void
 946 server_listen(void)
 947 {
 948         int ret, listen_sock, on = 1;
 949         struct addrinfo *ai;
 950         char ntop[NI_MAXHOST], strport[NI_MAXSERV];
 951
 952         for (ai = options.listen_addrs; ai; ai = ai->ai_next) {
 953                 if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6)
 954                         continue;
 955                 if (num_listen_socks >= MAX_LISTEN_SOCKS)
 956                         fatal("Too many listen sockets. "
 957                             "Enlarge MAX_LISTEN_SOCKS");
 958                 if ((ret = getnameinfo(ai->ai_addr, ai->ai_addrlen,
 959                     ntop, sizeof(ntop), strport, sizeof(strport),
 960                     NI_NUMERICHOST|NI_NUMERICSERV)) != 0) {
 961                         error("getnameinfo failed: %.100s",
 962                             ssh_gai_strerror(ret));
 963                         continue;
 964                 }
 965                 /* Create socket for listening. */
 966                 listen_sock = socket(ai->ai_family, ai->ai_socktype,
 967                     ai->ai_protocol);
 968                 if (listen_sock < 0) {
 969                         /* kernel may not support ipv6 */
 970                         verbose("socket: %.100s", strerror(errno));
 971                         continue;
 972                 }
 973                 if (set_nonblock(listen_sock) == -1) {
 974                         close(listen_sock);
 975                         continue;
 976                 }
 977                 /*
 978                  * Set socket options.
 979                  * Allow local port reuse in TIME_WAIT.
 980                  */
 981                 if (setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR,
 982                     &on, sizeof(on)) == -1)
 983                         error("setsockopt SO_REUSEADDR: %s", strerror(errno));
 984
 985 #ifdef IPV6_V6ONLY
 986                 /* Only communicate in IPv6 over AF_INET6 sockets. */
 987                 if (ai->ai_family == AF_INET6) {
 988                         if (setsockopt(listen_sock, IPPROTO_IPV6, IPV6_V6ONLY,
 989                             &on, sizeof(on)) == -1)
 990                                 error("setsockopt IPV6_V6ONLY: %s",
 991                                     strerror(errno));
 992                 }
 993 #endif
 994
 995                 debug("Bind to port %s on %s.", strport, ntop);
 996
 997                 /* Bind the socket to the desired port. */
 998                 if (bind(listen_sock, ai->ai_addr, ai->ai_addrlen) < 0) {
 999                         error("Bind to port %s on %s failed: %.200s.",
1000                             strport, ntop, strerror(errno));
1001                         close(listen_sock);
1002                         continue;
1003                 }
1004                 listen_socks[num_listen_socks] = listen_sock;
1005                 num_listen_socks++;
1006
1007                 /* Start listening on the port. */
1008                 if (listen(listen_sock, SSH_LISTEN_BACKLOG) < 0)
1009                         fatal("listen on [%s]:%s: %.100s",
1010                             ntop, strport, strerror(errno));
1011                 logit("Server listening on %s port %s.", ntop, strport);
1012         }
1013         freeaddrinfo(options.listen_addrs);
1014
1015         if (!num_listen_socks)
1016                 fatal("Cannot bind any address.");
1017 }
1018
1019 /*
1020  * The main TCP accept loop. Note that, for the non-debug case, returns
1021  * from this function are in a forked subprocess.
1022  */
1023 static void
1024 server_accept_loop(int *sock_in, int *sock_out, int *newsock, int *config_s)
1025 {
1026         fd_set *fdset;
1027         int i, j, ret, maxfd;
1028         int key_used = 0, startups = 0;
1029         int startup_p[2] = { -1 , -1 };
1030         struct sockaddr_storage from;
1031         socklen_t fromlen;
1032         pid_t pid;
1033
1034         /* setup fd set for accept */
1035         fdset = NULL;
1036         maxfd = 0;
1037         for (i = 0; i < num_listen_socks; i++)
1038                 if (listen_socks[i] > maxfd)
1039                         maxfd = listen_socks[i];
1040         /* pipes connected to unauthenticated childs */
1041         startup_pipes = xcalloc(options.max_startups, sizeof(int));
1042         for (i = 0; i < options.max_startups; i++)
1043                 startup_pipes[i] = -1;
1044
1045         /*
1046          * Stay listening for connections until the system crashes or
1047          * the daemon is killed with a signal.
1048          */
1049         for (;;) {
1050                 if (received_sighup)
1051                         sighup_restart();
1052                 if (fdset != NULL)
1053                         xfree(fdset);
1054                 fdset = (fd_set *)xcalloc(howmany(maxfd + 1, NFDBITS),
1055                     sizeof(fd_mask));
1056
1057                 for (i = 0; i < num_listen_socks; i++)
1058                         FD_SET(listen_socks[i], fdset);
1059                 for (i = 0; i < options.max_startups; i++)
1060                         if (startup_pipes[i] != -1)
1061                                 FD_SET(startup_pipes[i], fdset);
1062
1063                 /* Wait in select until there is a connection. */
1064                 ret = select(maxfd+1, fdset, NULL, NULL, NULL);
1065                 if (ret < 0 && errno != EINTR)
1066                         error("select: %.100s", strerror(errno));
1067                 if (received_sigterm) {
1068                         logit("Received signal %d; terminating.",
1069                             (int) received_sigterm);
1070                         close_listen_socks();
1071                         unlink(options.pid_file);
1072                         exit(255);
1073                 }
1074                 if (key_used && key_do_regen) {
1075                         generate_ephemeral_server_key();
1076                         key_used = 0;
1077                         key_do_regen = 0;
1078                 }
1079                 if (ret < 0)
1080                         continue;
1081
1082                 for (i = 0; i < options.max_startups; i++)
1083                         if (startup_pipes[i] != -1 &&
1084                             FD_ISSET(startup_pipes[i], fdset)) {
1085                                 /*
1086                                  * the read end of the pipe is ready
1087                                  * if the child has closed the pipe
1088                                  * after successful authentication
1089                                  * or if the child has died
1090                                  */
1091                                 close(startup_pipes[i]);
1092                                 startup_pipes[i] = -1;
1093                                 startups--;
1094                         }
1095                 for (i = 0; i < num_listen_socks; i++) {
1096                         if (!FD_ISSET(listen_socks[i], fdset))
1097                                 continue;
1098                         fromlen = sizeof(from);
1099                         *newsock = accept(listen_socks[i],
1100                             (struct sockaddr *)&from, &fromlen);
1101                         if (*newsock < 0) {
1102                                 if (errno != EINTR && errno != EAGAIN &&
1103                                     errno != EWOULDBLOCK)
1104                                         error("accept: %.100s", strerror(errno));
1105                                 continue;
1106                         }
1107                         if (unset_nonblock(*newsock) == -1) {
1108                                 close(*newsock);
1109                                 continue;
1110                         }
1111                         if (drop_connection(startups) == 1) {
1112                                 debug("drop connection #%d", startups);
1113                                 close(*newsock);
1114                                 continue;
1115                         }
1116                         if (pipe(startup_p) == -1) {
1117                                 close(*newsock);
1118                                 continue;
1119                         }
1120
1121                         if (rexec_flag && socketpair(AF_UNIX,
1122                             SOCK_STREAM, 0, config_s) == -1) {
1123                                 error("reexec socketpair: %s",
1124                                     strerror(errno));
1125                                 close(*newsock);
1126                                 close(startup_p[0]);
1127                                 close(startup_p[1]);
1128                                 continue;
1129                         }
1130
1131                         for (j = 0; j < options.max_startups; j++)
1132                                 if (startup_pipes[j] == -1) {
1133                                         startup_pipes[j] = startup_p[0];
1134                                         if (maxfd < startup_p[0])
1135                                                 maxfd = startup_p[0];
1136                                         startups++;
1137                                         break;
1138                                 }
1139
1140                         /*
1141                          * Got connection.  Fork a child to handle it, unless
1142                          * we are in debugging mode.
1143                          */
1144                         if (debug_flag) {
1145                                 /*
1146                                  * In debugging mode.  Close the listening
1147                                  * socket, and start processing the
1148                                  * connection without forking.
1149                                  */
1150                                 debug("Server will not fork when running in debugging mode.");
1151                                 close_listen_socks();
1152                                 *sock_in = *newsock;
1153                                 *sock_out = *newsock;
1154                                 close(startup_p[0]);
1155                                 close(startup_p[1]);
1156                                 startup_pipe = -1;
1157                                 pid = getpid();
1158                                 if (rexec_flag) {
1159                                         send_rexec_state(config_s[0],
1160                                             &cfg);
1161                                         close(config_s[0]);
1162                                 }
1163                                 break;
1164                         }
1165
1166                         /*
1167                          * Normal production daemon.  Fork, and have
1168                          * the child process the connection. The
1169                          * parent continues listening.
1170                          */
1171                         platform_pre_fork();
1172                         if ((pid = fork()) == 0) {
1173                                 /*
1174                                  * Child.  Close the listening and
1175                                  * max_startup sockets.  Start using
1176                                  * the accepted socket. Reinitialize
1177                                  * logging (since our pid has changed).
1178                                  * We break out of the loop to handle
1179                                  * the connection.
1180                                  */
1181                                 platform_post_fork_child();
1182                                 startup_pipe = startup_p[1];
1183                                 close_startup_pipes();
1184                                 close_listen_socks();
1185                                 *sock_in = *newsock;
1186                                 *sock_out = *newsock;
1187                                 log_init(__progname,
1188                                     options.log_level,
1189                                     options.log_facility,
1190                                     log_stderr);
1191                                 if (rexec_flag)
1192                                         close(config_s[0]);
1193                                 break;
1194                         }
1195
1196                         /* Parent.  Stay in the loop. */
1197                         platform_post_fork_parent(pid);
1198                         if (pid < 0)
1199                                 error("fork: %.100s", strerror(errno));
1200                         else
1201                                 debug("Forked child %ld.", (long)pid);
1202
1203                         close(startup_p[1]);
1204
1205                         if (rexec_flag) {
1206                                 send_rexec_state(config_s[0], &cfg);
1207                                 close(config_s[0]);
1208                                 close(config_s[1]);
1209                         }
1210
1211                         /*
1212                          * Mark that the key has been used (it
1213                          * was "given" to the child).
1214                          */
1215                         if ((options.protocol & SSH_PROTO_1) &&
1216                             key_used == 0) {
1217                                 /* Schedule server key regeneration alarm. */
1218                                 signal(SIGALRM, key_regeneration_alarm);
1219                                 alarm(options.key_regeneration_time);
1220                                 key_used = 1;
1221                         }
1222
1223                         close(*newsock);
1224
1225                         /*
1226                          * Ensure that our random state differs
1227                          * from that of the child
1228                          */
1229                         arc4random_stir();
1230                 }
1231
1232                 /* child process check (or debug mode) */
1233                 if (num_listen_socks < 0)
1234                         break;
1235         }
1236 }
1237
1238
1239 /*
1240  * Main program for the daemon.
1241  */
1242 int
1243 main(int ac, char **av)
1244 {
1245         extern char *optarg;
1246         extern int optind;
1247         int opt, i, on = 1;
1248         int sock_in = -1, sock_out = -1, newsock = -1;
1249         const char *remote_ip;
1250         char *test_user = NULL, *test_host = NULL, *test_addr = NULL;
1251         int remote_port;
1252         char *line, *p, *cp;
1253         int config_s[2] = { -1 , -1 };
1254         u_int64_t ibytes, obytes;
1255         mode_t new_umask;
1256         Key *key;
1257         Authctxt *authctxt;
1258
1259 #ifdef HAVE_SECUREWARE
1260         (void)set_auth_parameters(ac, av);
1261 #endif
1262         __progname = ssh_get_progname(av[0]);
1263         init_rng();
1264
1265         /* Save argv. Duplicate so setproctitle emulation doesn't clobber it */
1266         saved_argc = ac;
1267         rexec_argc = ac;
1268         saved_argv = xcalloc(ac + 1, sizeof(*saved_argv));
1269         for (i = 0; i < ac; i++)
1270                 saved_argv[i] = xstrdup(av[i]);
1271         saved_argv[i] = NULL;
1272
1273 #ifndef HAVE_SETPROCTITLE
1274         /* Prepare for later setproctitle emulation */
1275         compat_init_setproctitle(ac, av);
1276         av = saved_argv;
1277 #endif
1278
1279         if (geteuid() == 0 && setgroups(0, NULL) == -1)
1280                 debug("setgroups(): %.200s", strerror(errno));
1281
1282         /* Ensure that fds 0, 1 and 2 are open or directed to /dev/null */
1283         sanitise_stdfd();
1284
1285         /* Initialize configuration options to their default values. */
1286         initialize_server_options(&options);
1287
1288         /* Parse command-line arguments. */
1289         while ((opt = getopt(ac, av, "f:p:b:k:h:g:u:o:C:dDeiqrtQRT46")) != -1) {
1290                 switch (opt) {
1291                 case '4':
1292                         options.address_family = AF_INET;
1293                         break;
1294                 case '6':
1295                         options.address_family = AF_INET6;
1296                         break;
1297                 case 'f':
1298                         config_file_name = optarg;
1299                         break;
1300                 case 'd':
1301                         if (debug_flag == 0) {
1302                                 debug_flag = 1;
1303                                 options.log_level = SYSLOG_LEVEL_DEBUG1;
1304                         } else if (options.log_level < SYSLOG_LEVEL_DEBUG3)
1305                                 options.log_level++;
1306                         break;
1307                 case 'D':
1308                         no_daemon_flag = 1;
1309                         break;
1310                 case 'e':
1311                         log_stderr = 1;
1312                         break;
1313                 case 'i':
1314                         inetd_flag = 1;
1315                         break;
1316                 case 'r':
1317                         rexec_flag = 0;
1318                         break;
1319                 case 'R':
1320                         rexeced_flag = 1;
1321                         inetd_flag = 1;
1322                         break;
1323                 case 'Q':
1324                         /* ignored */
1325                         break;
1326                 case 'q':
1327                         options.log_level = SYSLOG_LEVEL_QUIET;
1328                         break;
1329                 case 'b':
1330                         options.server_key_bits = (int)strtonum(optarg, 256,
1331                             32768, NULL);
1332                         break;
1333                 case 'p':
1334                         options.ports_from_cmdline = 1;
1335                         if (options.num_ports >= MAX_PORTS) {
1336                                 fprintf(stderr, "too many ports.\n");
1337                                 exit(1);
1338                         }
1339                         options.ports[options.num_ports++] = a2port(optarg);
1340                         if (options.ports[options.num_ports-1] <= 0) {
1341                                 fprintf(stderr, "Bad port number.\n");
1342                                 exit(1);
1343                         }
1344                         break;
1345                 case 'g':
1346                         if ((options.login_grace_time = convtime(optarg)) == -1) {
1347                                 fprintf(stderr, "Invalid login grace time.\n");
1348                                 exit(1);
1349                         }
1350                         break;
1351                 case 'k':
1352                         if ((options.key_regeneration_time = convtime(optarg)) == -1) {
1353                                 fprintf(stderr, "Invalid key regeneration interval.\n");
1354                                 exit(1);
1355                         }
1356                         break;
1357                 case 'h':
1358                         if (options.num_host_key_files >= MAX_HOSTKEYS) {
1359                                 fprintf(stderr, "too many host keys.\n");
1360                                 exit(1);
1361                         }
1362                         options.host_key_files[options.num_host_key_files++] = optarg;
1363                         break;
1364                 case 't':
1365                         test_flag = 1;
1366                         break;
1367                 case 'T':
1368                         test_flag = 2;
1369                         break;
1370                 case 'C':
1371                         cp = optarg;
1372                         while ((p = strsep(&cp, ",")) && *p != '\0') {
1373                                 if (strncmp(p, "addr=", 5) == 0)
1374                                         test_addr = xstrdup(p + 5);
1375                                 else if (strncmp(p, "host=", 5) == 0)
1376                                         test_host = xstrdup(p + 5);
1377                                 else if (strncmp(p, "user=", 5) == 0)
1378                                         test_user = xstrdup(p + 5);
1379                                 else {
1380                                         fprintf(stderr, "Invalid test "
1381                                             "mode specification %s\n", p);
1382                                         exit(1);
1383                                 }
1384                         }
1385                         break;
1386                 case 'u':
1387                         utmp_len = (u_int)strtonum(optarg, 0, MAXHOSTNAMELEN+1, NULL);
1388                         if (utmp_len > MAXHOSTNAMELEN) {
1389                                 fprintf(stderr, "Invalid utmp length.\n");
1390                                 exit(1);
1391                         }
1392                         break;
1393                 case 'o':
1394                         line = xstrdup(optarg);
1395                         if (process_server_config_line(&options, line,
1396                             "command-line", 0, NULL, NULL, NULL, NULL) != 0)
1397                                 exit(1);
1398                         xfree(line);
1399                         break;
1400                 case '?':
1401                 default:
1402                         usage();
1403                         break;
1404                 }
1405         }
1406         if (rexeced_flag || inetd_flag)
1407                 rexec_flag = 0;
1408         if (!test_flag && (rexec_flag && (av[0] == NULL || *av[0] != '/')))
1409                 fatal("sshd re-exec requires execution with an absolute path");
1410         if (rexeced_flag)
1411                 closefrom(REEXEC_MIN_FREE_FD);
1412         else
1413                 closefrom(REEXEC_DEVCRYPTO_RESERVED_FD);
1414
1415         SSLeay_add_all_algorithms();
1416
1417         /*
1418          * Force logging to stderr until we have loaded the private host
1419          * key (unless started from inetd)
1420          */
1421         log_init(__progname,
1422             options.log_level == SYSLOG_LEVEL_NOT_SET ?
1423             SYSLOG_LEVEL_INFO : options.log_level,
1424             options.log_facility == SYSLOG_FACILITY_NOT_SET ?
1425             SYSLOG_FACILITY_AUTH : options.log_facility,
1426             log_stderr || !inetd_flag);
1427
1428         /*
1429          * Unset KRB5CCNAME, otherwise the user's session may inherit it from
1430          * root's environment
1431          */
1432         if (getenv("KRB5CCNAME") != NULL)
1433                 unsetenv("KRB5CCNAME");
1434
1435 #ifdef _UNICOS
1436         /* Cray can define user privs drop all privs now!
1437          * Not needed on PRIV_SU systems!
1438          */
1439         drop_cray_privs();
1440 #endif
1441
1442         sensitive_data.server_key = NULL;
1443         sensitive_data.ssh1_host_key = NULL;
1444         sensitive_data.have_ssh1_key = 0;
1445         sensitive_data.have_ssh2_key = 0;
1446
1447         /*
1448          * If we're doing an extended config test, make sure we have all of
1449          * the parameters we need.  If we're not doing an extended test,
1450          * do not silently ignore connection test params.
1451          */
1452         if (test_flag >= 2 &&
1453            (test_user != NULL || test_host != NULL || test_addr != NULL)
1454             && (test_user == NULL || test_host == NULL || test_addr == NULL))
1455                 fatal("user, host and addr are all required when testing "
1456                    "Match configs");
1457         if (test_flag < 2 && (test_user != NULL || test_host != NULL ||
1458             test_addr != NULL))
1459                 fatal("Config test connection parameter (-C) provided without "
1460                    "test mode (-T)");
1461
1462         /* Fetch our configuration */
1463         buffer_init(&cfg);
1464         if (rexeced_flag)
1465                 recv_rexec_state(REEXEC_CONFIG_PASS_FD, &cfg);
1466         else
1467                 load_server_config(config_file_name, &cfg);
1468
1469         parse_server_config(&options, rexeced_flag ? "rexec" : config_file_name,
1470             &cfg, NULL, NULL, NULL);
1471
1472         seed_rng();
1473
1474         /* Fill in default values for those options not explicitly set. */
1475         fill_default_server_options(&options);
1476
1477         /* challenge-response is implemented via keyboard interactive */
1478         if (options.challenge_response_authentication)
1479                 options.kbd_interactive_authentication = 1;
1480
1481         /* set default channel AF */
1482         channel_set_af(options.address_family);
1483
1484         /* Check that there are no remaining arguments. */
1485         if (optind < ac) {
1486                 fprintf(stderr, "Extra argument %s.\n", av[optind]);
1487                 exit(1);
1488         }
1489
1490         debug("sshd version %.100s", SSH_RELEASE);
1491
1492         /* Store privilege separation user for later use if required. */
1493         if ((privsep_pw = getpwnam(SSH_PRIVSEP_USER)) == NULL) {
1494                 if (use_privsep || options.kerberos_authentication)
1495                         fatal("Privilege separation user %s does not exist",
1496                             SSH_PRIVSEP_USER);
1497         } else {
1498                 memset(privsep_pw->pw_passwd, 0, strlen(privsep_pw->pw_passwd));
1499                 privsep_pw = pwcopy(privsep_pw);
1500                 xfree(privsep_pw->pw_passwd);
1501                 privsep_pw->pw_passwd = xstrdup("*");
1502         }
1503         endpwent();
1504
1505         /* load private host keys */
1506         sensitive_data.host_keys = xcalloc(options.num_host_key_files,
1507             sizeof(Key *));
1508         for (i = 0; i < options.num_host_key_files; i++)
1509                 sensitive_data.host_keys[i] = NULL;
1510
1511         for (i = 0; i < options.num_host_key_files; i++) {
1512                 key = key_load_private(options.host_key_files[i], "", NULL);
1513                 sensitive_data.host_keys[i] = key;
1514                 if (key == NULL) {
1515                         error("Could not load host key: %s",
1516                             options.host_key_files[i]);
1517                         sensitive_data.host_keys[i] = NULL;
1518                         continue;
1519                 }
1520                 switch (key->type) {
1521                 case KEY_RSA1:
1522                         sensitive_data.ssh1_host_key = key;
1523                         sensitive_data.have_ssh1_key = 1;
1524                         break;
1525                 case KEY_RSA:
1526                 case KEY_DSA:
1527                         sensitive_data.have_ssh2_key = 1;
1528                         break;
1529                 }
1530                 debug("private host key: #%d type %d %s", i, key->type,
1531                     key_type(key));
1532         }
1533         if ((options.protocol & SSH_PROTO_1) && !sensitive_data.have_ssh1_key) {
1534                 logit("Disabling protocol version 1. Could not load host key");
1535                 options.protocol &= ~SSH_PROTO_1;
1536         }
1537 #ifndef GSSAPI
1538         /* The GSSAPI key exchange can run without a host key */
1539         if ((options.protocol & SSH_PROTO_2) && !sensitive_data.have_ssh2_key) {
1540                 logit("Disabling protocol version 2. Could not load host key");
1541                 options.protocol &= ~SSH_PROTO_2;
1542         }
1543 #endif
1544         if (!(options.protocol & (SSH_PROTO_1|SSH_PROTO_2))) {
1545                 logit("sshd: no hostkeys available -- exiting.");
1546                 exit(1);
1547         }
1548
1549         /* Check certain values for sanity. */
1550         if (options.protocol & SSH_PROTO_1) {
1551                 if (options.server_key_bits < 512 ||
1552                     options.server_key_bits > 32768) {
1553                         fprintf(stderr, "Bad server key size.\n");
1554                         exit(1);
1555                 }
1556                 /*
1557                  * Check that server and host key lengths differ sufficiently. This
1558                  * is necessary to make double encryption work with rsaref. Oh, I
1559                  * hate software patents. I dont know if this can go? Niels
1560                  */
1561                 if (options.server_key_bits >
1562                     BN_num_bits(sensitive_data.ssh1_host_key->rsa->n) -
1563                     SSH_KEY_BITS_RESERVED && options.server_key_bits <
1564                     BN_num_bits(sensitive_data.ssh1_host_key->rsa->n) +
1565                     SSH_KEY_BITS_RESERVED) {
1566                         options.server_key_bits =
1567                             BN_num_bits(sensitive_data.ssh1_host_key->rsa->n) +
1568                             SSH_KEY_BITS_RESERVED;
1569                         debug("Forcing server key to %d bits to make it differ from host key.",
1570                             options.server_key_bits);
1571                 }
1572         }
1573
1574         if (use_privsep) {
1575                 struct stat st;
1576
1577                 if ((stat(_PATH_PRIVSEP_CHROOT_DIR, &st) == -1) ||
1578                     (S_ISDIR(st.st_mode) == 0))
1579                         fatal("Missing privilege separation directory: %s",
1580                             _PATH_PRIVSEP_CHROOT_DIR);
1581
1582 #ifdef HAVE_CYGWIN
1583                 if (check_ntsec(_PATH_PRIVSEP_CHROOT_DIR) &&
1584                     (st.st_uid != getuid () ||
1585                     (st.st_mode & (S_IWGRP|S_IWOTH)) != 0))
1586 #else
1587                 if (st.st_uid != 0 || (st.st_mode & (S_IWGRP|S_IWOTH)) != 0)
1588 #endif
1589                         fatal("%s must be owned by root and not group or "
1590                             "world-writable.", _PATH_PRIVSEP_CHROOT_DIR);
1591         }
1592
1593         if (test_flag > 1) {
1594                 if (test_user != NULL && test_addr != NULL && test_host != NULL)
1595                         parse_server_match_config(&options, test_user,
1596                             test_host, test_addr);
1597                 dump_config(&options);
1598         }
1599
1600         /* Configuration looks good, so exit if in test mode. */
1601         if (test_flag)
1602                 exit(0);
1603
1604         /*
1605          * Clear out any supplemental groups we may have inherited.  This
1606          * prevents inadvertent creation of files with bad modes (in the
1607          * portable version at least, it's certainly possible for PAM
1608          * to create a file, and we can't control the code in every
1609          * module which might be used).
1610          */
1611         if (setgroups(0, NULL) < 0)
1612                 debug("setgroups() failed: %.200s", strerror(errno));
1613
1614         if (rexec_flag) {
1615                 rexec_argv = xcalloc(rexec_argc + 2, sizeof(char *));
1616                 for (i = 0; i < rexec_argc; i++) {
1617                         debug("rexec_argv[%d]='%s'", i, saved_argv[i]);
1618                         rexec_argv[i] = saved_argv[i];
1619                 }
1620                 rexec_argv[rexec_argc] = "-R";
1621                 rexec_argv[rexec_argc + 1] = NULL;
1622         }
1623
1624         /* Ensure that umask disallows at least group and world write */
1625         new_umask = umask(0077) | 0022;
1626         (void) umask(new_umask);
1627
1628         /* Initialize the log (it is reinitialized below in case we forked). */
1629         if (debug_flag && (!inetd_flag || rexeced_flag))
1630                 log_stderr = 1;
1631         log_init(__progname, options.log_level, options.log_facility, log_stderr);
1632
1633         /*
1634          * If not in debugging mode, and not started from inetd, disconnect
1635          * from the controlling terminal, and fork.  The original process
1636          * exits.
1637          */
1638         if (!(debug_flag || inetd_flag || no_daemon_flag)) {
1639 #ifdef TIOCNOTTY
1640                 int fd;
1641 #endif /* TIOCNOTTY */
1642                 if (daemon(0, 0) < 0)
1643                         fatal("daemon() failed: %.200s", strerror(errno));
1644
1645                 /* Disconnect from the controlling tty. */
1646 #ifdef TIOCNOTTY
1647                 fd = open(_PATH_TTY, O_RDWR | O_NOCTTY);
1648                 if (fd >= 0) {
1649                         (void) ioctl(fd, TIOCNOTTY, NULL);
1650                         close(fd);
1651                 }
1652 #endif /* TIOCNOTTY */
1653         }
1654         /* Reinitialize the log (because of the fork above). */
1655         log_init(__progname, options.log_level, options.log_facility, log_stderr);
1656
1657         /* Initialize the random number generator. */
1658         arc4random_stir();
1659
1660         /* Chdir to the root directory so that the current disk can be
1661            unmounted if desired. */
1662         chdir("/");
1663
1664         /* ignore SIGPIPE */
1665         signal(SIGPIPE, SIG_IGN);
1666
1667         /* Get a connection, either from inetd or a listening TCP socket */
1668         if (inetd_flag) {
1669                 server_accept_inetd(&sock_in, &sock_out);
1670         } else {
1671                 server_listen();
1672
1673                 if (options.protocol & SSH_PROTO_1)
1674                         generate_ephemeral_server_key();
1675
1676                 signal(SIGHUP, sighup_handler);
1677                 signal(SIGCHLD, main_sigchld_handler);
1678                 signal(SIGTERM, sigterm_handler);
1679                 signal(SIGQUIT, sigterm_handler);
1680
1681                 /*
1682                  * Write out the pid file after the sigterm handler
1683                  * is setup and the listen sockets are bound
1684                  */
1685                 if (!debug_flag) {
1686                         FILE *f = fopen(options.pid_file, "w");
1687
1688                         if (f == NULL) {
1689                                 error("Couldn't create pid file \"%s\": %s",
1690                                     options.pid_file, strerror(errno));
1691                         } else {
1692                                 fprintf(f, "%ld\n", (long) getpid());
1693                                 fclose(f);
1694                         }
1695                 }
1696
1697                 /* Accept a connection and return in a forked child */
1698                 server_accept_loop(&sock_in, &sock_out,
1699                     &newsock, config_s);
1700         }
1701
1702         /* This is the child processing a new connection. */
1703         setproctitle("%s", "[accepted]");
1704
1705         /*
1706          * Create a new session and process group since the 4.4BSD
1707          * setlogin() affects the entire process group.  We don't
1708          * want the child to be able to affect the parent.
1709          */
1710 #if !defined(SSHD_ACQUIRES_CTTY)
1711         /*
1712          * If setsid is called, on some platforms sshd will later acquire a
1713          * controlling terminal which will result in "could not set
1714          * controlling tty" errors.
1715          */
1716         if (!debug_flag && !inetd_flag && setsid() < 0)
1717                 error("setsid: %.100s", strerror(errno));
1718 #endif
1719
1720         if (rexec_flag) {
1721                 int fd;
1722
1723                 debug("rexec start in %d out %d newsock %d pipe %d sock %d",
1724                     sock_in, sock_out, newsock, startup_pipe, config_s[0]);
1725                 dup2(newsock, STDIN_FILENO);
1726                 dup2(STDIN_FILENO, STDOUT_FILENO);
1727                 if (startup_pipe == -1)
1728                         close(REEXEC_STARTUP_PIPE_FD);
1729                 else
1730                         dup2(startup_pipe, REEXEC_STARTUP_PIPE_FD);
1731
1732                 dup2(config_s[1], REEXEC_CONFIG_PASS_FD);
1733                 close(config_s[1]);
1734                 if (startup_pipe != -1)
1735                         close(startup_pipe);
1736
1737                 execv(rexec_argv[0], rexec_argv);
1738
1739                 /* Reexec has failed, fall back and continue */
1740                 error("rexec of %s failed: %s", rexec_argv[0], strerror(errno));
1741                 recv_rexec_state(REEXEC_CONFIG_PASS_FD, NULL);
1742                 log_init(__progname, options.log_level,
1743                     options.log_facility, log_stderr);
1744
1745                 /* Clean up fds */
1746                 startup_pipe = REEXEC_STARTUP_PIPE_FD;
1747                 close(config_s[1]);
1748                 close(REEXEC_CONFIG_PASS_FD);
1749                 newsock = sock_out = sock_in = dup(STDIN_FILENO);
1750                 if ((fd = open(_PATH_DEVNULL, O_RDWR, 0)) != -1) {
1751                         dup2(fd, STDIN_FILENO);
1752                         dup2(fd, STDOUT_FILENO);
1753                         if (fd > STDERR_FILENO)
1754                                 close(fd);
1755                 }
1756                 debug("rexec cleanup in %d out %d newsock %d pipe %d sock %d",
1757                     sock_in, sock_out, newsock, startup_pipe, config_s[0]);
1758         }
1759
1760         /*
1761          * Disable the key regeneration alarm.  We will not regenerate the
1762          * key since we are no longer in a position to give it to anyone. We
1763          * will not restart on SIGHUP since it no longer makes sense.
1764          */
1765         alarm(0);
1766         signal(SIGALRM, SIG_DFL);
1767         signal(SIGHUP, SIG_DFL);
1768         signal(SIGTERM, SIG_DFL);
1769         signal(SIGQUIT, SIG_DFL);
1770         signal(SIGCHLD, SIG_DFL);
1771         signal(SIGINT, SIG_DFL);
1772
1773         /*
1774          * Register our connection.  This turns encryption off because we do
1775          * not have a key.
1776          */
1777         packet_set_connection(sock_in, sock_out);
1778         packet_set_server();
1779
1780         /* Set SO_KEEPALIVE if requested. */
1781         if (options.tcp_keep_alive && packet_connection_is_on_socket() &&
1782             setsockopt(sock_in, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on)) < 0)
1783                 error("setsockopt SO_KEEPALIVE: %.100s", strerror(errno));
1784
1785         if ((remote_port = get_remote_port()) < 0) {
1786                 debug("get_remote_port failed");
1787                 cleanup_exit(255);
1788         }
1789
1790         /*
1791          * We use get_canonical_hostname with usedns = 0 instead of
1792          * get_remote_ipaddr here so IP options will be checked.
1793          */
1794         (void) get_canonical_hostname(0);
1795         /*
1796          * The rest of the code depends on the fact that
1797          * get_remote_ipaddr() caches the remote ip, even if
1798          * the socket goes away.
1799          */
1800         remote_ip = get_remote_ipaddr();
1801
1802 #ifdef SSH_AUDIT_EVENTS
1803         audit_connection_from(remote_ip, remote_port);
1804 #endif
1805 #ifdef LIBWRAP
1806         allow_severity = options.log_facility|LOG_INFO;
1807         deny_severity = options.log_facility|LOG_WARNING;
1808         /* Check whether logins are denied from this host. */
1809         if (packet_connection_is_on_socket()) {
1810                 struct request_info req;
1811
1812                 request_init(&req, RQ_DAEMON, __progname, RQ_FILE, sock_in, 0);
1813                 fromhost(&req);
1814
1815                 if (!hosts_access(&req)) {
1816                         debug("Connection refused by tcp wrapper");
1817                         refuse(&req);
1818                         /* NOTREACHED */
1819                         fatal("libwrap refuse returns");
1820                 }
1821         }
1822 #endif /* LIBWRAP */
1823
1824         /* Log the connection. */
1825         verbose("Connection from %.500s port %d", remote_ip, remote_port);
1826
1827 #ifdef USE_SECURITY_SESSION_API
1828         /*
1829          * Create a new security session for use by the new user login if
1830          * the current session is the root session or we are not launched
1831          * by inetd (eg: debugging mode or server mode).  We do not
1832          * necessarily need to create a session if we are launched from
1833          * inetd because Panther xinetd will create a session for us.
1834          *
1835          * The only case where this logic will fail is if there is an
1836          * inetd running in a non-root session which is not creating
1837          * new sessions for us.  Then all the users will end up in the
1838          * same session (bad).
1839          *
1840          * When the client exits, the session will be destroyed for us
1841          * automatically.
1842          *
1843          * We must create the session before any credentials are stored
1844          * (including AFS pags, which happens a few lines below).
1845          */
1846         {
1847                 OSStatus err = 0;
1848                 SecuritySessionId sid = 0;
1849                 SessionAttributeBits sattrs = 0;
1850
1851                 err = SessionGetInfo(callerSecuritySession, &sid, &sattrs);
1852                 if (err)
1853                         error("SessionGetInfo() failed with error %.8X",
1854                             (unsigned) err);
1855                 else
1856                         debug("Current Session ID is %.8X / Session Attributes are %.8X",
1857                             (unsigned) sid, (unsigned) sattrs);
1858
1859                 if (inetd_flag && !(sattrs & sessionIsRoot))
1860                         debug("Running in inetd mode in a non-root session... "
1861                             "assuming inetd created the session for us.");
1862                 else {
1863                         debug("Creating new security session...");
1864                         err = SessionCreate(0, sessionHasTTY | sessionIsRemote);
1865                         if (err)
1866                                 error("SessionCreate() failed with error %.8X",
1867                                     (unsigned) err);
1868
1869                         err = SessionGetInfo(callerSecuritySession, &sid,
1870                             &sattrs);
1871                         if (err)
1872                                 error("SessionGetInfo() failed with error %.8X",
1873                                     (unsigned) err);
1874                         else
1875                                 debug("New Session ID is %.8X / Session Attributes are %.8X",
1876                                     (unsigned) sid, (unsigned) sattrs);
1877                 }
1878         }
1879 #endif
1880
1881         /*
1882          * We don't want to listen forever unless the other side
1883          * successfully authenticates itself.  So we set up an alarm which is
1884          * cleared after successful authentication.  A limit of zero
1885          * indicates no limit. Note that we don't set the alarm in debugging
1886          * mode; it is just annoying to have the server exit just when you
1887          * are about to discover the bug.
1888          */
1889         signal(SIGALRM, grace_alarm_handler);
1890         if (!debug_flag)
1891                 alarm(options.login_grace_time);
1892
1893         sshd_exchange_identification(sock_in, sock_out);
1894
1895         /* In inetd mode, generate ephemeral key only for proto 1 connections */
1896         if (!compat20 && inetd_flag && sensitive_data.server_key == NULL)
1897                 generate_ephemeral_server_key();
1898
1899         packet_set_nonblocking();
1900
1901         /* allocate authentication context */
1902         authctxt = xcalloc(1, sizeof(*authctxt));
1903
1904         authctxt->loginmsg = &loginmsg;
1905
1906         /* XXX global for cleanup, access from other modules */
1907         the_authctxt = authctxt;
1908
1909         /* prepare buffer to collect messages to display to user after login */
1910         buffer_init(&loginmsg);
1911
1912         if (use_privsep)
1913                 if (privsep_preauth(authctxt) == 1)
1914                         goto authenticated;
1915
1916         /* perform the key exchange */
1917         /* authenticate user and start session */
1918         if (compat20) {
1919                 do_ssh2_kex();
1920                 do_authentication2(authctxt);
1921         } else {
1922                 do_ssh1_kex();
1923                 do_authentication(authctxt);
1924         }
1925         /*
1926          * If we use privilege separation, the unprivileged child transfers
1927          * the current keystate and exits
1928          */
1929         if (use_privsep) {
1930                 mm_send_keystate(pmonitor);
1931                 exit(0);
1932         }
1933
1934  authenticated:
1935         /*
1936          * Cancel the alarm we set to limit the time taken for
1937          * authentication.
1938          */
1939         alarm(0);
1940         signal(SIGALRM, SIG_DFL);
1941         authctxt->authenticated = 1;
1942         if (startup_pipe != -1) {
1943                 close(startup_pipe);
1944                 startup_pipe = -1;
1945         }
1946
1947 #ifdef SSH_AUDIT_EVENTS
1948         audit_event(SSH_AUTH_SUCCESS);
1949 #endif
1950
1951 #ifdef GSSAPI
1952         if (options.gss_authentication) {
1953                 temporarily_use_uid(authctxt->pw);
1954                 ssh_gssapi_storecreds();
1955                 restore_uid();
1956         }
1957 #endif
1958 #ifdef USE_PAM
1959         if (options.use_pam) {
1960                 do_pam_setcred(1);
1961                 do_pam_session();
1962         }
1963 #endif
1964
1965         /*
1966          * In privilege separation, we fork another child and prepare
1967          * file descriptor passing.
1968          */
1969         if (use_privsep) {
1970                 privsep_postauth(authctxt);
1971                 /* the monitor process [priv] will not return */
1972                 if (!compat20)
1973                         destroy_sensitive_data();
1974         }
1975
1976         packet_set_timeout(options.client_alive_interval,
1977             options.client_alive_count_max);
1978
1979         /* Start session. */
1980         do_authenticated(authctxt);
1981
1982         /* The connection has been terminated. */
1983         packet_get_state(MODE_IN, NULL, NULL, NULL, &ibytes);
1984         packet_get_state(MODE_OUT, NULL, NULL, NULL, &obytes);
1985         verbose("Transferred: sent %llu, received %llu bytes", obytes, ibytes);
1986
1987         verbose("Closing connection to %.500s port %d", remote_ip, remote_port);
1988
1989 #ifdef USE_PAM
1990         if (options.use_pam)
1991                 finish_pam();
1992 #endif /* USE_PAM */
1993
1994 #ifdef SSH_AUDIT_EVENTS
1995         PRIVSEP(audit_event(SSH_CONNECTION_CLOSE));
1996 #endif
1997
1998         packet_close();
1999
2000         if (use_privsep)
2001                 mm_terminate();
2002
2003         exit(0);
2004 }
2005
2006 /*
2007  * Decrypt session_key_int using our private server key and private host key
2008  * (key with larger modulus first).
2009  */
2010 int
2011 ssh1_session_key(BIGNUM *session_key_int)
2012 {
2013         int rsafail = 0;
2014
2015         if (BN_cmp(sensitive_data.server_key->rsa->n,
2016             sensitive_data.ssh1_host_key->rsa->n) > 0) {
2017                 /* Server key has bigger modulus. */
2018                 if (BN_num_bits(sensitive_data.server_key->rsa->n) <
2019                     BN_num_bits(sensitive_data.ssh1_host_key->rsa->n) +
2020                     SSH_KEY_BITS_RESERVED) {
2021                         fatal("do_connection: %s: "
2022                             "server_key %d < host_key %d + SSH_KEY_BITS_RESERVED %d",
2023                             get_remote_ipaddr(),
2024                             BN_num_bits(sensitive_data.server_key->rsa->n),
2025                             BN_num_bits(sensitive_data.ssh1_host_key->rsa->n),
2026                             SSH_KEY_BITS_RESERVED);
2027                 }
2028                 if (rsa_private_decrypt(session_key_int, session_key_int,
2029                     sensitive_data.server_key->rsa) <= 0)
2030                         rsafail++;
2031                 if (rsa_private_decrypt(session_key_int, session_key_int,
2032                     sensitive_data.ssh1_host_key->rsa) <= 0)
2033                         rsafail++;
2034         } else {
2035                 /* Host key has bigger modulus (or they are equal). */
2036                 if (BN_num_bits(sensitive_data.ssh1_host_key->rsa->n) <
2037                     BN_num_bits(sensitive_data.server_key->rsa->n) +
2038                     SSH_KEY_BITS_RESERVED) {
2039                         fatal("do_connection: %s: "
2040                             "host_key %d < server_key %d + SSH_KEY_BITS_RESERVED %d",
2041                             get_remote_ipaddr(),
2042                             BN_num_bits(sensitive_data.ssh1_host_key->rsa->n),
2043                             BN_num_bits(sensitive_data.server_key->rsa->n),
2044                             SSH_KEY_BITS_RESERVED);
2045                 }
2046                 if (rsa_private_decrypt(session_key_int, session_key_int,
2047                     sensitive_data.ssh1_host_key->rsa) < 0)
2048                         rsafail++;
2049                 if (rsa_private_decrypt(session_key_int, session_key_int,
2050                     sensitive_data.server_key->rsa) < 0)
2051                         rsafail++;
2052         }
2053         return (rsafail);
2054 }
2055 /*
2056  * SSH1 key exchange
2057  */
2058 static void
2059 do_ssh1_kex(void)
2060 {
2061         int i, len;
2062         int rsafail = 0;
2063         BIGNUM *session_key_int;
2064         u_char session_key[SSH_SESSION_KEY_LENGTH];
2065         u_char cookie[8];
2066         u_int cipher_type, auth_mask, protocol_flags;
2067
2068         /*
2069          * Generate check bytes that the client must send back in the user
2070          * packet in order for it to be accepted; this is used to defy ip
2071          * spoofing attacks.  Note that this only works against somebody
2072          * doing IP spoofing from a remote machine; any machine on the local
2073          * network can still see outgoing packets and catch the random
2074          * cookie.  This only affects rhosts authentication, and this is one
2075          * of the reasons why it is inherently insecure.
2076          */
2077         arc4random_buf(cookie, sizeof(cookie));
2078
2079         /*
2080          * Send our public key.  We include in the packet 64 bits of random
2081          * data that must be matched in the reply in order to prevent IP
2082          * spoofing.
2083          */
2084         packet_start(SSH_SMSG_PUBLIC_KEY);
2085         for (i = 0; i < 8; i++)
2086                 packet_put_char(cookie[i]);
2087
2088         /* Store our public server RSA key. */
2089         packet_put_int(BN_num_bits(sensitive_data.server_key->rsa->n));
2090         packet_put_bignum(sensitive_data.server_key->rsa->e);
2091         packet_put_bignum(sensitive_data.server_key->rsa->n);
2092
2093         /* Store our public host RSA key. */
2094         packet_put_int(BN_num_bits(sensitive_data.ssh1_host_key->rsa->n));
2095         packet_put_bignum(sensitive_data.ssh1_host_key->rsa->e);
2096         packet_put_bignum(sensitive_data.ssh1_host_key->rsa->n);
2097
2098         /* Put protocol flags. */
2099         packet_put_int(SSH_PROTOFLAG_HOST_IN_FWD_OPEN);
2100
2101         /* Declare which ciphers we support. */
2102         packet_put_int(cipher_mask_ssh1(0));
2103
2104         /* Declare supported authentication types. */
2105         auth_mask = 0;
2106         if (options.rhosts_rsa_authentication)
2107                 auth_mask |= 1 << SSH_AUTH_RHOSTS_RSA;
2108         if (options.rsa_authentication)
2109                 auth_mask |= 1 << SSH_AUTH_RSA;
2110         if (options.challenge_response_authentication == 1)
2111                 auth_mask |= 1 << SSH_AUTH_TIS;
2112         if (options.password_authentication)
2113                 auth_mask |= 1 << SSH_AUTH_PASSWORD;
2114         packet_put_int(auth_mask);
2115
2116         /* Send the packet and wait for it to be sent. */
2117         packet_send();
2118         packet_write_wait();
2119
2120         debug("Sent %d bit server key and %d bit host key.",
2121             BN_num_bits(sensitive_data.server_key->rsa->n),
2122             BN_num_bits(sensitive_data.ssh1_host_key->rsa->n));
2123
2124         /* Read clients reply (cipher type and session key). */
2125         packet_read_expect(SSH_CMSG_SESSION_KEY);
2126
2127         /* Get cipher type and check whether we accept this. */
2128         cipher_type = packet_get_char();
2129
2130         if (!(cipher_mask_ssh1(0) & (1 << cipher_type)))
2131                 packet_disconnect("Warning: client selects unsupported cipher.");
2132
2133         /* Get check bytes from the packet.  These must match those we
2134            sent earlier with the public key packet. */
2135         for (i = 0; i < 8; i++)
2136                 if (cookie[i] != packet_get_char())
2137                         packet_disconnect("IP Spoofing check bytes do not match.");
2138
2139         debug("Encryption type: %.200s", cipher_name(cipher_type));
2140
2141         /* Get the encrypted integer. */
2142         if ((session_key_int = BN_new()) == NULL)
2143                 fatal("do_ssh1_kex: BN_new failed");
2144         packet_get_bignum(session_key_int);
2145
2146         protocol_flags = packet_get_int();
2147         packet_set_protocol_flags(protocol_flags);
2148         packet_check_eom();
2149
2150         /* Decrypt session_key_int using host/server keys */
2151         rsafail = PRIVSEP(ssh1_session_key(session_key_int));
2152
2153         /*
2154          * Extract session key from the decrypted integer.  The key is in the
2155          * least significant 256 bits of the integer; the first byte of the
2156          * key is in the highest bits.
2157          */
2158         if (!rsafail) {
2159                 (void) BN_mask_bits(session_key_int, sizeof(session_key) * 8);
2160                 len = BN_num_bytes(session_key_int);
2161                 if (len < 0 || (u_int)len > sizeof(session_key)) {
2162                         error("do_ssh1_kex: bad session key len from %s: "
2163                             "session_key_int %d > sizeof(session_key) %lu",
2164                             get_remote_ipaddr(), len, (u_long)sizeof(session_key));
2165                         rsafail++;
2166                 } else {
2167                         memset(session_key, 0, sizeof(session_key));
2168                         BN_bn2bin(session_key_int,
2169                             session_key + sizeof(session_key) - len);
2170
2171                         derive_ssh1_session_id(
2172                             sensitive_data.ssh1_host_key->rsa->n,
2173                             sensitive_data.server_key->rsa->n,
2174                             cookie, session_id);
2175                         /*
2176                          * Xor the first 16 bytes of the session key with the
2177                          * session id.
2178                          */
2179                         for (i = 0; i < 16; i++)
2180                                 session_key[i] ^= session_id[i];
2181                 }
2182         }
2183         if (rsafail) {
2184                 int bytes = BN_num_bytes(session_key_int);
2185                 u_char *buf = xmalloc(bytes);
2186                 MD5_CTX md;
2187
2188                 logit("do_connection: generating a fake encryption key");
2189                 BN_bn2bin(session_key_int, buf);
2190                 MD5_Init(&md);
2191                 MD5_Update(&md, buf, bytes);
2192                 MD5_Update(&md, sensitive_data.ssh1_cookie, SSH_SESSION_KEY_LENGTH);
2193                 MD5_Final(session_key, &md);
2194                 MD5_Init(&md);
2195                 MD5_Update(&md, session_key, 16);
2196                 MD5_Update(&md, buf, bytes);
2197                 MD5_Update(&md, sensitive_data.ssh1_cookie, SSH_SESSION_KEY_LENGTH);
2198                 MD5_Final(session_key + 16, &md);
2199                 memset(buf, 0, bytes);
2200                 xfree(buf);
2201                 for (i = 0; i < 16; i++)
2202                         session_id[i] = session_key[i] ^ session_key[i + 16];
2203         }
2204         /* Destroy the private and public keys. No longer. */
2205         destroy_sensitive_data();
2206
2207         if (use_privsep)
2208                 mm_ssh1_session_id(session_id);
2209
2210         /* Destroy the decrypted integer.  It is no longer needed. */
2211         BN_clear_free(session_key_int);
2212
2213         /* Set the session key.  From this on all communications will be encrypted. */
2214         packet_set_encryption_key(session_key, SSH_SESSION_KEY_LENGTH, cipher_type);
2215
2216         /* Destroy our copy of the session key.  It is no longer needed. */
2217         memset(session_key, 0, sizeof(session_key));
2218
2219         debug("Received session key; encryption turned on.");
2220
2221         /* Send an acknowledgment packet.  Note that this packet is sent encrypted. */
2222         packet_start(SSH_SMSG_SUCCESS);
2223         packet_send();
2224         packet_write_wait();
2225 }
2226
2227 /*
2228  * SSH2 key exchange: diffie-hellman-group1-sha1
2229  */
2230 static void
2231 do_ssh2_kex(void)
2232 {
2233         Kex *kex;
2234
2235         if (options.ciphers != NULL) {
2236                 myproposal[PROPOSAL_ENC_ALGS_CTOS] =
2237                 myproposal[PROPOSAL_ENC_ALGS_STOC] = options.ciphers;
2238         }
2239         myproposal[PROPOSAL_ENC_ALGS_CTOS] =
2240             compat_cipher_proposal(myproposal[PROPOSAL_ENC_ALGS_CTOS]);
2241         myproposal[PROPOSAL_ENC_ALGS_STOC] =
2242             compat_cipher_proposal(myproposal[PROPOSAL_ENC_ALGS_STOC]);
2243
2244         if (options.macs != NULL) {
2245                 myproposal[PROPOSAL_MAC_ALGS_CTOS] =
2246                 myproposal[PROPOSAL_MAC_ALGS_STOC] = options.macs;
2247         }
2248         if (options.compression == COMP_NONE) {
2249                 myproposal[PROPOSAL_COMP_ALGS_CTOS] =
2250                 myproposal[PROPOSAL_COMP_ALGS_STOC] = "none";
2251         } else if (options.compression == COMP_DELAYED) {
2252                 myproposal[PROPOSAL_COMP_ALGS_CTOS] =
2253                 myproposal[PROPOSAL_COMP_ALGS_STOC] = "none,zlib@openssh.com";
2254         }
2255
2256         myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = list_hostkey_types();
2257
2258 #ifdef GSSAPI
2259         {
2260         char *orig;
2261         char *gss = NULL;
2262         char *newstr = NULL;
2263         orig = myproposal[PROPOSAL_KEX_ALGS];
2264
2265         /*
2266          * If we don't have a host key, then there's no point advertising
2267          * the other key exchange algorithms
2268          */
2269
2270         if (strlen(myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS]) == 0)
2271                 orig = NULL;
2272
2273         if (options.gss_keyex)
2274                 gss = ssh_gssapi_server_mechanisms();
2275         else
2276                 gss = NULL;
2277
2278         if (gss && orig)
2279                 xasprintf(&newstr, "%s,%s", gss, orig);
2280         else if (gss)
2281                 newstr = gss;
2282         else if (orig)
2283                 newstr = orig;
2284
2285         /*
2286          * If we've got GSSAPI mechanisms, then we've got the 'null' host
2287          * key alg, but we can't tell people about it unless its the only
2288          * host key algorithm we support
2289          */
2290         if (gss && (strlen(myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS])) == 0)
2291                 myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = "null";
2292
2293         if (newstr)
2294                 myproposal[PROPOSAL_KEX_ALGS] = newstr;
2295         else
2296                 fatal("No supported key exchange algorithms");
2297         }
2298 #endif
2299
2300         /* start key exchange */
2301         kex = kex_setup(myproposal);
2302         kex->kex[KEX_DH_GRP1_SHA1] = kexdh_server;
2303         kex->kex[KEX_DH_GRP14_SHA1] = kexdh_server;
2304         kex->kex[KEX_DH_GEX_SHA1] = kexgex_server;
2305         kex->kex[KEX_DH_GEX_SHA256] = kexgex_server;
2306 #ifdef GSSAPI
2307         if (options.gss_keyex) {
2308                 kex->kex[KEX_GSS_GRP1_SHA1] = kexgss_server;
2309                 kex->kex[KEX_GSS_GRP14_SHA1] = kexgss_server;
2310                 kex->kex[KEX_GSS_GEX_SHA1] = kexgss_server;
2311         }
2312 #endif
2313         kex->server = 1;
2314         kex->client_version_string=client_version_string;
2315         kex->server_version_string=server_version_string;
2316         kex->load_host_key=&get_hostkey_by_type;
2317         kex->host_key_index=&get_hostkey_index;
2318
2319         xxx_kex = kex;
2320
2321         dispatch_run(DISPATCH_BLOCK, &kex->done, kex);
2322
2323         session_id2 = kex->session_id;
2324         session_id2_len = kex->session_id_len;
2325
2326 #ifdef DEBUG_KEXDH
2327         /* send 1st encrypted/maced/compressed message */
2328         packet_start(SSH2_MSG_IGNORE);
2329         packet_put_cstring("markus");
2330         packet_send();
2331         packet_write_wait();
2332 #endif
2333         debug("KEX done");
2334 }
2335
2336 /* server specific fatal cleanup */
2337 void
2338 cleanup_exit(int i)
2339 {
2340         if (the_authctxt)
2341                 do_cleanup(the_authctxt);
2342 #ifdef SSH_AUDIT_EVENTS
2343         /* done after do_cleanup so it can cancel the PAM auth 'thread' */
2344         if (!use_privsep || mm_is_monitor())
2345                 audit_event(SSH_CONNECTION_ABANDON);
2346 #endif
2347         _exit(i);
2348 }