source/smbd/share_access.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Check access based on valid users, read list and friends
   4    Copyright (C) Volker Lendecke 2005
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22
  23 /*
  24  * No prefix means direct username
  25  * @name means netgroup first, then unix group
  26  * &name means netgroup
  27  * +name means unix group
  28  * + and & may be combined
  29  */
  30
  31 extern userdom_struct current_user_info;
  32
  33 static BOOL do_group_checks(const char **name, const char **pattern)
  34 {
  35         if ((*name)[0] == '@') {
  36                 *pattern = "&+";
  37                 *name += 1;
  38                 return True;
  39         }
  40
  41         if (((*name)[0] == '+') && ((*name)[1] == '&')) {
  42                 *pattern = "+&";
  43                 *name += 2;
  44                 return True;
  45         }
  46
  47         if ((*name)[0] == '+') {
  48                 *pattern = "+";
  49                 *name += 1;
  50                 return True;
  51         }
  52
  53         if (((*name)[0] == '&') && ((*name)[1] == '+')) {
  54                 *pattern = "&+";
  55                 *name += 2;
  56                 return True;
  57         }
  58
  59         if ((*name)[0] == '&') {
  60                 *pattern = "&";
  61                 *name += 1;
  62                 return True;
  63         }
  64
  65         return False;
  66 }
  67
  68 static BOOL token_contains_name(TALLOC_CTX *mem_ctx,
  69                                 const char *username,
  70                                 const char *sharename,
  71                                 const struct nt_user_token *token,
  72                                 const char *name)
  73 {
  74         const char *prefix;
  75         DOM_SID sid;
  76         enum lsa_SidType type;
  77
  78         if (username != NULL) {
  79                 name = talloc_sub_basic(mem_ctx, username,
  80                                         current_user_info.domain, name);
  81         }
  82         if (sharename != NULL) {
  83                 name = talloc_string_sub(mem_ctx, name, "%S", sharename);
  84         }
  85
  86         if (name == NULL) {
  87                 /* This is too security sensitive, better panic than return a
  88                  * result that might be interpreted in a wrong way. */
  89                 smb_panic("substitutions failed\n");
  90         }
  91
  92         /* check to see is we already have a SID */
  93
  94         if ( string_to_sid( &sid, name ) ) {
  95                 DEBUG(5,("token_contains_name: Checking for SID [%s] in token\n", name));
  96                 return nt_token_check_sid( &sid, token );
  97         }
  98
  99         if (!do_group_checks(&name, &prefix)) {
 100                 if (!lookup_name_smbconf(mem_ctx, name, LOOKUP_NAME_ALL,
 101                                  NULL, NULL, &sid, &type)) {
 102                         DEBUG(5, ("lookup_name %s failed\n", name));
 103                         return False;
 104                 }
 105                 if (type != SID_NAME_USER) {
 106                         DEBUG(5, ("%s is a %s, expected a user\n",
 107                                   name, sid_type_lookup(type)));
 108                         return False;
 109                 }
 110                 return nt_token_check_sid(&sid, token);
 111         }
 112
 113         for (/* initialized above */ ; *prefix != '\0'; prefix++) {
 114                 if (*prefix == '+') {
 115                         if (!lookup_name_smbconf(mem_ctx, name,
 116                                          LOOKUP_NAME_ALL|LOOKUP_NAME_GROUP,
 117                                          NULL, NULL, &sid, &type)) {
 118                                 DEBUG(5, ("lookup_name %s failed\n", name));
 119                                 return False;
 120                         }
 121                         if ((type != SID_NAME_DOM_GRP) &&
 122                             (type != SID_NAME_ALIAS) &&
 123                             (type != SID_NAME_WKN_GRP)) {
 124                                 DEBUG(5, ("%s is a %s, expected a group\n",
 125                                           name, sid_type_lookup(type)));
 126                                 return False;
 127                         }
 128                         if (nt_token_check_sid(&sid, token)) {
 129                                 return True;
 130                         }
 131                         continue;
 132                 }
 133                 if (*prefix == '&') {
 134                         if (user_in_netgroup(username, name)) {
 135                                 return True;
 136                         }
 137                         continue;
 138                 }
 139                 smb_panic("got invalid prefix from do_groups_check\n");
 140         }
 141         return False;
 142 }
 143
 144 /*
 145  * Check whether a user is contained in the list provided.
 146  *
 147  * Please note that the user name and share names passed in here mainly for
 148  * the substitution routines that expand the parameter values, the decision
 149  * whether a user is in the list is done after a lookup_name on the expanded
 150  * parameter value, solely based on comparing the SIDs in token.
 151  *
 152  * The other use is the netgroup check when using @group or &group.
 153  */
 154
 155 BOOL token_contains_name_in_list(const char *username,
 156                                  const char *sharename,
 157                                  const struct nt_user_token *token,
 158                                  const char **list)
 159 {
 160         TALLOC_CTX *mem_ctx;
 161
 162         if (list == NULL) {
 163                 return False;
 164         }
 165
 166         if ( (mem_ctx = talloc_new(NULL)) == NULL ) {
 167                 smb_panic("talloc_new failed\n");
 168         }
 169
 170         while (*list != NULL) {
 171                 if (token_contains_name(mem_ctx, username, sharename,token, *list)) {
 172                         TALLOC_FREE(mem_ctx);
 173                         return True;
 174                 }
 175                 list += 1;
 176         }
 177
 178         TALLOC_FREE(mem_ctx);
 179         return False;
 180 }
 181
 182 /*
 183  * Check whether the user described by "token" has access to share snum.
 184  *
 185  * This looks at "invalid users", "valid users" and "only user/username"
 186  *
 187  * Please note that the user name and share names passed in here mainly for
 188  * the substitution routines that expand the parameter values, the decision
 189  * whether a user is in the list is done after a lookup_name on the expanded
 190  * parameter value, solely based on comparing the SIDs in token.
 191  *
 192  * The other use is the netgroup check when using @group or &group.
 193  */
 194
 195 BOOL user_ok_token(const char *username, struct nt_user_token *token, int snum)
 196 {
 197         if (lp_invalid_users(snum) != NULL) {
 198                 if (token_contains_name_in_list(username, lp_servicename(snum),
 199                                                 token,
 200                                                 lp_invalid_users(snum))) {
 201                         DEBUG(10, ("User %s in 'invalid users'\n", username));
 202                         return False;
 203                 }
 204         }
 205
 206         if (lp_valid_users(snum) != NULL) {
 207                 if (!token_contains_name_in_list(username,
 208                                                  lp_servicename(snum), token,
 209                                                  lp_valid_users(snum))) {
 210                         DEBUG(10, ("User %s not in 'valid users'\n",
 211                                    username));
 212                         return False;
 213                 }
 214         }
 215
 216         if (lp_onlyuser(snum)) {
 217                 const char *list[2];
 218                 list[0] = lp_username(snum);
 219                 list[1] = NULL;
 220                 if ((list[0] == NULL) || (*list[0] == '\0')) {
 221                         DEBUG(0, ("'only user = yes' and no 'username ='\n"));
 222                         return False;
 223                 }
 224                 if (!token_contains_name_in_list(NULL, lp_servicename(snum),
 225                                                  token, list)) {
 226                         DEBUG(10, ("%s != 'username'\n", username));
 227                         return False;
 228                 }
 229         }
 230
 231         DEBUG(10, ("user_ok_token: share %s is ok for unix user %s\n",
 232                    lp_servicename(snum), username));
 233
 234         return True;
 235 }
 236
 237 /*
 238  * Check whether the user described by "token" is restricted to read-only
 239  * access on share snum.
 240  *
 241  * This looks at "invalid users", "valid users" and "only user/username"
 242  *
 243  * Please note that the user name and share names passed in here mainly for
 244  * the substitution routines that expand the parameter values, the decision
 245  * whether a user is in the list is done after a lookup_name on the expanded
 246  * parameter value, solely based on comparing the SIDs in token.
 247  *
 248  * The other use is the netgroup check when using @group or &group.
 249  */
 250
 251 BOOL is_share_read_only_for_token(const char *username,
 252                                   struct nt_user_token *token, int snum)
 253 {
 254         BOOL result = lp_readonly(snum);
 255
 256         if (lp_readlist(snum) != NULL) {
 257                 if (token_contains_name_in_list(username,
 258                                                 lp_servicename(snum), token,
 259                                                 lp_readlist(snum))) {
 260                         result = True;
 261                 }
 262         }
 263
 264         if (lp_writelist(snum) != NULL) {
 265                 if (token_contains_name_in_list(username,
 266                                                 lp_servicename(snum), token,
 267                                                 lp_writelist(snum))) {
 268                         result = False;
 269                 }
 270         }
 271
 272         DEBUG(10,("is_share_read_only_for_user: share %s is %s for unix user "
 273                   "%s\n", lp_servicename(snum),
 274                   result ? "read-only" : "read-write", username));
 275
 276         return result;
 277 }