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