auth-rhosts.c

   1 /*
   2  * Author: Tatu Ylonen <ylo@cs.hut.fi>
   3  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   4  *                    All rights reserved
   5  * Rhosts authentication.  This file contains code to check whether to admit
   6  * the login based on rhosts authentication.  This file also processes
   7  * /etc/hosts.equiv.
   8  *
   9  * As far as I am concerned, the code I have written for this software
  10  * can be used freely for any purpose.  Any derived versions of this
  11  * software must be clearly marked as such, and if the derived work is
  12  * incompatible with the protocol description in the RFC file, it must be
  13  * called by a name other than "ssh" or "Secure Shell".
  14  */
  15
  16 #include "includes.h"
  17 RCSID("$OpenBSD: auth-rhosts.c,v 1.35 2006/02/20 17:19:53 stevesk Exp $");
  18
  19 #include <sys/types.h>
  20 #include <sys/stat.h>
  21
  22 #ifdef HAVE_NETGROUP_H
  23 # include <netgroup.h>
  24 #endif
  25
  26 #include "packet.h"
  27 #include "uidswap.h"
  28 #include "pathnames.h"
  29 #include "log.h"
  30 #include "servconf.h"
  31 #include "canohost.h"
  32 #include "auth.h"
  33
  34 /* import */
  35 extern ServerOptions options;
  36 extern int use_privsep;
  37
  38 /*
  39  * This function processes an rhosts-style file (.rhosts, .shosts, or
  40  * /etc/hosts.equiv).  This returns true if authentication can be granted
  41  * based on the file, and returns zero otherwise.
  42  */
  43
  44 static int
  45 check_rhosts_file(const char *filename, const char *hostname,
  46                   const char *ipaddr, const char *client_user,
  47                   const char *server_user)
  48 {
  49         FILE *f;
  50         char buf[1024]; /* Must not be larger than host, user, dummy below. */
  51
  52         /* Open the .rhosts file, deny if unreadable */
  53         f = fopen(filename, "r");
  54         if (!f)
  55                 return 0;
  56
  57         while (fgets(buf, sizeof(buf), f)) {
  58                 /* All three must be at least as big as buf to avoid overflows. */
  59                 char hostbuf[1024], userbuf[1024], dummy[1024], *host, *user, *cp;
  60                 int negated;
  61
  62                 for (cp = buf; *cp == ' ' || *cp == '\t'; cp++)
  63                         ;
  64                 if (*cp == '#' || *cp == '\n' || !*cp)
  65                         continue;
  66
  67                 /*
  68                  * NO_PLUS is supported at least on OSF/1.  We skip it (we
  69                  * don't ever support the plus syntax).
  70                  */
  71                 if (strncmp(cp, "NO_PLUS", 7) == 0)
  72                         continue;
  73
  74                 /*
  75                  * This should be safe because each buffer is as big as the
  76                  * whole string, and thus cannot be overwritten.
  77                  */
  78                 switch (sscanf(buf, "%1023s %1023s %1023s", hostbuf, userbuf,
  79                     dummy)) {
  80                 case 0:
  81                         auth_debug_add("Found empty line in %.100s.", filename);
  82                         continue;
  83                 case 1:
  84                         /* Host name only. */
  85                         strlcpy(userbuf, server_user, sizeof(userbuf));
  86                         break;
  87                 case 2:
  88                         /* Got both host and user name. */
  89                         break;
  90                 case 3:
  91                         auth_debug_add("Found garbage in %.100s.", filename);
  92                         continue;
  93                 default:
  94                         /* Weird... */
  95                         continue;
  96                 }
  97
  98                 host = hostbuf;
  99                 user = userbuf;
 100                 negated = 0;
 101
 102                 /* Process negated host names, or positive netgroups. */
 103                 if (host[0] == '-') {
 104                         negated = 1;
 105                         host++;
 106                 } else if (host[0] == '+')
 107                         host++;
 108
 109                 if (user[0] == '-') {
 110                         negated = 1;
 111                         user++;
 112                 } else if (user[0] == '+')
 113                         user++;
 114
 115                 /* Check for empty host/user names (particularly '+'). */
 116                 if (!host[0] || !user[0]) {
 117                         /* We come here if either was '+' or '-'. */
 118                         auth_debug_add("Ignoring wild host/user names in %.100s.",
 119                             filename);
 120                         continue;
 121                 }
 122                 /* Verify that host name matches. */
 123                 if (host[0] == '@') {
 124                         if (!innetgr(host + 1, hostname, NULL, NULL) &&
 125                             !innetgr(host + 1, ipaddr, NULL, NULL))
 126                                 continue;
 127                 } else if (strcasecmp(host, hostname) && strcmp(host, ipaddr) != 0)
 128                         continue;       /* Different hostname. */
 129
 130                 /* Verify that user name matches. */
 131                 if (user[0] == '@') {
 132                         if (!innetgr(user + 1, NULL, client_user, NULL))
 133                                 continue;
 134                 } else if (strcmp(user, client_user) != 0)
 135                         continue;       /* Different username. */
 136
 137                 /* Found the user and host. */
 138                 fclose(f);
 139
 140                 /* If the entry was negated, deny access. */
 141                 if (negated) {
 142                         auth_debug_add("Matched negative entry in %.100s.",
 143                             filename);
 144                         return 0;
 145                 }
 146                 /* Accept authentication. */
 147                 return 1;
 148         }
 149
 150         /* Authentication using this file denied. */
 151         fclose(f);
 152         return 0;
 153 }
 154
 155 /*
 156  * Tries to authenticate the user using the .shosts or .rhosts file. Returns
 157  * true if authentication succeeds.  If ignore_rhosts is true, only
 158  * /etc/hosts.equiv will be considered (.rhosts and .shosts are ignored).
 159  */
 160
 161 int
 162 auth_rhosts(struct passwd *pw, const char *client_user)
 163 {
 164         const char *hostname, *ipaddr;
 165
 166         hostname = get_canonical_hostname(options.use_dns);
 167         ipaddr = get_remote_ipaddr();
 168         return auth_rhosts2(pw, client_user, hostname, ipaddr);
 169 }
 170
 171 static int
 172 auth_rhosts2_raw(struct passwd *pw, const char *client_user, const char *hostname,
 173     const char *ipaddr)
 174 {
 175         char buf[1024];
 176         struct stat st;
 177         static const char *rhosts_files[] = {".shosts", ".rhosts", NULL};
 178         u_int rhosts_file_index;
 179
 180         debug2("auth_rhosts2: clientuser %s hostname %s ipaddr %s",
 181             client_user, hostname, ipaddr);
 182
 183         /* Switch to the user's uid. */
 184         temporarily_use_uid(pw);
 185         /*
 186          * Quick check: if the user has no .shosts or .rhosts files, return
 187          * failure immediately without doing costly lookups from name
 188          * servers.
 189          */
 190         for (rhosts_file_index = 0; rhosts_files[rhosts_file_index];
 191             rhosts_file_index++) {
 192                 /* Check users .rhosts or .shosts. */
 193                 snprintf(buf, sizeof buf, "%.500s/%.100s",
 194                          pw->pw_dir, rhosts_files[rhosts_file_index]);
 195                 if (stat(buf, &st) >= 0)
 196                         break;
 197         }
 198         /* Switch back to privileged uid. */
 199         restore_uid();
 200
 201         /* Deny if The user has no .shosts or .rhosts file and there are no system-wide files. */
 202         if (!rhosts_files[rhosts_file_index] &&
 203             stat(_PATH_RHOSTS_EQUIV, &st) < 0 &&
 204             stat(_PATH_SSH_HOSTS_EQUIV, &st) < 0)
 205                 return 0;
 206
 207         /* If not logging in as superuser, try /etc/hosts.equiv and shosts.equiv. */
 208         if (pw->pw_uid != 0) {
 209                 if (check_rhosts_file(_PATH_RHOSTS_EQUIV, hostname, ipaddr,
 210                     client_user, pw->pw_name)) {
 211                         auth_debug_add("Accepted for %.100s [%.100s] by /etc/hosts.equiv.",
 212                             hostname, ipaddr);
 213                         return 1;
 214                 }
 215                 if (check_rhosts_file(_PATH_SSH_HOSTS_EQUIV, hostname, ipaddr,
 216                     client_user, pw->pw_name)) {
 217                         auth_debug_add("Accepted for %.100s [%.100s] by %.100s.",
 218                             hostname, ipaddr, _PATH_SSH_HOSTS_EQUIV);
 219                         return 1;
 220                 }
 221         }
 222         /*
 223          * Check that the home directory is owned by root or the user, and is
 224          * not group or world writable.
 225          */
 226         if (stat(pw->pw_dir, &st) < 0) {
 227                 logit("Rhosts authentication refused for %.100s: "
 228                     "no home directory %.200s", pw->pw_name, pw->pw_dir);
 229                 auth_debug_add("Rhosts authentication refused for %.100s: "
 230                     "no home directory %.200s", pw->pw_name, pw->pw_dir);
 231                 return 0;
 232         }
 233         if (options.strict_modes &&
 234             ((st.st_uid != 0 && st.st_uid != pw->pw_uid) ||
 235             (st.st_mode & 022) != 0)) {
 236                 logit("Rhosts authentication refused for %.100s: "
 237                     "bad ownership or modes for home directory.", pw->pw_name);
 238                 auth_debug_add("Rhosts authentication refused for %.100s: "
 239                     "bad ownership or modes for home directory.", pw->pw_name);
 240                 return 0;
 241         }
 242         /* Temporarily use the user's uid. */
 243         temporarily_use_uid(pw);
 244
 245         /* Check all .rhosts files (currently .shosts and .rhosts). */
 246         for (rhosts_file_index = 0; rhosts_files[rhosts_file_index];
 247             rhosts_file_index++) {
 248                 /* Check users .rhosts or .shosts. */
 249                 snprintf(buf, sizeof buf, "%.500s/%.100s",
 250                          pw->pw_dir, rhosts_files[rhosts_file_index]);
 251                 if (stat(buf, &st) < 0)
 252                         continue;
 253
 254                 /*
 255                  * Make sure that the file is either owned by the user or by
 256                  * root, and make sure it is not writable by anyone but the
 257                  * owner.  This is to help avoid novices accidentally
 258                  * allowing access to their account by anyone.
 259                  */
 260                 if (options.strict_modes &&
 261                     ((st.st_uid != 0 && st.st_uid != pw->pw_uid) ||
 262                     (st.st_mode & 022) != 0)) {
 263                         logit("Rhosts authentication refused for %.100s: bad modes for %.200s",
 264                             pw->pw_name, buf);
 265                         auth_debug_add("Bad file modes for %.200s", buf);
 266                         continue;
 267                 }
 268                 /* Check if we have been configured to ignore .rhosts and .shosts files. */
 269                 if (options.ignore_rhosts) {
 270                         auth_debug_add("Server has been configured to ignore %.100s.",
 271                             rhosts_files[rhosts_file_index]);
 272                         continue;
 273                 }
 274                 /* Check if authentication is permitted by the file. */
 275                 if (check_rhosts_file(buf, hostname, ipaddr, client_user, pw->pw_name)) {
 276                         auth_debug_add("Accepted by %.100s.",
 277                             rhosts_files[rhosts_file_index]);
 278                         /* Restore the privileged uid. */
 279                         restore_uid();
 280                         auth_debug_add("Accepted host %s ip %s client_user %s server_user %s",
 281                                 hostname, ipaddr, client_user, pw->pw_name);
 282                         return 1;
 283                 }
 284         }
 285
 286         /* Restore the privileged uid. */
 287         restore_uid();
 288         return 0;
 289 }
 290
 291 int
 292 auth_rhosts2(struct passwd *pw, const char *client_user, const char *hostname,
 293     const char *ipaddr)
 294 {
 295         int ret;
 296
 297         auth_debug_reset();
 298         ret = auth_rhosts2_raw(pw, client_user, hostname, ipaddr);
 299         if (!use_privsep)
 300                 auth_debug_send();
 301         return ret;
 302 }