sshd.c

   1 /*
   2  * Author: Tatu Ylonen <ylo@cs.hut.fi>
   3  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   4  *                    All rights reserved
   5  * This program is the ssh daemon.  It listens for connections from clients,
   6  * and performs authentication, executes use commands or shell, and forwards
   7  * information to/from the application to the user client over an encrypted
   8  * connection.  This can also handle forwarding of X11, TCP/IP, and
   9  * authentication agent connections.
  10  *
  11  * As far as I am concerned, the code I have written for this software
  12  * can be used freely for any purpose.  Any derived versions of this
  13  * software must be clearly marked as such, and if the derived work is
  14  * incompatible with the protocol description in the RFC file, it must be
  15  * called by a name other than "ssh" or "Secure Shell".
  16  *
  17  * SSH2 implementation:
  18  *
  19  * Copyright (c) 2000 Markus Friedl.  All rights reserved.
  20  *
  21  * Redistribution and use in source and binary forms, with or without
  22  * modification, are permitted provided that the following conditions
  23  * are met:
  24  * 1. Redistributions of source code must retain the above copyright
  25  *    notice, this list of conditions and the following disclaimer.
  26  * 2. Redistributions in binary form must reproduce the above copyright
  27  *    notice, this list of conditions and the following disclaimer in the
  28  *    documentation and/or other materials provided with the distribution.
  29  *
  30  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  31  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  32  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  33  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  34  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  35  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  36  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  37  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  38  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  39  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  40  */
  41
  42 #include "includes.h"
  43 RCSID("$OpenBSD: sshd.c,v 1.134 2000/11/12 19:50:38 markus Exp $");
  44
  45 #include "xmalloc.h"
  46 #include "rsa.h"
  47 #include "ssh.h"
  48 #include "pty.h"
  49 #include "packet.h"
  50 #include "mpaux.h"
  51 #include "servconf.h"
  52 #include "uidswap.h"
  53 #include "compat.h"
  54 #include "buffer.h"
  55
  56 #include "ssh2.h"
  57 #include <openssl/dh.h>
  58 #include <openssl/bn.h>
  59 #include <openssl/hmac.h>
  60 #include "kex.h"
  61 #include <openssl/dsa.h>
  62 #include <openssl/rsa.h>
  63 #include "key.h"
  64 #include "dh.h"
  65
  66 #include "auth.h"
  67 #include "myproposal.h"
  68 #include "authfile.h"
  69
  70 #ifdef LIBWRAP
  71 #include <tcpd.h>
  72 #include <syslog.h>
  73 int allow_severity = LOG_INFO;
  74 int deny_severity = LOG_WARNING;
  75 #endif /* LIBWRAP */
  76
  77 #ifndef O_NOCTTY
  78 #define O_NOCTTY        0
  79 #endif
  80
  81 /* Server configuration options. */
  82 ServerOptions options;
  83
  84 /* Name of the server configuration file. */
  85 char *config_file_name = SERVER_CONFIG_FILE;
  86
  87 /*
  88  * Flag indicating whether IPv4 or IPv6.  This can be set on the command line.
  89  * Default value is AF_UNSPEC means both IPv4 and IPv6.
  90  */
  91 #ifdef IPV4_DEFAULT
  92 int IPv4or6 = AF_INET;
  93 #else
  94 int IPv4or6 = AF_UNSPEC;
  95 #endif
  96
  97 /*
  98  * Debug mode flag.  This can be set on the command line.  If debug
  99  * mode is enabled, extra debugging output will be sent to the system
 100  * log, the daemon will not go to background, and will exit after processing
 101  * the first connection.
 102  */
 103 int debug_flag = 0;
 104
 105 /* Flag indicating that the daemon is being started from inetd. */
 106 int inetd_flag = 0;
 107
 108 /* debug goes to stderr unless inetd_flag is set */
 109 int log_stderr = 0;
 110
 111 /* argv[0] without path. */
 112 char *av0;
 113
 114 /* Saved arguments to main(). */
 115 char **saved_argv;
 116 int saved_argc;
 117
 118 /*
 119  * The sockets that the server is listening; this is used in the SIGHUP
 120  * signal handler.
 121  */
 122 #define MAX_LISTEN_SOCKS        16
 123 int listen_socks[MAX_LISTEN_SOCKS];
 124 int num_listen_socks = 0;
 125
 126 /*
 127  * the client's version string, passed by sshd2 in compat mode. if != NULL,
 128  * sshd will skip the version-number exchange
 129  */
 130 char *client_version_string = NULL;
 131 char *server_version_string = NULL;
 132
 133 /*
 134  * Any really sensitive data in the application is contained in this
 135  * structure. The idea is that this structure could be locked into memory so
 136  * that the pages do not get written into swap.  However, there are some
 137  * problems. The private key contains BIGNUMs, and we do not (in principle)
 138  * have access to the internals of them, and locking just the structure is
 139  * not very useful.  Currently, memory locking is not implemented.
 140  */
 141 struct {
 142         Key     *server_key;            /* empheral server key */
 143         Key     *ssh1_host_key;         /* ssh1 host key */
 144         Key     **host_keys;            /* all private host keys */
 145         int     have_ssh1_key;
 146         int     have_ssh2_key;
 147 } sensitive_data;
 148
 149 /*
 150  * Flag indicating whether the current session key has been used.  This flag
 151  * is set whenever the key is used, and cleared when the key is regenerated.
 152  */
 153 int key_used = 0;
 154
 155 /* This is set to true when SIGHUP is received. */
 156 int received_sighup = 0;
 157
 158 /* session identifier, used by RSA-auth */
 159 unsigned char session_id[16];
 160
 161 /* same for ssh2 */
 162 unsigned char *session_id2 = NULL;
 163 int session_id2_len = 0;
 164
 165 /* record remote hostname or ip */
 166 unsigned int utmp_len = MAXHOSTNAMELEN;
 167
 168 /* Prototypes for various functions defined later in this file. */
 169 void do_ssh1_kex();
 170 void do_ssh2_kex();
 171
 172 void ssh_dh1_server(Kex *, Buffer *_kexinit, Buffer *);
 173 void ssh_dhgex_server(Kex *, Buffer *_kexinit, Buffer *);
 174
 175 /*
 176  * Close all listening sockets
 177  */
 178 void
 179 close_listen_socks(void)
 180 {
 181         int i;
 182         for (i = 0; i < num_listen_socks; i++)
 183                 close(listen_socks[i]);
 184         num_listen_socks = -1;
 185 }
 186
 187 /*
 188  * Signal handler for SIGHUP.  Sshd execs itself when it receives SIGHUP;
 189  * the effect is to reread the configuration file (and to regenerate
 190  * the server key).
 191  */
 192 void
 193 sighup_handler(int sig)
 194 {
 195         received_sighup = 1;
 196         signal(SIGHUP, sighup_handler);
 197 }
 198
 199 /*
 200  * Called from the main program after receiving SIGHUP.
 201  * Restarts the server.
 202  */
 203 void
 204 sighup_restart()
 205 {
 206         log("Received SIGHUP; restarting.");
 207         close_listen_socks();
 208         execv(saved_argv[0], saved_argv);
 209         log("RESTART FAILED: av0='%s', error: %s.", av0, strerror(errno));
 210         exit(1);
 211 }
 212
 213 /*
 214  * Generic signal handler for terminating signals in the master daemon.
 215  * These close the listen socket; not closing it seems to cause "Address
 216  * already in use" problems on some machines, which is inconvenient.
 217  */
 218 void
 219 sigterm_handler(int sig)
 220 {
 221         log("Received signal %d; terminating.", sig);
 222         close_listen_socks();
 223         unlink(options.pid_file);
 224         exit(255);
 225 }
 226
 227 /*
 228  * SIGCHLD handler.  This is called whenever a child dies.  This will then
 229  * reap any zombies left by exited c.
 230  */
 231 void
 232 main_sigchld_handler(int sig)
 233 {
 234         int save_errno = errno;
 235         int status;
 236
 237         while (waitpid(-1, &status, WNOHANG) > 0)
 238                 ;
 239
 240         signal(SIGCHLD, main_sigchld_handler);
 241         errno = save_errno;
 242 }
 243
 244 /*
 245  * Signal handler for the alarm after the login grace period has expired.
 246  */
 247 void
 248 grace_alarm_handler(int sig)
 249 {
 250         /* Close the connection. */
 251         packet_close();
 252
 253         /* Log error and exit. */
 254         fatal("Timeout before authentication for %s.", get_remote_ipaddr());
 255 }
 256
 257 /*
 258  * Signal handler for the key regeneration alarm.  Note that this
 259  * alarm only occurs in the daemon waiting for connections, and it does not
 260  * do anything with the private key or random state before forking.
 261  * Thus there should be no concurrency control/asynchronous execution
 262  * problems.
 263  */
 264 /* XXX do we really want this work to be done in a signal handler ? -m */
 265 void
 266 generate_empheral_server_key(void)
 267 {
 268         log("Generating %s%d bit RSA key.", sensitive_data.server_key ? "new " : "",
 269             options.server_key_bits);
 270         if (sensitive_data.server_key != NULL)
 271                 key_free(sensitive_data.server_key);
 272         sensitive_data.server_key = key_generate(KEY_RSA1, options.server_key_bits);
 273         arc4random_stir();
 274         log("RSA key generation complete.");
 275 }
 276 void
 277 key_regeneration_alarm(int sig)
 278 {
 279         int save_errno = errno;
 280
 281         /* Check if we should generate a new key. */
 282         if (key_used) {
 283                 /* This should really be done in the background. */
 284                 generate_empheral_server_key();
 285                 key_used = 0;
 286         }
 287         /* Reschedule the alarm. */
 288         signal(SIGALRM, key_regeneration_alarm);
 289         alarm(options.key_regeneration_time);
 290         errno = save_errno;
 291 }
 292
 293 void
 294 sshd_exchange_identification(int sock_in, int sock_out)
 295 {
 296         int i, mismatch;
 297         int remote_major, remote_minor;
 298         int major, minor;
 299         char *s;
 300         char buf[256];                  /* Must not be larger than remote_version. */
 301         char remote_version[256];       /* Must be at least as big as buf. */
 302
 303         if ((options.protocol & SSH_PROTO_1) &&
 304             (options.protocol & SSH_PROTO_2)) {
 305                 major = PROTOCOL_MAJOR_1;
 306                 minor = 99;
 307         } else if (options.protocol & SSH_PROTO_2) {
 308                 major = PROTOCOL_MAJOR_2;
 309                 minor = PROTOCOL_MINOR_2;
 310         } else {
 311                 major = PROTOCOL_MAJOR_1;
 312                 minor = PROTOCOL_MINOR_1;
 313         }
 314         snprintf(buf, sizeof buf, "SSH-%d.%d-%.100s\n", major, minor, SSH_VERSION);
 315         server_version_string = xstrdup(buf);
 316
 317         if (client_version_string == NULL) {
 318                 /* Send our protocol version identification. */
 319                 if (atomicio(write, sock_out, server_version_string, strlen(server_version_string))
 320                     != strlen(server_version_string)) {
 321                         log("Could not write ident string to %s.", get_remote_ipaddr());
 322                         fatal_cleanup();
 323                 }
 324
 325                 /* Read other side\'s version identification. */
 326                 for (i = 0; i < sizeof(buf) - 1; i++) {
 327                         if (atomicio(read, sock_in, &buf[i], 1) != 1) {
 328                                 log("Did not receive ident string from %s.", get_remote_ipaddr());
 329                                 fatal_cleanup();
 330                         }
 331                         if (buf[i] == '\r') {
 332                                 buf[i] = '\n';
 333                                 buf[i + 1] = 0;
 334                                 /* Kludge for F-Secure Macintosh < 1.0.2 */
 335                                 if (i == 12 &&
 336                                     strncmp(buf, "SSH-1.5-W1.0", 12) == 0)
 337                                         break;
 338                                 continue;
 339                         }
 340                         if (buf[i] == '\n') {
 341                                 /* buf[i] == '\n' */
 342                                 buf[i + 1] = 0;
 343                                 break;
 344                         }
 345                 }
 346                 buf[sizeof(buf) - 1] = 0;
 347                 client_version_string = xstrdup(buf);
 348         }
 349
 350         /*
 351          * Check that the versions match.  In future this might accept
 352          * several versions and set appropriate flags to handle them.
 353          */
 354         if (sscanf(client_version_string, "SSH-%d.%d-%[^\n]\n",
 355             &remote_major, &remote_minor, remote_version) != 3) {
 356                 s = "Protocol mismatch.\n";
 357                 (void) atomicio(write, sock_out, s, strlen(s));
 358                 close(sock_in);
 359                 close(sock_out);
 360                 log("Bad protocol version identification '%.100s' from %s",
 361                     client_version_string, get_remote_ipaddr());
 362                 fatal_cleanup();
 363         }
 364         debug("Client protocol version %d.%d; client software version %.100s",
 365               remote_major, remote_minor, remote_version);
 366
 367         compat_datafellows(remote_version);
 368
 369         mismatch = 0;
 370         switch(remote_major) {
 371         case 1:
 372                 if (remote_minor == 99) {
 373                         if (options.protocol & SSH_PROTO_2)
 374                                 enable_compat20();
 375                         else
 376                                 mismatch = 1;
 377                         break;
 378                 }
 379                 if (!(options.protocol & SSH_PROTO_1)) {
 380                         mismatch = 1;
 381                         break;
 382                 }
 383                 if (remote_minor < 3) {
 384                         packet_disconnect("Your ssh version is too old and "
 385                             "is no longer supported.  Please install a newer version.");
 386                 } else if (remote_minor == 3) {
 387                         /* note that this disables agent-forwarding */
 388                         enable_compat13();
 389                 }
 390                 break;
 391         case 2:
 392                 if (options.protocol & SSH_PROTO_2) {
 393                         enable_compat20();
 394                         break;
 395                 }
 396                 /* FALLTHROUGH */
 397         default:
 398                 mismatch = 1;
 399                 break;
 400         }
 401         chop(server_version_string);
 402         chop(client_version_string);
 403         debug("Local version string %.200s", server_version_string);
 404
 405         if (mismatch) {
 406                 s = "Protocol major versions differ.\n";
 407                 (void) atomicio(write, sock_out, s, strlen(s));
 408                 close(sock_in);
 409                 close(sock_out);
 410                 log("Protocol major versions differ for %s: %.200s vs. %.200s",
 411                     get_remote_ipaddr(),
 412                     server_version_string, client_version_string);
 413                 fatal_cleanup();
 414         }
 415         if (compat20)
 416                 packet_set_ssh2_format();
 417 }
 418
 419
 420 /* Destroy the host and server keys.  They will no longer be needed. */
 421 void
 422 destroy_sensitive_data(void)
 423 {
 424         int i;
 425
 426         if (sensitive_data.server_key) {
 427                 key_free(sensitive_data.server_key);
 428                 sensitive_data.server_key = NULL;
 429         }
 430         for(i = 0; i < options.num_host_key_files; i++) {
 431                 if (sensitive_data.host_keys[i]) {
 432                         key_free(sensitive_data.host_keys[i]);
 433                         sensitive_data.host_keys[i] = NULL;
 434                 }
 435         }
 436         sensitive_data.ssh1_host_key = NULL;
 437 }
 438 Key *
 439 load_private_key_autodetect(const char *filename)
 440 {
 441         struct stat st;
 442         int type;
 443         Key *public, *private;
 444
 445         if (stat(filename, &st) < 0) {
 446                 perror(filename);
 447                 return NULL;
 448         }
 449         /*
 450          * try to load the public key. right now this only works for RSA1,
 451          * since SSH2 keys are fully encrypted
 452          */
 453         type = KEY_RSA1;
 454         public = key_new(type);
 455         if (!load_public_key(filename, public, NULL)) {
 456                 /* ok, so we will assume this is 'some' key */
 457                 type = KEY_UNSPEC;
 458         }
 459         key_free(public);
 460
 461         /* Ok, try key with empty passphrase */
 462         private = key_new(type);
 463         if (load_private_key(filename, "", private, NULL)) {
 464                 debug("load_private_key_autodetect: type %d %s",
 465                     private->type, key_type(private));
 466                 return private;
 467         }
 468         key_free(private);
 469         return NULL;
 470 }
 471
 472 char *
 473 list_hostkey_types(void)
 474 {
 475         static char buf[1024];
 476         int i;
 477         buf[0] = '\0';
 478         for(i = 0; i < options.num_host_key_files; i++) {
 479                 Key *key = sensitive_data.host_keys[i];
 480                 if (key == NULL)
 481                         continue;
 482                 switch(key->type) {
 483                 case KEY_RSA:
 484                 case KEY_DSA:
 485                         strlcat(buf, key_ssh_name(key), sizeof buf);
 486                         strlcat(buf, ",", sizeof buf);
 487                         break;
 488                 }
 489         }
 490         i = strlen(buf);
 491         if (i > 0 && buf[i-1] == ',')
 492                 buf[i-1] = '\0';
 493         debug("list_hostkey_types: %s", buf);
 494         return buf;
 495 }
 496
 497 Key *
 498 get_hostkey_by_type(int type)
 499 {
 500         int i;
 501         for(i = 0; i < options.num_host_key_files; i++) {
 502                 Key *key = sensitive_data.host_keys[i];
 503                 if (key != NULL && key->type == type)
 504                         return key;
 505         }
 506         return NULL;
 507 }
 508
 509 /*
 510  * returns 1 if connection should be dropped, 0 otherwise.
 511  * dropping starts at connection #max_startups_begin with a probability
 512  * of (max_startups_rate/100). the probability increases linearly until
 513  * all connections are dropped for startups > max_startups
 514  */
 515 int
 516 drop_connection(int startups)
 517 {
 518         double p, r;
 519
 520         if (startups < options.max_startups_begin)
 521                 return 0;
 522         if (startups >= options.max_startups)
 523                 return 1;
 524         if (options.max_startups_rate == 100)
 525                 return 1;
 526
 527         p  = 100 - options.max_startups_rate;
 528         p *= startups - options.max_startups_begin;
 529         p /= (double) (options.max_startups - options.max_startups_begin);
 530         p += options.max_startups_rate;
 531         p /= 100.0;
 532         r = arc4random() / (double) UINT_MAX;
 533
 534         debug("drop_connection: p %g, r %g", p, r);
 535         return (r < p) ? 1 : 0;
 536 }
 537
 538 int *startup_pipes = NULL;      /* options.max_startup sized array of fd ints */
 539 int startup_pipe;               /* in child */
 540
 541 /*
 542  * Main program for the daemon.
 543  */
 544 int
 545 main(int ac, char **av)
 546 {
 547         extern char *optarg;
 548         extern int optind;
 549         int opt, sock_in = 0, sock_out = 0, newsock, j, i, fdsetsz, on = 1;
 550         pid_t pid;
 551         socklen_t fromlen;
 552         int silent = 0;
 553         fd_set *fdset;
 554         struct sockaddr_storage from;
 555         const char *remote_ip;
 556         int remote_port;
 557         FILE *f;
 558         struct linger linger;
 559         struct addrinfo *ai;
 560         char ntop[NI_MAXHOST], strport[NI_MAXSERV];
 561         int listen_sock, maxfd;
 562         int startup_p[2];
 563         int startups = 0;
 564
 565         init_rng();
 566
 567         /* Save argv[0]. */
 568         saved_argc = ac;
 569         saved_argv = av;
 570         if (strchr(av[0], '/'))
 571                 av0 = strrchr(av[0], '/') + 1;
 572         else
 573                 av0 = av[0];
 574
 575         /* Initialize configuration options to their default values. */
 576         initialize_server_options(&options);
 577
 578         /* Parse command-line arguments. */
 579         while ((opt = getopt(ac, av, "f:p:b:k:h:g:V:u:diqQ46")) != EOF) {
 580                 switch (opt) {
 581                 case '4':
 582                         IPv4or6 = AF_INET;
 583                         break;
 584                 case '6':
 585                         IPv4or6 = AF_INET6;
 586                         break;
 587                 case 'f':
 588                         config_file_name = optarg;
 589                         break;
 590                 case 'd':
 591                         if (0 == debug_flag) {
 592                                 debug_flag = 1;
 593                                 options.log_level = SYSLOG_LEVEL_DEBUG1;
 594                         } else if (options.log_level < SYSLOG_LEVEL_DEBUG3) {
 595                                 options.log_level++;
 596                         } else {
 597                                 fprintf(stderr, "Too high debugging level.\n");
 598                                 exit(1);
 599                         }
 600                         break;
 601                 case 'i':
 602                         inetd_flag = 1;
 603                         break;
 604                 case 'Q':
 605                         silent = 1;
 606                         break;
 607                 case 'q':
 608                         options.log_level = SYSLOG_LEVEL_QUIET;
 609                         break;
 610                 case 'b':
 611                         options.server_key_bits = atoi(optarg);
 612                         break;
 613                 case 'p':
 614                         options.ports_from_cmdline = 1;
 615                         if (options.num_ports >= MAX_PORTS) {
 616                                 fprintf(stderr, "too many ports.\n");
 617                                 exit(1);
 618                         }
 619                         options.ports[options.num_ports++] = atoi(optarg);
 620                         break;
 621                 case 'g':
 622                         options.login_grace_time = atoi(optarg);
 623                         break;
 624                 case 'k':
 625                         options.key_regeneration_time = atoi(optarg);
 626                         break;
 627                 case 'h':
 628                         if (options.num_host_key_files >= MAX_HOSTKEYS) {
 629                                 fprintf(stderr, "too many host keys.\n");
 630                                 exit(1);
 631                         }
 632                         options.host_key_files[options.num_host_key_files++] = optarg;
 633                         break;
 634                 case 'V':
 635                         client_version_string = optarg;
 636                         /* only makes sense with inetd_flag, i.e. no listen() */
 637                         inetd_flag = 1;
 638                         break;
 639                 case 'u':
 640                         utmp_len = atoi(optarg);
 641                         break;
 642                 case '?':
 643                 default:
 644                         fprintf(stderr, "sshd version %s\n", SSH_VERSION);
 645                         fprintf(stderr, "Usage: %s [options]\n", av0);
 646                         fprintf(stderr, "Options:\n");
 647                         fprintf(stderr, "  -f file    Configuration file (default %s)\n", SERVER_CONFIG_FILE);
 648                         fprintf(stderr, "  -d         Debugging mode (multiple -d means more debugging)\n");
 649                         fprintf(stderr, "  -i         Started from inetd\n");
 650                         fprintf(stderr, "  -q         Quiet (no logging)\n");
 651                         fprintf(stderr, "  -p port    Listen on the specified port (default: 22)\n");
 652                         fprintf(stderr, "  -k seconds Regenerate server key every this many seconds (default: 3600)\n");
 653                         fprintf(stderr, "  -g seconds Grace period for authentication (default: 300)\n");
 654                         fprintf(stderr, "  -b bits    Size of server RSA key (default: 768 bits)\n");
 655                         fprintf(stderr, "  -h file    File from which to read host key (default: %s)\n",
 656                             HOST_KEY_FILE);
 657                         fprintf(stderr, "  -u len     Maximum hostname length for utmp recording\n");
 658                         fprintf(stderr, "  -4         Use IPv4 only\n");
 659                         fprintf(stderr, "  -6         Use IPv6 only\n");
 660                         exit(1);
 661                 }
 662         }
 663
 664         /*
 665          * Force logging to stderr until we have loaded the private host
 666          * key (unless started from inetd)
 667          */
 668         log_init(av0,
 669             options.log_level == -1 ? SYSLOG_LEVEL_INFO : options.log_level,
 670             options.log_facility == -1 ? SYSLOG_FACILITY_AUTH : options.log_facility,
 671             !silent && !inetd_flag);
 672
 673         /* Read server configuration options from the configuration file. */
 674         read_server_config(&options, config_file_name);
 675
 676         /* Fill in default values for those options not explicitly set. */
 677         fill_default_server_options(&options);
 678
 679         /* Check that there are no remaining arguments. */
 680         if (optind < ac) {
 681                 fprintf(stderr, "Extra argument %s.\n", av[optind]);
 682                 exit(1);
 683         }
 684
 685         debug("sshd version %.100s", SSH_VERSION);
 686
 687         /* load private host keys */
 688         sensitive_data.host_keys = xmalloc(options.num_host_key_files*sizeof(Key*));
 689         sensitive_data.server_key = NULL;
 690         sensitive_data.ssh1_host_key = NULL;
 691         sensitive_data.have_ssh1_key = 0;
 692         sensitive_data.have_ssh2_key = 0;
 693
 694         for(i = 0; i < options.num_host_key_files; i++) {
 695                 Key *key = load_private_key_autodetect(options.host_key_files[i]);
 696                 if (key == NULL) {
 697                         error("Could not load host key: %.200s: %.100s",
 698                             options.host_key_files[i], strerror(errno));
 699                         continue;
 700                 }
 701                 switch(key->type){
 702                 case KEY_RSA1:
 703                         sensitive_data.ssh1_host_key = key;
 704                         sensitive_data.have_ssh1_key = 1;
 705                         break;
 706                 case KEY_RSA:
 707                 case KEY_DSA:
 708                         sensitive_data.have_ssh2_key = 1;
 709                         break;
 710                 }
 711                 sensitive_data.host_keys[i] = key;
 712         }
 713         if ((options.protocol & SSH_PROTO_1) && !sensitive_data.have_ssh1_key) {
 714                 log("Disabling protocol version 1. Could not load host key");
 715                 options.protocol &= ~SSH_PROTO_1;
 716         }
 717         if ((options.protocol & SSH_PROTO_2) && !sensitive_data.have_ssh2_key) {
 718                 log("Disabling protocol version 2. Could not load host key");
 719                 options.protocol &= ~SSH_PROTO_2;
 720         }
 721         if (! options.protocol & (SSH_PROTO_1|SSH_PROTO_2)) {
 722                 if (silent == 0)
 723                         fprintf(stderr, "sshd: no hostkeys available -- exiting.\n");
 724                 log("sshd: no hostkeys available -- exiting.\n");
 725                 exit(1);
 726         }
 727
 728         /* Check certain values for sanity. */
 729         if (options.protocol & SSH_PROTO_1) {
 730                 if (options.server_key_bits < 512 ||
 731                     options.server_key_bits > 32768) {
 732                         fprintf(stderr, "Bad server key size.\n");
 733                         exit(1);
 734                 }
 735                 /*
 736                  * Check that server and host key lengths differ sufficiently. This
 737                  * is necessary to make double encryption work with rsaref. Oh, I
 738                  * hate software patents. I dont know if this can go? Niels
 739                  */
 740                 if (options.server_key_bits >
 741                     BN_num_bits(sensitive_data.ssh1_host_key->rsa->n) - SSH_KEY_BITS_RESERVED &&
 742                     options.server_key_bits <
 743                     BN_num_bits(sensitive_data.ssh1_host_key->rsa->n) + SSH_KEY_BITS_RESERVED) {
 744                         options.server_key_bits =
 745                             BN_num_bits(sensitive_data.ssh1_host_key->rsa->n) + SSH_KEY_BITS_RESERVED;
 746                         debug("Forcing server key to %d bits to make it differ from host key.",
 747                             options.server_key_bits);
 748                 }
 749         }
 750
 751 #ifdef HAVE_SCO_PROTECTED_PW
 752         (void) set_auth_parameters(ac, av);
 753 #endif
 754
 755         /* Initialize the log (it is reinitialized below in case we forked). */
 756         if (debug_flag && !inetd_flag)
 757                 log_stderr = 1;
 758         log_init(av0, options.log_level, options.log_facility, log_stderr);
 759
 760         /*
 761          * If not in debugging mode, and not started from inetd, disconnect
 762          * from the controlling terminal, and fork.  The original process
 763          * exits.
 764          */
 765         if (!debug_flag && !inetd_flag) {
 766 #ifdef TIOCNOTTY
 767                 int fd;
 768 #endif /* TIOCNOTTY */
 769                 if (daemon(0, 0) < 0)
 770                         fatal("daemon() failed: %.200s", strerror(errno));
 771
 772                 /* Disconnect from the controlling tty. */
 773 #ifdef TIOCNOTTY
 774                 fd = open("/dev/tty", O_RDWR | O_NOCTTY);
 775                 if (fd >= 0) {
 776                         (void) ioctl(fd, TIOCNOTTY, NULL);
 777                         close(fd);
 778                 }
 779 #endif /* TIOCNOTTY */
 780         }
 781         /* Reinitialize the log (because of the fork above). */
 782         log_init(av0, options.log_level, options.log_facility, log_stderr);
 783
 784         /* Initialize the random number generator. */
 785         arc4random_stir();
 786
 787         /* Chdir to the root directory so that the current disk can be
 788            unmounted if desired. */
 789         chdir("/");
 790
 791         /* Start listening for a socket, unless started from inetd. */
 792         if (inetd_flag) {
 793                 int s1, s2;
 794                 s1 = dup(0);    /* Make sure descriptors 0, 1, and 2 are in use. */
 795                 s2 = dup(s1);
 796                 sock_in = dup(0);
 797                 sock_out = dup(1);
 798                 startup_pipe = -1;
 799                 /*
 800                  * We intentionally do not close the descriptors 0, 1, and 2
 801                  * as our code for setting the descriptors won\'t work if
 802                  * ttyfd happens to be one of those.
 803                  */
 804                 debug("inetd sockets after dupping: %d, %d", sock_in, sock_out);
 805                 if (options.protocol & SSH_PROTO_1)
 806                         generate_empheral_server_key();
 807         } else {
 808                 for (ai = options.listen_addrs; ai; ai = ai->ai_next) {
 809                         if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6)
 810                                 continue;
 811                         if (num_listen_socks >= MAX_LISTEN_SOCKS)
 812                                 fatal("Too many listen sockets. "
 813                                     "Enlarge MAX_LISTEN_SOCKS");
 814                         if (getnameinfo(ai->ai_addr, ai->ai_addrlen,
 815                             ntop, sizeof(ntop), strport, sizeof(strport),
 816                             NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
 817                                 error("getnameinfo failed");
 818                                 continue;
 819                         }
 820                         /* Create socket for listening. */
 821                         listen_sock = socket(ai->ai_family, SOCK_STREAM, 0);
 822                         if (listen_sock < 0) {
 823                                 /* kernel may not support ipv6 */
 824                                 verbose("socket: %.100s", strerror(errno));
 825                                 continue;
 826                         }
 827                         if (fcntl(listen_sock, F_SETFL, O_NONBLOCK) < 0) {
 828                                 error("listen_sock O_NONBLOCK: %s", strerror(errno));
 829                                 close(listen_sock);
 830                                 continue;
 831                         }
 832                         /*
 833                          * Set socket options.  We try to make the port
 834                          * reusable and have it close as fast as possible
 835                          * without waiting in unnecessary wait states on
 836                          * close.
 837                          */
 838                         setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR,
 839                             (void *) &on, sizeof(on));
 840                         linger.l_onoff = 1;
 841                         linger.l_linger = 5;
 842                         setsockopt(listen_sock, SOL_SOCKET, SO_LINGER,
 843                             (void *) &linger, sizeof(linger));
 844
 845                         debug("Bind to port %s on %s.", strport, ntop);
 846
 847                         /* Bind the socket to the desired port. */
 848                         if ((bind(listen_sock, ai->ai_addr, ai->ai_addrlen) < 0) &&
 849                                  (!ai->ai_next)) {
 850                                 error("Bind to port %s on %s failed: %.200s.",
 851                                     strport, ntop, strerror(errno));
 852                                 close(listen_sock);
 853                                 continue;
 854                         }
 855                         listen_socks[num_listen_socks] = listen_sock;
 856                         num_listen_socks++;
 857
 858                         /* Start listening on the port. */
 859                         log("Server listening on %s port %s.", ntop, strport);
 860                         if (listen(listen_sock, 5) < 0)
 861                                 fatal("listen: %.100s", strerror(errno));
 862
 863                 }
 864                 freeaddrinfo(options.listen_addrs);
 865
 866                 if (!num_listen_socks)
 867                         fatal("Cannot bind any address.");
 868
 869                 if (!debug_flag) {
 870                         /*
 871                          * Record our pid in /etc/sshd_pid to make it easier
 872                          * to kill the correct sshd.  We don\'t want to do
 873                          * this before the bind above because the bind will
 874                          * fail if there already is a daemon, and this will
 875                          * overwrite any old pid in the file.
 876                          */
 877                         f = fopen(options.pid_file, "wb");
 878                         if (f) {
 879                                 fprintf(f, "%u\n", (unsigned int) getpid());
 880                                 fclose(f);
 881                         }
 882                 }
 883                 if (options.protocol & SSH_PROTO_1) {
 884                         generate_empheral_server_key();
 885
 886                         /* Schedule server key regeneration alarm. */
 887                         signal(SIGALRM, key_regeneration_alarm);
 888                         alarm(options.key_regeneration_time);
 889                 }
 890
 891                 /* Arrange to restart on SIGHUP.  The handler needs listen_sock. */
 892                 signal(SIGHUP, sighup_handler);
 893
 894                 signal(SIGTERM, sigterm_handler);
 895                 signal(SIGQUIT, sigterm_handler);
 896
 897                 /* Arrange SIGCHLD to be caught. */
 898                 signal(SIGCHLD, main_sigchld_handler);
 899
 900                 /* setup fd set for listen */
 901                 fdset = NULL;
 902                 maxfd = 0;
 903                 for (i = 0; i < num_listen_socks; i++)
 904                         if (listen_socks[i] > maxfd)
 905                                 maxfd = listen_socks[i];
 906                 /* pipes connected to unauthenticated childs */
 907                 startup_pipes = xmalloc(options.max_startups * sizeof(int));
 908                 for (i = 0; i < options.max_startups; i++)
 909                         startup_pipes[i] = -1;
 910
 911                 /*
 912                  * Stay listening for connections until the system crashes or
 913                  * the daemon is killed with a signal.
 914                  */
 915                 for (;;) {
 916                         if (received_sighup)
 917                                 sighup_restart();
 918                         if (fdset != NULL)
 919                                 xfree(fdset);
 920                         fdsetsz = howmany(maxfd, NFDBITS) * sizeof(fd_mask);
 921                         fdset = (fd_set *)xmalloc(fdsetsz);
 922                         memset(fdset, 0, fdsetsz);
 923
 924                         for (i = 0; i < num_listen_socks; i++)
 925                                 FD_SET(listen_socks[i], fdset);
 926                         for (i = 0; i < options.max_startups; i++)
 927                                 if (startup_pipes[i] != -1)
 928                                         FD_SET(startup_pipes[i], fdset);
 929
 930                         /* Wait in select until there is a connection. */
 931                         if (select(maxfd + 1, fdset, NULL, NULL, NULL) < 0) {
 932                                 if (errno != EINTR)
 933                                         error("select: %.100s", strerror(errno));
 934                                 continue;
 935                         }
 936                         for (i = 0; i < options.max_startups; i++)
 937                                 if (startup_pipes[i] != -1 &&
 938                                     FD_ISSET(startup_pipes[i], fdset)) {
 939                                         /*
 940                                          * the read end of the pipe is ready
 941                                          * if the child has closed the pipe
 942                                          * after successfull authentication
 943                                          * or if the child has died
 944                                          */
 945                                         close(startup_pipes[i]);
 946                                         startup_pipes[i] = -1;
 947                                         startups--;
 948                                 }
 949                         for (i = 0; i < num_listen_socks; i++) {
 950                                 if (!FD_ISSET(listen_socks[i], fdset))
 951                                         continue;
 952                                 fromlen = sizeof(from);
 953                                 newsock = accept(listen_socks[i], (struct sockaddr *)&from,
 954                                     &fromlen);
 955                                 if (newsock < 0) {
 956                                         if (errno != EINTR && errno != EWOULDBLOCK)
 957                                                 error("accept: %.100s", strerror(errno));
 958                                         continue;
 959                                 }
 960                                 if (fcntl(newsock, F_SETFL, 0) < 0) {
 961                                         error("newsock del O_NONBLOCK: %s", strerror(errno));
 962                                         continue;
 963                                 }
 964                                 if (drop_connection(startups) == 1) {
 965                                         debug("drop connection #%d", startups);
 966                                         close(newsock);
 967                                         continue;
 968                                 }
 969                                 if (pipe(startup_p) == -1) {
 970                                         close(newsock);
 971                                         continue;
 972                                 }
 973
 974                                 for (j = 0; j < options.max_startups; j++)
 975                                         if (startup_pipes[j] == -1) {
 976                                                 startup_pipes[j] = startup_p[0];
 977                                                 if (maxfd < startup_p[0])
 978                                                         maxfd = startup_p[0];
 979                                                 startups++;
 980                                                 break;
 981                                         }
 982
 983                                 /*
 984                                  * Got connection.  Fork a child to handle it, unless
 985                                  * we are in debugging mode.
 986                                  */
 987                                 if (debug_flag) {
 988                                         /*
 989                                          * In debugging mode.  Close the listening
 990                                          * socket, and start processing the
 991                                          * connection without forking.
 992                                          */
 993                                         debug("Server will not fork when running in debugging mode.");
 994                                         close_listen_socks();
 995                                         sock_in = newsock;
 996                                         sock_out = newsock;
 997                                         startup_pipe = -1;
 998                                         pid = getpid();
 999                                         break;
1000                                 } else {
1001                                         /*
1002                                          * Normal production daemon.  Fork, and have
1003                                          * the child process the connection. The
1004                                          * parent continues listening.
1005                                          */
1006                                         if ((pid = fork()) == 0) {
1007                                                 /*
1008                                                  * Child.  Close the listening and max_startup
1009                                                  * sockets.  Start using the accepted socket.
1010                                                  * Reinitialize logging (since our pid has
1011                                                  * changed).  We break out of the loop to handle
1012                                                  * the connection.
1013                                                  */
1014                                                 startup_pipe = startup_p[1];
1015                                                 for (j = 0; j < options.max_startups; j++)
1016                                                         if (startup_pipes[j] != -1)
1017                                                                 close(startup_pipes[j]);
1018                                                 close_listen_socks();
1019                                                 sock_in = newsock;
1020                                                 sock_out = newsock;
1021                                                 log_init(av0, options.log_level, options.log_facility, log_stderr);
1022                                                 break;
1023                                         }
1024                                 }
1025
1026                                 /* Parent.  Stay in the loop. */
1027                                 if (pid < 0)
1028                                         error("fork: %.100s", strerror(errno));
1029                                 else
1030                                         debug("Forked child %d.", pid);
1031
1032                                 close(startup_p[1]);
1033
1034                                 /* Mark that the key has been used (it was "given" to the child). */
1035                                 key_used = 1;
1036
1037                                 arc4random_stir();
1038
1039                                 /* Close the new socket (the child is now taking care of it). */
1040                                 close(newsock);
1041                         }
1042                         /* child process check (or debug mode) */
1043                         if (num_listen_socks < 0)
1044                                 break;
1045                 }
1046         }
1047
1048         /* This is the child processing a new connection. */
1049
1050         /*
1051          * Disable the key regeneration alarm.  We will not regenerate the
1052          * key since we are no longer in a position to give it to anyone. We
1053          * will not restart on SIGHUP since it no longer makes sense.
1054          */
1055         alarm(0);
1056         signal(SIGALRM, SIG_DFL);
1057         signal(SIGHUP, SIG_DFL);
1058         signal(SIGTERM, SIG_DFL);
1059         signal(SIGQUIT, SIG_DFL);
1060         signal(SIGCHLD, SIG_DFL);
1061         signal(SIGINT, SIG_DFL);
1062
1063         /*
1064          * Set socket options for the connection.  We want the socket to
1065          * close as fast as possible without waiting for anything.  If the
1066          * connection is not a socket, these will do nothing.
1067          */
1068         /* setsockopt(sock_in, SOL_SOCKET, SO_REUSEADDR, (void *)&on, sizeof(on)); */
1069         linger.l_onoff = 1;
1070         linger.l_linger = 5;
1071         setsockopt(sock_in, SOL_SOCKET, SO_LINGER, (void *) &linger, sizeof(linger));
1072
1073         /*
1074          * Register our connection.  This turns encryption off because we do
1075          * not have a key.
1076          */
1077         packet_set_connection(sock_in, sock_out);
1078
1079         remote_port = get_remote_port();
1080         remote_ip = get_remote_ipaddr();
1081
1082         /* Check whether logins are denied from this host. */
1083 #ifdef LIBWRAP
1084         /* XXX LIBWRAP noes not know about IPv6 */
1085         {
1086                 struct request_info req;
1087
1088                 request_init(&req, RQ_DAEMON, av0, RQ_FILE, sock_in, NULL);
1089                 fromhost(&req);
1090
1091                 if (!hosts_access(&req)) {
1092                         close(sock_in);
1093                         close(sock_out);
1094                         refuse(&req);
1095                 }
1096 /*XXX IPv6 verbose("Connection from %.500s port %d", eval_client(&req), remote_port); */
1097         }
1098 #endif /* LIBWRAP */
1099         /* Log the connection. */
1100         verbose("Connection from %.500s port %d", remote_ip, remote_port);
1101
1102         /*
1103          * We don\'t want to listen forever unless the other side
1104          * successfully authenticates itself.  So we set up an alarm which is
1105          * cleared after successful authentication.  A limit of zero
1106          * indicates no limit. Note that we don\'t set the alarm in debugging
1107          * mode; it is just annoying to have the server exit just when you
1108          * are about to discover the bug.
1109          */
1110         signal(SIGALRM, grace_alarm_handler);
1111         if (!debug_flag)
1112                 alarm(options.login_grace_time);
1113
1114         sshd_exchange_identification(sock_in, sock_out);
1115         /*
1116          * Check that the connection comes from a privileged port.  Rhosts-
1117          * and Rhosts-RSA-Authentication only make sense from priviledged
1118          * programs.  Of course, if the intruder has root access on his local
1119          * machine, he can connect from any port.  So do not use these
1120          * authentication methods from machines that you do not trust.
1121          */
1122         if (remote_port >= IPPORT_RESERVED ||
1123             remote_port < IPPORT_RESERVED / 2) {
1124                 debug("Rhosts Authentication methods disabled, "
1125                     "originating port not trusted.");
1126                 options.rhosts_authentication = 0;
1127                 options.rhosts_rsa_authentication = 0;
1128         }
1129 #ifdef KRB4
1130         if (!packet_connection_is_ipv4() &&
1131             options.kerberos_authentication) {
1132                 debug("Kerberos Authentication disabled, only available for IPv4.");
1133                 options.kerberos_authentication = 0;
1134         }
1135 #endif /* KRB4 */
1136
1137         packet_set_nonblocking();
1138
1139         /* perform the key exchange */
1140         /* authenticate user and start session */
1141         if (compat20) {
1142                 do_ssh2_kex();
1143                 do_authentication2();
1144         } else {
1145                 do_ssh1_kex();
1146                 do_authentication();
1147         }
1148
1149 #ifdef KRB4
1150         /* Cleanup user's ticket cache file. */
1151         if (options.kerberos_ticket_cleanup)
1152                 (void) dest_tkt();
1153 #endif /* KRB4 */
1154
1155         /* The connection has been terminated. */
1156         verbose("Closing connection to %.100s", remote_ip);
1157
1158 #ifdef USE_PAM
1159         finish_pam();
1160 #endif /* USE_PAM */
1161
1162         packet_close();
1163         exit(0);
1164 }
1165
1166 /*
1167  * SSH1 key exchange
1168  */
1169 void
1170 do_ssh1_kex()
1171 {
1172         int i, len;
1173         int plen, slen;
1174         BIGNUM *session_key_int;
1175         unsigned char session_key[SSH_SESSION_KEY_LENGTH];
1176         unsigned char cookie[8];
1177         unsigned int cipher_type, auth_mask, protocol_flags;
1178         u_int32_t rand = 0;
1179
1180         /*
1181          * Generate check bytes that the client must send back in the user
1182          * packet in order for it to be accepted; this is used to defy ip
1183          * spoofing attacks.  Note that this only works against somebody
1184          * doing IP spoofing from a remote machine; any machine on the local
1185          * network can still see outgoing packets and catch the random
1186          * cookie.  This only affects rhosts authentication, and this is one
1187          * of the reasons why it is inherently insecure.
1188          */
1189         for (i = 0; i < 8; i++) {
1190                 if (i % 4 == 0)
1191                         rand = arc4random();
1192                 cookie[i] = rand & 0xff;
1193                 rand >>= 8;
1194         }
1195
1196         /*
1197          * Send our public key.  We include in the packet 64 bits of random
1198          * data that must be matched in the reply in order to prevent IP
1199          * spoofing.
1200          */
1201         packet_start(SSH_SMSG_PUBLIC_KEY);
1202         for (i = 0; i < 8; i++)
1203                 packet_put_char(cookie[i]);
1204
1205         /* Store our public server RSA key. */
1206         packet_put_int(BN_num_bits(sensitive_data.server_key->rsa->n));
1207         packet_put_bignum(sensitive_data.server_key->rsa->e);
1208         packet_put_bignum(sensitive_data.server_key->rsa->n);
1209
1210         /* Store our public host RSA key. */
1211         packet_put_int(BN_num_bits(sensitive_data.ssh1_host_key->rsa->n));
1212         packet_put_bignum(sensitive_data.ssh1_host_key->rsa->e);
1213         packet_put_bignum(sensitive_data.ssh1_host_key->rsa->n);
1214
1215         /* Put protocol flags. */
1216         packet_put_int(SSH_PROTOFLAG_HOST_IN_FWD_OPEN);
1217
1218         /* Declare which ciphers we support. */
1219         packet_put_int(cipher_mask_ssh1(0));
1220
1221         /* Declare supported authentication types. */
1222         auth_mask = 0;
1223         if (options.rhosts_authentication)
1224                 auth_mask |= 1 << SSH_AUTH_RHOSTS;
1225         if (options.rhosts_rsa_authentication)
1226                 auth_mask |= 1 << SSH_AUTH_RHOSTS_RSA;
1227         if (options.rsa_authentication)
1228                 auth_mask |= 1 << SSH_AUTH_RSA;
1229 #ifdef KRB4
1230         if (options.kerberos_authentication)
1231                 auth_mask |= 1 << SSH_AUTH_KERBEROS;
1232 #endif
1233 #ifdef AFS
1234         if (options.kerberos_tgt_passing)
1235                 auth_mask |= 1 << SSH_PASS_KERBEROS_TGT;
1236         if (options.afs_token_passing)
1237                 auth_mask |= 1 << SSH_PASS_AFS_TOKEN;
1238 #endif
1239 #ifdef SKEY
1240         if (options.skey_authentication == 1)
1241                 auth_mask |= 1 << SSH_AUTH_TIS;
1242 #endif
1243         if (options.password_authentication)
1244                 auth_mask |= 1 << SSH_AUTH_PASSWORD;
1245         packet_put_int(auth_mask);
1246
1247         /* Send the packet and wait for it to be sent. */
1248         packet_send();
1249         packet_write_wait();
1250
1251         debug("Sent %d bit server key and %d bit host key.",
1252             BN_num_bits(sensitive_data.server_key->rsa->n),
1253             BN_num_bits(sensitive_data.ssh1_host_key->rsa->n));
1254
1255         /* Read clients reply (cipher type and session key). */
1256         packet_read_expect(&plen, SSH_CMSG_SESSION_KEY);
1257
1258         /* Get cipher type and check whether we accept this. */
1259         cipher_type = packet_get_char();
1260
1261         if (!(cipher_mask_ssh1(0) & (1 << cipher_type)))
1262                 packet_disconnect("Warning: client selects unsupported cipher.");
1263
1264         /* Get check bytes from the packet.  These must match those we
1265            sent earlier with the public key packet. */
1266         for (i = 0; i < 8; i++)
1267                 if (cookie[i] != packet_get_char())
1268                         packet_disconnect("IP Spoofing check bytes do not match.");
1269
1270         debug("Encryption type: %.200s", cipher_name(cipher_type));
1271
1272         /* Get the encrypted integer. */
1273         session_key_int = BN_new();
1274         packet_get_bignum(session_key_int, &slen);
1275
1276         protocol_flags = packet_get_int();
1277         packet_set_protocol_flags(protocol_flags);
1278
1279         packet_integrity_check(plen, 1 + 8 + slen + 4, SSH_CMSG_SESSION_KEY);
1280
1281         /*
1282          * Decrypt it using our private server key and private host key (key
1283          * with larger modulus first).
1284          */
1285         if (BN_cmp(sensitive_data.server_key->rsa->n, sensitive_data.ssh1_host_key->rsa->n) > 0) {
1286                 /* Private key has bigger modulus. */
1287                 if (BN_num_bits(sensitive_data.server_key->rsa->n) <
1288                     BN_num_bits(sensitive_data.ssh1_host_key->rsa->n) + SSH_KEY_BITS_RESERVED) {
1289                         fatal("do_connection: %s: server_key %d < host_key %d + SSH_KEY_BITS_RESERVED %d",
1290                             get_remote_ipaddr(),
1291                             BN_num_bits(sensitive_data.server_key->rsa->n),
1292                             BN_num_bits(sensitive_data.ssh1_host_key->rsa->n),
1293                             SSH_KEY_BITS_RESERVED);
1294                 }
1295                 rsa_private_decrypt(session_key_int, session_key_int,
1296                     sensitive_data.server_key->rsa);
1297                 rsa_private_decrypt(session_key_int, session_key_int,
1298                     sensitive_data.ssh1_host_key->rsa);
1299         } else {
1300                 /* Host key has bigger modulus (or they are equal). */
1301                 if (BN_num_bits(sensitive_data.ssh1_host_key->rsa->n) <
1302                     BN_num_bits(sensitive_data.server_key->rsa->n) + SSH_KEY_BITS_RESERVED) {
1303                         fatal("do_connection: %s: host_key %d < server_key %d + SSH_KEY_BITS_RESERVED %d",
1304                             get_remote_ipaddr(),
1305                             BN_num_bits(sensitive_data.ssh1_host_key->rsa->n),
1306                             BN_num_bits(sensitive_data.server_key->rsa->n),
1307                             SSH_KEY_BITS_RESERVED);
1308                 }
1309                 rsa_private_decrypt(session_key_int, session_key_int,
1310                     sensitive_data.ssh1_host_key->rsa);
1311                 rsa_private_decrypt(session_key_int, session_key_int,
1312                     sensitive_data.server_key->rsa);
1313         }
1314
1315         compute_session_id(session_id, cookie,
1316             sensitive_data.ssh1_host_key->rsa->n,
1317             sensitive_data.server_key->rsa->n);
1318
1319         /* Destroy the private and public keys.  They will no longer be needed. */
1320         destroy_sensitive_data();
1321
1322         /*
1323          * Extract session key from the decrypted integer.  The key is in the
1324          * least significant 256 bits of the integer; the first byte of the
1325          * key is in the highest bits.
1326          */
1327         BN_mask_bits(session_key_int, sizeof(session_key) * 8);
1328         len = BN_num_bytes(session_key_int);
1329         if (len < 0 || len > sizeof(session_key))
1330                 fatal("do_connection: bad len from %s: session_key_int %d > sizeof(session_key) %d",
1331                     get_remote_ipaddr(),
1332                     len, sizeof(session_key));
1333         memset(session_key, 0, sizeof(session_key));
1334         BN_bn2bin(session_key_int, session_key + sizeof(session_key) - len);
1335
1336         /* Destroy the decrypted integer.  It is no longer needed. */
1337         BN_clear_free(session_key_int);
1338
1339         /* Xor the first 16 bytes of the session key with the session id. */
1340         for (i = 0; i < 16; i++)
1341                 session_key[i] ^= session_id[i];
1342
1343         /* Set the session key.  From this on all communications will be encrypted. */
1344         packet_set_encryption_key(session_key, SSH_SESSION_KEY_LENGTH, cipher_type);
1345
1346         /* Destroy our copy of the session key.  It is no longer needed. */
1347         memset(session_key, 0, sizeof(session_key));
1348
1349         debug("Received session key; encryption turned on.");
1350
1351         /* Send an acknowledgement packet.  Note that this packet is sent encrypted. */
1352         packet_start(SSH_SMSG_SUCCESS);
1353         packet_send();
1354         packet_write_wait();
1355 }
1356
1357 /*
1358  * SSH2 key exchange: diffie-hellman-group1-sha1
1359  */
1360 void
1361 do_ssh2_kex()
1362 {
1363         Buffer *server_kexinit;
1364         Buffer *client_kexinit;
1365         int payload_len;
1366         int i;
1367         Kex *kex;
1368         char *cprop[PROPOSAL_MAX];
1369
1370 /* KEXINIT */
1371
1372         if (options.ciphers != NULL) {
1373                 myproposal[PROPOSAL_ENC_ALGS_CTOS] =
1374                 myproposal[PROPOSAL_ENC_ALGS_STOC] = options.ciphers;
1375         }
1376         myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] = list_hostkey_types();
1377
1378         server_kexinit = kex_init(myproposal);
1379         client_kexinit = xmalloc(sizeof(*client_kexinit));
1380         buffer_init(client_kexinit);
1381
1382         /* algorithm negotiation */
1383         kex_exchange_kexinit(server_kexinit, client_kexinit, cprop);
1384         kex = kex_choose_conf(cprop, myproposal, 1);
1385         for (i = 0; i < PROPOSAL_MAX; i++)
1386                 xfree(cprop[i]);
1387
1388         switch (kex->kex_type) {
1389         case DH_GRP1_SHA1:
1390                 ssh_dh1_server(kex, client_kexinit, server_kexinit);
1391                 break;
1392         case DH_GEX_SHA1:
1393                 ssh_dhgex_server(kex, client_kexinit, server_kexinit);
1394                 break;
1395         default:
1396                 fatal("Unsupported key exchange %d", kex->kex_type);
1397         }
1398
1399         debug("send SSH2_MSG_NEWKEYS.");
1400         packet_start(SSH2_MSG_NEWKEYS);
1401         packet_send();
1402         packet_write_wait();
1403         debug("done: send SSH2_MSG_NEWKEYS.");
1404
1405         debug("Wait SSH2_MSG_NEWKEYS.");
1406         packet_read_expect(&payload_len, SSH2_MSG_NEWKEYS);
1407         debug("GOT SSH2_MSG_NEWKEYS.");
1408
1409 #ifdef DEBUG_KEXDH
1410         /* send 1st encrypted/maced/compressed message */
1411         packet_start(SSH2_MSG_IGNORE);
1412         packet_put_cstring("markus");
1413         packet_send();
1414         packet_write_wait();
1415 #endif
1416
1417         debug("done: KEX2.");
1418 }
1419
1420 /*
1421  * SSH2 key exchange
1422  */
1423
1424 /* diffie-hellman-group1-sha1 */
1425
1426 void
1427 ssh_dh1_server(Kex *kex, Buffer *client_kexinit, Buffer *server_kexinit)
1428 {
1429 #ifdef DEBUG_KEXDH
1430         int i;
1431 #endif
1432         int payload_len, dlen;
1433         int slen;
1434         unsigned char *signature = NULL;
1435         unsigned char *server_host_key_blob = NULL;
1436         unsigned int sbloblen;
1437         unsigned int klen, kout;
1438         unsigned char *kbuf;
1439         unsigned char *hash;
1440         BIGNUM *shared_secret = 0;
1441         DH *dh;
1442         BIGNUM *dh_client_pub = 0;
1443         Key *hostkey;
1444
1445         hostkey = get_hostkey_by_type(kex->hostkey_type);
1446         if (hostkey == NULL)
1447                 fatal("Unsupported hostkey type %d", kex->hostkey_type);
1448
1449 /* KEXDH */
1450         debug("Wait SSH2_MSG_KEXDH_INIT.");
1451         packet_read_expect(&payload_len, SSH2_MSG_KEXDH_INIT);
1452
1453         /* key, cert */
1454         dh_client_pub = BN_new();
1455         if (dh_client_pub == NULL)
1456                 fatal("dh_client_pub == NULL");
1457         packet_get_bignum2(dh_client_pub, &dlen);
1458
1459 #ifdef DEBUG_KEXDH
1460         fprintf(stderr, "\ndh_client_pub= ");
1461         BN_print_fp(stderr, dh_client_pub);
1462         fprintf(stderr, "\n");
1463         debug("bits %d", BN_num_bits(dh_client_pub));
1464 #endif
1465
1466         /* generate DH key */
1467         dh = dh_new_group1();                   /* XXX depends on 'kex' */
1468
1469 #ifdef DEBUG_KEXDH
1470         fprintf(stderr, "\np= ");
1471         BN_print_fp(stderr, dh->p);
1472         fprintf(stderr, "\ng= ");
1473         bn_print(dh->g);
1474         fprintf(stderr, "\npub= ");
1475         BN_print_fp(stderr, dh->pub_key);
1476         fprintf(stderr, "\n");
1477         DHparams_print_fp(stderr, dh);
1478 #endif
1479         if (!dh_pub_is_valid(dh, dh_client_pub))
1480                 packet_disconnect("bad client public DH value");
1481
1482         klen = DH_size(dh);
1483         kbuf = xmalloc(klen);
1484         kout = DH_compute_key(kbuf, dh_client_pub, dh);
1485
1486 #ifdef DEBUG_KEXDH
1487         debug("shared secret: len %d/%d", klen, kout);
1488         fprintf(stderr, "shared secret == ");
1489         for (i = 0; i< kout; i++)
1490                 fprintf(stderr, "%02x", (kbuf[i])&0xff);
1491         fprintf(stderr, "\n");
1492 #endif
1493         shared_secret = BN_new();
1494
1495         BN_bin2bn(kbuf, kout, shared_secret);
1496         memset(kbuf, 0, klen);
1497         xfree(kbuf);
1498
1499         /* XXX precompute? */
1500         key_to_blob(hostkey, &server_host_key_blob, &sbloblen);
1501
1502         /* calc H */                    /* XXX depends on 'kex' */
1503         hash = kex_hash(
1504             client_version_string,
1505             server_version_string,
1506             buffer_ptr(client_kexinit), buffer_len(client_kexinit),
1507             buffer_ptr(server_kexinit), buffer_len(server_kexinit),
1508             (char *)server_host_key_blob, sbloblen,
1509             dh_client_pub,
1510             dh->pub_key,
1511             shared_secret
1512         );
1513         buffer_free(client_kexinit);
1514         buffer_free(server_kexinit);
1515         xfree(client_kexinit);
1516         xfree(server_kexinit);
1517 #ifdef DEBUG_KEXDH
1518         fprintf(stderr, "hash == ");
1519         for (i = 0; i< 20; i++)
1520                 fprintf(stderr, "%02x", (hash[i])&0xff);
1521         fprintf(stderr, "\n");
1522 #endif
1523         /* save session id := H */
1524         /* XXX hashlen depends on KEX */
1525         session_id2_len = 20;
1526         session_id2 = xmalloc(session_id2_len);
1527         memcpy(session_id2, hash, session_id2_len);
1528
1529         /* sign H */
1530         /* XXX hashlen depends on KEX */
1531         key_sign(hostkey, &signature, &slen, hash, 20);
1532
1533         destroy_sensitive_data();
1534
1535         /* send server hostkey, DH pubkey 'f' and singed H */
1536         packet_start(SSH2_MSG_KEXDH_REPLY);
1537         packet_put_string((char *)server_host_key_blob, sbloblen);
1538         packet_put_bignum2(dh->pub_key);        /* f */
1539         packet_put_string((char *)signature, slen);
1540         packet_send();
1541         xfree(signature);
1542         xfree(server_host_key_blob);
1543         packet_write_wait();
1544
1545         kex_derive_keys(kex, hash, shared_secret);
1546         packet_set_kex(kex);
1547
1548         /* have keys, free DH */
1549         DH_free(dh);
1550 }
1551
1552 /* diffie-hellman-group-exchange-sha1 */
1553
1554 void
1555 ssh_dhgex_server(Kex *kex, Buffer *client_kexinit, Buffer *server_kexinit)
1556 {
1557 #ifdef DEBUG_KEXDH
1558         int i;
1559 #endif
1560         int payload_len, dlen;
1561         int slen, nbits;
1562         unsigned char *signature = NULL;
1563         unsigned char *server_host_key_blob = NULL;
1564         unsigned int sbloblen;
1565         unsigned int klen, kout;
1566         unsigned char *kbuf;
1567         unsigned char *hash;
1568         BIGNUM *shared_secret = 0;
1569         DH *dh;
1570         BIGNUM *dh_client_pub = 0;
1571         Key *hostkey;
1572
1573         hostkey = get_hostkey_by_type(kex->hostkey_type);
1574         if (hostkey == NULL)
1575                 fatal("Unsupported hostkey type %d", kex->hostkey_type);
1576
1577 /* KEXDHGEX */
1578         debug("Wait SSH2_MSG_KEX_DH_GEX_REQUEST.");
1579         packet_read_expect(&payload_len, SSH2_MSG_KEX_DH_GEX_REQUEST);
1580         nbits = packet_get_int();
1581         dh = choose_dh(nbits);
1582
1583         debug("Sending SSH2_MSG_KEX_DH_GEX_GROUP.");
1584         packet_start(SSH2_MSG_KEX_DH_GEX_GROUP);
1585         packet_put_bignum2(dh->p);
1586         packet_put_bignum2(dh->g);
1587         packet_send();
1588         packet_write_wait();
1589
1590         debug("Wait SSH2_MSG_KEX_DH_GEX_INIT.");
1591         packet_read_expect(&payload_len, SSH2_MSG_KEX_DH_GEX_INIT);
1592
1593         /* key, cert */
1594         dh_client_pub = BN_new();
1595         if (dh_client_pub == NULL)
1596                 fatal("dh_client_pub == NULL");
1597         packet_get_bignum2(dh_client_pub, &dlen);
1598
1599 #ifdef DEBUG_KEXDH
1600         fprintf(stderr, "\ndh_client_pub= ");
1601         BN_print_fp(stderr, dh_client_pub);
1602         fprintf(stderr, "\n");
1603         debug("bits %d", BN_num_bits(dh_client_pub));
1604 #endif
1605
1606 #ifdef DEBUG_KEXDH
1607         fprintf(stderr, "\np= ");
1608         BN_print_fp(stderr, dh->p);
1609         fprintf(stderr, "\ng= ");
1610         bn_print(dh->g);
1611         fprintf(stderr, "\npub= ");
1612         BN_print_fp(stderr, dh->pub_key);
1613         fprintf(stderr, "\n");
1614         DHparams_print_fp(stderr, dh);
1615 #endif
1616         if (!dh_pub_is_valid(dh, dh_client_pub))
1617                 packet_disconnect("bad client public DH value");
1618
1619         klen = DH_size(dh);
1620         kbuf = xmalloc(klen);
1621         kout = DH_compute_key(kbuf, dh_client_pub, dh);
1622
1623 #ifdef DEBUG_KEXDH
1624         debug("shared secret: len %d/%d", klen, kout);
1625         fprintf(stderr, "shared secret == ");
1626         for (i = 0; i< kout; i++)
1627                 fprintf(stderr, "%02x", (kbuf[i])&0xff);
1628         fprintf(stderr, "\n");
1629 #endif
1630         shared_secret = BN_new();
1631
1632         BN_bin2bn(kbuf, kout, shared_secret);
1633         memset(kbuf, 0, klen);
1634         xfree(kbuf);
1635
1636         /* XXX precompute? */
1637         key_to_blob(hostkey, &server_host_key_blob, &sbloblen);
1638
1639         /* calc H */                    /* XXX depends on 'kex' */
1640         hash = kex_hash_gex(
1641             client_version_string,
1642             server_version_string,
1643             buffer_ptr(client_kexinit), buffer_len(client_kexinit),
1644             buffer_ptr(server_kexinit), buffer_len(server_kexinit),
1645             (char *)server_host_key_blob, sbloblen,
1646             nbits, dh->p, dh->g,
1647             dh_client_pub,
1648             dh->pub_key,
1649             shared_secret
1650         );
1651         buffer_free(client_kexinit);
1652         buffer_free(server_kexinit);
1653         xfree(client_kexinit);
1654         xfree(server_kexinit);
1655 #ifdef DEBUG_KEXDH
1656         fprintf(stderr, "hash == ");
1657         for (i = 0; i< 20; i++)
1658                 fprintf(stderr, "%02x", (hash[i])&0xff);
1659         fprintf(stderr, "\n");
1660 #endif
1661         /* save session id := H */
1662         /* XXX hashlen depends on KEX */
1663         session_id2_len = 20;
1664         session_id2 = xmalloc(session_id2_len);
1665         memcpy(session_id2, hash, session_id2_len);
1666
1667         /* sign H */
1668         /* XXX hashlen depends on KEX */
1669         key_sign(hostkey, &signature, &slen, hash, 20);
1670
1671         destroy_sensitive_data();
1672
1673         /* send server hostkey, DH pubkey 'f' and singed H */
1674         packet_start(SSH2_MSG_KEX_DH_GEX_REPLY);
1675         packet_put_string((char *)server_host_key_blob, sbloblen);
1676         packet_put_bignum2(dh->pub_key);        /* f */
1677         packet_put_string((char *)signature, slen);
1678         packet_send();
1679         xfree(signature);
1680         xfree(server_host_key_blob);
1681         packet_write_wait();
1682
1683         kex_derive_keys(kex, hash, shared_secret);
1684         packet_set_kex(kex);
1685
1686         /* have keys, free DH */
1687         DH_free(dh);
1688 }