a449061741afc1c47e0fb274f307ca23668d7e5a
[dragonfly.git] / crypto / openssh / auth.c
1 /* $OpenBSD: auth.c,v 1.124 2017/09/12 06:32:07 djm Exp $ */
2 /*
3  * Copyright (c) 2000 Markus Friedl.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "includes.h"
27
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <sys/socket.h>
31
32 #include <netinet/in.h>
33
34 #include <errno.h>
35 #include <fcntl.h>
36 #ifdef HAVE_PATHS_H
37 # include <paths.h>
38 #endif
39 #include <pwd.h>
40 #ifdef HAVE_LOGIN_H
41 #include <login.h>
42 #endif
43 #ifdef USE_SHADOW
44 #include <shadow.h>
45 #endif
46 #include <stdarg.h>
47 #include <stdio.h>
48 #include <string.h>
49 #include <unistd.h>
50 #include <limits.h>
51 #include <netdb.h>
52
53 #include "xmalloc.h"
54 #include "match.h"
55 #include "groupaccess.h"
56 #include "log.h"
57 #include "buffer.h"
58 #include "misc.h"
59 #include "servconf.h"
60 #include "key.h"
61 #include "hostfile.h"
62 #include "auth.h"
63 #include "auth-options.h"
64 #include "canohost.h"
65 #include "uidswap.h"
66 #include "packet.h"
67 #include "loginrec.h"
68 #ifdef GSSAPI
69 #include "ssh-gss.h"
70 #endif
71 #include "authfile.h"
72 #include "monitor_wrap.h"
73 #include "authfile.h"
74 #include "ssherr.h"
75 #include "compat.h"
76
77 /* import */
78 extern ServerOptions options;
79 extern int use_privsep;
80 extern Buffer loginmsg;
81 extern struct passwd *privsep_pw;
82
83 /* Debugging messages */
84 Buffer auth_debug;
85 int auth_debug_init;
86
87 /*
88  * Check if the user is allowed to log in via ssh. If user is listed
89  * in DenyUsers or one of user's groups is listed in DenyGroups, false
90  * will be returned. If AllowUsers isn't empty and user isn't listed
91  * there, or if AllowGroups isn't empty and one of user's groups isn't
92  * listed there, false will be returned.
93  * If the user's shell is not executable, false will be returned.
94  * Otherwise true is returned.
95  */
96 int
97 allowed_user(struct passwd * pw)
98 {
99         struct ssh *ssh = active_state; /* XXX */
100         struct stat st;
101         const char *hostname = NULL, *ipaddr = NULL, *passwd = NULL;
102         u_int i;
103         int r;
104 #ifdef USE_SHADOW
105         struct spwd *spw = NULL;
106 #endif
107
108         /* Shouldn't be called if pw is NULL, but better safe than sorry... */
109         if (!pw || !pw->pw_name)
110                 return 0;
111
112 #ifdef USE_SHADOW
113         if (!options.use_pam)
114                 spw = getspnam(pw->pw_name);
115 #ifdef HAS_SHADOW_EXPIRE
116         if (!options.use_pam && spw != NULL && auth_shadow_acctexpired(spw))
117                 return 0;
118 #endif /* HAS_SHADOW_EXPIRE */
119 #endif /* USE_SHADOW */
120
121         /* grab passwd field for locked account check */
122         passwd = pw->pw_passwd;
123 #ifdef USE_SHADOW
124         if (spw != NULL)
125 #ifdef USE_LIBIAF
126                 passwd = get_iaf_password(pw);
127 #else
128                 passwd = spw->sp_pwdp;
129 #endif /* USE_LIBIAF */
130 #endif
131
132         /* check for locked account */
133         if (!options.use_pam && passwd && *passwd) {
134                 int locked = 0;
135
136 #ifdef LOCKED_PASSWD_STRING
137                 if (strcmp(passwd, LOCKED_PASSWD_STRING) == 0)
138                          locked = 1;
139 #endif
140 #ifdef LOCKED_PASSWD_PREFIX
141                 if (strncmp(passwd, LOCKED_PASSWD_PREFIX,
142                     strlen(LOCKED_PASSWD_PREFIX)) == 0)
143                          locked = 1;
144 #endif
145 #ifdef LOCKED_PASSWD_SUBSTR
146                 if (strstr(passwd, LOCKED_PASSWD_SUBSTR))
147                         locked = 1;
148 #endif
149 #ifdef USE_LIBIAF
150                 free((void *) passwd);
151 #endif /* USE_LIBIAF */
152                 if (locked) {
153                         logit("User %.100s not allowed because account is locked",
154                             pw->pw_name);
155                         return 0;
156                 }
157         }
158
159         /*
160          * Deny if shell does not exist or is not executable unless we
161          * are chrooting.
162          */
163         if (options.chroot_directory == NULL ||
164             strcasecmp(options.chroot_directory, "none") == 0) {
165                 char *shell = xstrdup((pw->pw_shell[0] == '\0') ?
166                     _PATH_BSHELL : pw->pw_shell); /* empty = /bin/sh */
167
168                 if (stat(shell, &st) != 0) {
169                         logit("User %.100s not allowed because shell %.100s "
170                             "does not exist", pw->pw_name, shell);
171                         free(shell);
172                         return 0;
173                 }
174                 if (S_ISREG(st.st_mode) == 0 ||
175                     (st.st_mode & (S_IXOTH|S_IXUSR|S_IXGRP)) == 0) {
176                         logit("User %.100s not allowed because shell %.100s "
177                             "is not executable", pw->pw_name, shell);
178                         free(shell);
179                         return 0;
180                 }
181                 free(shell);
182         }
183
184         if (options.num_deny_users > 0 || options.num_allow_users > 0 ||
185             options.num_deny_groups > 0 || options.num_allow_groups > 0) {
186                 hostname = auth_get_canonical_hostname(ssh, options.use_dns);
187                 ipaddr = ssh_remote_ipaddr(ssh);
188         }
189
190         /* Return false if user is listed in DenyUsers */
191         if (options.num_deny_users > 0) {
192                 for (i = 0; i < options.num_deny_users; i++) {
193                         r = match_user(pw->pw_name, hostname, ipaddr,
194                             options.deny_users[i]);
195                         if (r < 0) {
196                                 fatal("Invalid DenyUsers pattern \"%.100s\"",
197                                     options.deny_users[i]);
198                         } else if (r != 0) {
199                                 logit("User %.100s from %.100s not allowed "
200                                     "because listed in DenyUsers",
201                                     pw->pw_name, hostname);
202                                 return 0;
203                         }
204                 }
205         }
206         /* Return false if AllowUsers isn't empty and user isn't listed there */
207         if (options.num_allow_users > 0) {
208                 for (i = 0; i < options.num_allow_users; i++) {
209                         r = match_user(pw->pw_name, hostname, ipaddr,
210                             options.allow_users[i]);
211                         if (r < 0) {
212                                 fatal("Invalid AllowUsers pattern \"%.100s\"",
213                                     options.allow_users[i]);
214                         } else if (r == 1)
215                                 break;
216                 }
217                 /* i < options.num_allow_users iff we break for loop */
218                 if (i >= options.num_allow_users) {
219                         logit("User %.100s from %.100s not allowed because "
220                             "not listed in AllowUsers", pw->pw_name, hostname);
221                         return 0;
222                 }
223         }
224         if (options.num_deny_groups > 0 || options.num_allow_groups > 0) {
225                 /* Get the user's group access list (primary and supplementary) */
226                 if (ga_init(pw->pw_name, pw->pw_gid) == 0) {
227                         logit("User %.100s from %.100s not allowed because "
228                             "not in any group", pw->pw_name, hostname);
229                         return 0;
230                 }
231
232                 /* Return false if one of user's groups is listed in DenyGroups */
233                 if (options.num_deny_groups > 0)
234                         if (ga_match(options.deny_groups,
235                             options.num_deny_groups)) {
236                                 ga_free();
237                                 logit("User %.100s from %.100s not allowed "
238                                     "because a group is listed in DenyGroups",
239                                     pw->pw_name, hostname);
240                                 return 0;
241                         }
242                 /*
243                  * Return false if AllowGroups isn't empty and one of user's groups
244                  * isn't listed there
245                  */
246                 if (options.num_allow_groups > 0)
247                         if (!ga_match(options.allow_groups,
248                             options.num_allow_groups)) {
249                                 ga_free();
250                                 logit("User %.100s from %.100s not allowed "
251                                     "because none of user's groups are listed "
252                                     "in AllowGroups", pw->pw_name, hostname);
253                                 return 0;
254                         }
255                 ga_free();
256         }
257
258 #ifdef CUSTOM_SYS_AUTH_ALLOWED_USER
259         if (!sys_auth_allowed_user(pw, &loginmsg))
260                 return 0;
261 #endif
262
263         /* We found no reason not to let this user try to log on... */
264         return 1;
265 }
266
267 /*
268  * Formats any key left in authctxt->auth_method_key for inclusion in
269  * auth_log()'s message. Also includes authxtct->auth_method_info if present.
270  */
271 static char *
272 format_method_key(Authctxt *authctxt)
273 {
274         const struct sshkey *key = authctxt->auth_method_key;
275         const char *methinfo = authctxt->auth_method_info;
276         char *fp, *ret = NULL;
277
278         if (key == NULL)
279                 return NULL;
280
281         if (key_is_cert(key)) {
282                 fp = sshkey_fingerprint(key->cert->signature_key,
283                     options.fingerprint_hash, SSH_FP_DEFAULT);
284                 xasprintf(&ret, "%s ID %s (serial %llu) CA %s %s%s%s",
285                     sshkey_type(key), key->cert->key_id,
286                     (unsigned long long)key->cert->serial,
287                     sshkey_type(key->cert->signature_key),
288                     fp == NULL ? "(null)" : fp,
289                     methinfo == NULL ? "" : ", ",
290                     methinfo == NULL ? "" : methinfo);
291                 free(fp);
292         } else {
293                 fp = sshkey_fingerprint(key, options.fingerprint_hash,
294                     SSH_FP_DEFAULT);
295                 xasprintf(&ret, "%s %s%s%s", sshkey_type(key),
296                     fp == NULL ? "(null)" : fp,
297                     methinfo == NULL ? "" : ", ",
298                     methinfo == NULL ? "" : methinfo);
299                 free(fp);
300         }
301         return ret;
302 }
303
304 void
305 auth_log(Authctxt *authctxt, int authenticated, int partial,
306     const char *method, const char *submethod)
307 {
308         struct ssh *ssh = active_state; /* XXX */
309         void (*authlog) (const char *fmt,...) = verbose;
310         const char *authmsg;
311         char *extra = NULL;
312
313         if (use_privsep && !mm_is_monitor() && !authctxt->postponed)
314                 return;
315
316         /* Raise logging level */
317         if (authenticated == 1 ||
318             !authctxt->valid ||
319             authctxt->failures >= options.max_authtries / 2 ||
320             strcmp(method, "password") == 0)
321                 authlog = logit;
322
323         if (authctxt->postponed)
324                 authmsg = "Postponed";
325         else if (partial)
326                 authmsg = "Partial";
327         else
328                 authmsg = authenticated ? "Accepted" : "Failed";
329
330         if ((extra = format_method_key(authctxt)) == NULL) {
331                 if (authctxt->auth_method_info != NULL)
332                         extra = xstrdup(authctxt->auth_method_info);
333         }
334
335         authlog("%s %s%s%s for %s%.100s from %.200s port %d ssh2%s%s",
336             authmsg,
337             method,
338             submethod != NULL ? "/" : "", submethod == NULL ? "" : submethod,
339             authctxt->valid ? "" : "invalid user ",
340             authctxt->user,
341             ssh_remote_ipaddr(ssh),
342             ssh_remote_port(ssh),
343             extra != NULL ? ": " : "",
344             extra != NULL ? extra : "");
345
346         free(extra);
347
348 #ifdef CUSTOM_FAILED_LOGIN
349         if (authenticated == 0 && !authctxt->postponed &&
350             (strcmp(method, "password") == 0 ||
351             strncmp(method, "keyboard-interactive", 20) == 0 ||
352             strcmp(method, "challenge-response") == 0))
353                 record_failed_login(authctxt->user,
354                     auth_get_canonical_hostname(ssh, options.use_dns), "ssh");
355 # ifdef WITH_AIXAUTHENTICATE
356         if (authenticated)
357                 sys_auth_record_login(authctxt->user,
358                     auth_get_canonical_hostname(ssh, options.use_dns), "ssh",
359                     &loginmsg);
360 # endif
361 #endif
362 #ifdef SSH_AUDIT_EVENTS
363         if (authenticated == 0 && !authctxt->postponed)
364                 audit_event(audit_classify_auth(method));
365 #endif
366 }
367
368
369 void
370 auth_maxtries_exceeded(Authctxt *authctxt)
371 {
372         struct ssh *ssh = active_state; /* XXX */
373
374         error("maximum authentication attempts exceeded for "
375             "%s%.100s from %.200s port %d ssh2",
376             authctxt->valid ? "" : "invalid user ",
377             authctxt->user,
378             ssh_remote_ipaddr(ssh),
379             ssh_remote_port(ssh));
380         packet_disconnect("Too many authentication failures");
381         /* NOTREACHED */
382 }
383
384 /*
385  * Check whether root logins are disallowed.
386  */
387 int
388 auth_root_allowed(const char *method)
389 {
390         struct ssh *ssh = active_state; /* XXX */
391
392         switch (options.permit_root_login) {
393         case PERMIT_YES:
394                 return 1;
395         case PERMIT_NO_PASSWD:
396                 if (strcmp(method, "publickey") == 0 ||
397                     strcmp(method, "hostbased") == 0 ||
398                     strcmp(method, "gssapi-with-mic") == 0)
399                         return 1;
400                 break;
401         case PERMIT_FORCED_ONLY:
402                 if (forced_command) {
403                         logit("Root login accepted for forced command.");
404                         return 1;
405                 }
406                 break;
407         }
408         logit("ROOT LOGIN REFUSED FROM %.200s port %d",
409             ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));
410         return 0;
411 }
412
413
414 /*
415  * Given a template and a passwd structure, build a filename
416  * by substituting % tokenised options. Currently, %% becomes '%',
417  * %h becomes the home directory and %u the username.
418  *
419  * This returns a buffer allocated by xmalloc.
420  */
421 char *
422 expand_authorized_keys(const char *filename, struct passwd *pw)
423 {
424         char *file, ret[PATH_MAX];
425         int i;
426
427         file = percent_expand(filename, "h", pw->pw_dir,
428             "u", pw->pw_name, (char *)NULL);
429
430         /*
431          * Ensure that filename starts anchored. If not, be backward
432          * compatible and prepend the '%h/'
433          */
434         if (*file == '/')
435                 return (file);
436
437         i = snprintf(ret, sizeof(ret), "%s/%s", pw->pw_dir, file);
438         if (i < 0 || (size_t)i >= sizeof(ret))
439                 fatal("expand_authorized_keys: path too long");
440         free(file);
441         return (xstrdup(ret));
442 }
443
444 char *
445 authorized_principals_file(struct passwd *pw)
446 {
447         if (options.authorized_principals_file == NULL)
448                 return NULL;
449         return expand_authorized_keys(options.authorized_principals_file, pw);
450 }
451
452 /* return ok if key exists in sysfile or userfile */
453 HostStatus
454 check_key_in_hostfiles(struct passwd *pw, struct sshkey *key, const char *host,
455     const char *sysfile, const char *userfile)
456 {
457         char *user_hostfile;
458         struct stat st;
459         HostStatus host_status;
460         struct hostkeys *hostkeys;
461         const struct hostkey_entry *found;
462
463         hostkeys = init_hostkeys();
464         load_hostkeys(hostkeys, host, sysfile);
465         if (userfile != NULL) {
466                 user_hostfile = tilde_expand_filename(userfile, pw->pw_uid);
467                 if (options.strict_modes &&
468                     (stat(user_hostfile, &st) == 0) &&
469                     ((st.st_uid != 0 && st.st_uid != pw->pw_uid) ||
470                     (st.st_mode & 022) != 0)) {
471                         logit("Authentication refused for %.100s: "
472                             "bad owner or modes for %.200s",
473                             pw->pw_name, user_hostfile);
474                         auth_debug_add("Ignored %.200s: bad ownership or modes",
475                             user_hostfile);
476                 } else {
477                         temporarily_use_uid(pw);
478                         load_hostkeys(hostkeys, host, user_hostfile);
479                         restore_uid();
480                 }
481                 free(user_hostfile);
482         }
483         host_status = check_key_in_hostkeys(hostkeys, key, &found);
484         if (host_status == HOST_REVOKED)
485                 error("WARNING: revoked key for %s attempted authentication",
486                     found->host);
487         else if (host_status == HOST_OK)
488                 debug("%s: key for %s found at %s:%ld", __func__,
489                     found->host, found->file, found->line);
490         else
491                 debug("%s: key for host %s not found", __func__, host);
492
493         free_hostkeys(hostkeys);
494
495         return host_status;
496 }
497
498 static FILE *
499 auth_openfile(const char *file, struct passwd *pw, int strict_modes,
500     int log_missing, char *file_type)
501 {
502         char line[1024];
503         struct stat st;
504         int fd;
505         FILE *f;
506
507         if ((fd = open(file, O_RDONLY|O_NONBLOCK)) == -1) {
508                 if (log_missing || errno != ENOENT)
509                         debug("Could not open %s '%s': %s", file_type, file,
510                            strerror(errno));
511                 return NULL;
512         }
513
514         if (fstat(fd, &st) < 0) {
515                 close(fd);
516                 return NULL;
517         }
518         if (!S_ISREG(st.st_mode)) {
519                 logit("User %s %s %s is not a regular file",
520                     pw->pw_name, file_type, file);
521                 close(fd);
522                 return NULL;
523         }
524         unset_nonblock(fd);
525         if ((f = fdopen(fd, "r")) == NULL) {
526                 close(fd);
527                 return NULL;
528         }
529         if (strict_modes &&
530             safe_path_fd(fileno(f), file, pw, line, sizeof(line)) != 0) {
531                 fclose(f);
532                 logit("Authentication refused: %s", line);
533                 auth_debug_add("Ignored %s: %s", file_type, line);
534                 return NULL;
535         }
536
537         return f;
538 }
539
540
541 FILE *
542 auth_openkeyfile(const char *file, struct passwd *pw, int strict_modes)
543 {
544         return auth_openfile(file, pw, strict_modes, 1, "authorized keys");
545 }
546
547 FILE *
548 auth_openprincipals(const char *file, struct passwd *pw, int strict_modes)
549 {
550         return auth_openfile(file, pw, strict_modes, 0,
551             "authorized principals");
552 }
553
554 struct passwd *
555 getpwnamallow(const char *user)
556 {
557         struct ssh *ssh = active_state; /* XXX */
558 #ifdef HAVE_LOGIN_CAP
559         extern login_cap_t *lc;
560 #ifdef BSD_AUTH
561         auth_session_t *as;
562 #endif
563 #endif
564         struct passwd *pw;
565         struct connection_info *ci = get_connection_info(1, options.use_dns);
566
567         ci->user = user;
568         parse_server_match_config(&options, ci);
569         log_change_level(options.log_level);
570         process_permitopen(ssh, &options);
571
572 #if defined(_AIX) && defined(HAVE_SETAUTHDB)
573         aix_setauthdb(user);
574 #endif
575
576         pw = getpwnam(user);
577
578 #if defined(_AIX) && defined(HAVE_SETAUTHDB)
579         aix_restoreauthdb();
580 #endif
581 #ifdef HAVE_CYGWIN
582         /*
583          * Windows usernames are case-insensitive.  To avoid later problems
584          * when trying to match the username, the user is only allowed to
585          * login if the username is given in the same case as stored in the
586          * user database.
587          */
588         if (pw != NULL && strcmp(user, pw->pw_name) != 0) {
589                 logit("Login name %.100s does not match stored username %.100s",
590                     user, pw->pw_name);
591                 pw = NULL;
592         }
593 #endif
594         if (pw == NULL) {
595                 logit("Invalid user %.100s from %.100s port %d",
596                     user, ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));
597 #ifdef CUSTOM_FAILED_LOGIN
598                 record_failed_login(user,
599                     auth_get_canonical_hostname(ssh, options.use_dns), "ssh");
600 #endif
601 #ifdef SSH_AUDIT_EVENTS
602                 audit_event(SSH_INVALID_USER);
603 #endif /* SSH_AUDIT_EVENTS */
604                 return (NULL);
605         }
606         if (!allowed_user(pw))
607                 return (NULL);
608 #ifdef HAVE_LOGIN_CAP
609         if ((lc = login_getclass(pw->pw_class)) == NULL) {
610                 debug("unable to get login class: %s", user);
611                 return (NULL);
612         }
613 #ifdef BSD_AUTH
614         if ((as = auth_open()) == NULL || auth_setpwd(as, pw) != 0 ||
615             auth_approval(as, lc, pw->pw_name, "ssh") <= 0) {
616                 debug("Approval failure for %s", user);
617                 pw = NULL;
618         }
619         if (as != NULL)
620                 auth_close(as);
621 #endif
622 #endif
623         if (pw != NULL)
624                 return (pwcopy(pw));
625         return (NULL);
626 }
627
628 /* Returns 1 if key is revoked by revoked_keys_file, 0 otherwise */
629 int
630 auth_key_is_revoked(struct sshkey *key)
631 {
632         char *fp = NULL;
633         int r;
634
635         if (options.revoked_keys_file == NULL)
636                 return 0;
637         if ((fp = sshkey_fingerprint(key, options.fingerprint_hash,
638             SSH_FP_DEFAULT)) == NULL) {
639                 r = SSH_ERR_ALLOC_FAIL;
640                 error("%s: fingerprint key: %s", __func__, ssh_err(r));
641                 goto out;
642         }
643
644         r = sshkey_check_revoked(key, options.revoked_keys_file);
645         switch (r) {
646         case 0:
647                 break; /* not revoked */
648         case SSH_ERR_KEY_REVOKED:
649                 error("Authentication key %s %s revoked by file %s",
650                     sshkey_type(key), fp, options.revoked_keys_file);
651                 goto out;
652         default:
653                 error("Error checking authentication key %s %s in "
654                     "revoked keys file %s: %s", sshkey_type(key), fp,
655                     options.revoked_keys_file, ssh_err(r));
656                 goto out;
657         }
658
659         /* Success */
660         r = 0;
661
662  out:
663         free(fp);
664         return r == 0 ? 0 : 1;
665 }
666
667 void
668 auth_debug_add(const char *fmt,...)
669 {
670         char buf[1024];
671         va_list args;
672
673         if (!auth_debug_init)
674                 return;
675
676         va_start(args, fmt);
677         vsnprintf(buf, sizeof(buf), fmt, args);
678         va_end(args);
679         buffer_put_cstring(&auth_debug, buf);
680 }
681
682 void
683 auth_debug_send(void)
684 {
685         char *msg;
686
687         if (!auth_debug_init)
688                 return;
689         while (buffer_len(&auth_debug)) {
690                 msg = buffer_get_string(&auth_debug, NULL);
691                 packet_send_debug("%s", msg);
692                 free(msg);
693         }
694 }
695
696 void
697 auth_debug_reset(void)
698 {
699         if (auth_debug_init)
700                 buffer_clear(&auth_debug);
701         else {
702                 buffer_init(&auth_debug);
703                 auth_debug_init = 1;
704         }
705 }
706
707 struct passwd *
708 fakepw(void)
709 {
710         static struct passwd fake;
711
712         memset(&fake, 0, sizeof(fake));
713         fake.pw_name = "NOUSER";
714         fake.pw_passwd =
715             "$2a$06$r3.juUaHZDlIbQaO2dS9FuYxL1W9M81R1Tc92PoSNmzvpEqLkLGrK";
716 #ifdef HAVE_STRUCT_PASSWD_PW_GECOS
717         fake.pw_gecos = "NOUSER";
718 #endif
719         fake.pw_uid = privsep_pw == NULL ? (uid_t)-1 : privsep_pw->pw_uid;
720         fake.pw_gid = privsep_pw == NULL ? (gid_t)-1 : privsep_pw->pw_gid;
721 #ifdef HAVE_STRUCT_PASSWD_PW_CLASS
722         fake.pw_class = "";
723 #endif
724         fake.pw_dir = "/nonexist";
725         fake.pw_shell = "/nonexist";
726
727         return (&fake);
728 }
729
730 /*
731  * Returns the remote DNS hostname as a string. The returned string must not
732  * be freed. NB. this will usually trigger a DNS query the first time it is
733  * called.
734  * This function does additional checks on the hostname to mitigate some
735  * attacks on legacy rhosts-style authentication.
736  * XXX is RhostsRSAAuthentication vulnerable to these?
737  * XXX Can we remove these checks? (or if not, remove RhostsRSAAuthentication?)
738  */
739
740 static char *
741 remote_hostname(struct ssh *ssh)
742 {
743         struct sockaddr_storage from;
744         socklen_t fromlen;
745         struct addrinfo hints, *ai, *aitop;
746         char name[NI_MAXHOST], ntop2[NI_MAXHOST];
747         const char *ntop = ssh_remote_ipaddr(ssh);
748
749         /* Get IP address of client. */
750         fromlen = sizeof(from);
751         memset(&from, 0, sizeof(from));
752         if (getpeername(ssh_packet_get_connection_in(ssh),
753             (struct sockaddr *)&from, &fromlen) < 0) {
754                 debug("getpeername failed: %.100s", strerror(errno));
755                 return strdup(ntop);
756         }
757
758         ipv64_normalise_mapped(&from, &fromlen);
759         if (from.ss_family == AF_INET6)
760                 fromlen = sizeof(struct sockaddr_in6);
761
762         debug3("Trying to reverse map address %.100s.", ntop);
763         /* Map the IP address to a host name. */
764         if (getnameinfo((struct sockaddr *)&from, fromlen, name, sizeof(name),
765             NULL, 0, NI_NAMEREQD) != 0) {
766                 /* Host name not found.  Use ip address. */
767                 return strdup(ntop);
768         }
769
770         /*
771          * if reverse lookup result looks like a numeric hostname,
772          * someone is trying to trick us by PTR record like following:
773          *      1.1.1.10.in-addr.arpa.  IN PTR  2.3.4.5
774          */
775         memset(&hints, 0, sizeof(hints));
776         hints.ai_socktype = SOCK_DGRAM; /*dummy*/
777         hints.ai_flags = AI_NUMERICHOST;
778         if (getaddrinfo(name, NULL, &hints, &ai) == 0) {
779                 logit("Nasty PTR record \"%s\" is set up for %s, ignoring",
780                     name, ntop);
781                 freeaddrinfo(ai);
782                 return strdup(ntop);
783         }
784
785         /* Names are stored in lowercase. */
786         lowercase(name);
787
788         /*
789          * Map it back to an IP address and check that the given
790          * address actually is an address of this host.  This is
791          * necessary because anyone with access to a name server can
792          * define arbitrary names for an IP address. Mapping from
793          * name to IP address can be trusted better (but can still be
794          * fooled if the intruder has access to the name server of
795          * the domain).
796          */
797         memset(&hints, 0, sizeof(hints));
798         hints.ai_family = from.ss_family;
799         hints.ai_socktype = SOCK_STREAM;
800         if (getaddrinfo(name, NULL, &hints, &aitop) != 0) {
801                 logit("reverse mapping checking getaddrinfo for %.700s "
802                     "[%s] failed.", name, ntop);
803                 return strdup(ntop);
804         }
805         /* Look for the address from the list of addresses. */
806         for (ai = aitop; ai; ai = ai->ai_next) {
807                 if (getnameinfo(ai->ai_addr, ai->ai_addrlen, ntop2,
808                     sizeof(ntop2), NULL, 0, NI_NUMERICHOST) == 0 &&
809                     (strcmp(ntop, ntop2) == 0))
810                                 break;
811         }
812         freeaddrinfo(aitop);
813         /* If we reached the end of the list, the address was not there. */
814         if (ai == NULL) {
815                 /* Address not found for the host name. */
816                 logit("Address %.100s maps to %.600s, but this does not "
817                     "map back to the address.", ntop, name);
818                 return strdup(ntop);
819         }
820         return strdup(name);
821 }
822
823 /*
824  * Return the canonical name of the host in the other side of the current
825  * connection.  The host name is cached, so it is efficient to call this
826  * several times.
827  */
828
829 const char *
830 auth_get_canonical_hostname(struct ssh *ssh, int use_dns)
831 {
832         static char *dnsname;
833
834         if (!use_dns)
835                 return ssh_remote_ipaddr(ssh);
836         else if (dnsname != NULL)
837                 return dnsname;
838         else {
839                 dnsname = remote_hostname(ssh);
840                 return dnsname;
841         }
842 }