source3/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 3 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, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "includes.h"
  21 #include "smbd/smbd.h"
  22 #include "smbd/globals.h"
  23 #include "../libcli/security/security.h"
  24 #include "passdb/lookup_sid.h"
  25 #include "auth.h"
  26
  27 /*
  28  * No prefix means direct username
  29  * @name means netgroup first, then unix group
  30  * &name means netgroup
  31  * +name means unix group
  32  * + and & may be combined
  33  */
  34
  35 static bool do_group_checks(const char **name, const char **pattern)
  36 {
  37         if ((*name)[0] == '@') {
  38                 *pattern = "&+";
  39                 *name += 1;
  40                 return True;
  41         }
  42
  43         if (((*name)[0] == '+') && ((*name)[1] == '&')) {
  44                 *pattern = "+&";
  45                 *name += 2;
  46                 return True;
  47         }
  48
  49         if ((*name)[0] == '+') {
  50                 *pattern = "+";
  51                 *name += 1;
  52                 return True;
  53         }
  54
  55         if (((*name)[0] == '&') && ((*name)[1] == '+')) {
  56                 *pattern = "&+";
  57                 *name += 2;
  58                 return True;
  59         }
  60
  61         if ((*name)[0] == '&') {
  62                 *pattern = "&";
  63                 *name += 1;
  64                 return True;
  65         }
  66
  67         return False;
  68 }
  69
  70 static bool token_contains_name(TALLOC_CTX *mem_ctx,
  71                                 const char *username,
  72                                 const char *domain,
  73                                 const char *sharename,
  74                                 const struct security_token *token,
  75                                 const char *name)
  76 {
  77         const char *prefix;
  78         struct dom_sid sid;
  79         enum lsa_SidType type;
  80
  81         if (username != NULL) {
  82                 name = talloc_sub_basic(mem_ctx, username, domain, name);
  83         }
  84         if (sharename != NULL) {
  85                 name = talloc_string_sub(mem_ctx, name, "%S", sharename);
  86         }
  87
  88         if (name == NULL) {
  89                 /* This is too security sensitive, better panic than return a
  90                  * result that might be interpreted in a wrong way. */
  91                 smb_panic("substitutions failed");
  92         }
  93
  94         /* check to see is we already have a SID */
  95
  96         if ( string_to_sid( &sid, name ) ) {
  97                 DEBUG(5,("token_contains_name: Checking for SID [%s] in token\n", name));
  98                 return nt_token_check_sid( &sid, token );
  99         }
 100
 101         if (!do_group_checks(&name, &prefix)) {
 102                 if (!lookup_name_smbconf(mem_ctx, name, LOOKUP_NAME_ALL,
 103                                  NULL, NULL, &sid, &type)) {
 104                         DEBUG(5, ("lookup_name %s failed\n", name));
 105                         return False;
 106                 }
 107                 if (type != SID_NAME_USER) {
 108                         DEBUG(5, ("%s is a %s, expected a user\n",
 109                                   name, sid_type_lookup(type)));
 110                         return False;
 111                 }
 112                 return nt_token_check_sid(&sid, token);
 113         }
 114
 115         for (/* initialized above */ ; *prefix != '\0'; prefix++) {
 116                 if (*prefix == '+') {
 117                         if (!lookup_name_smbconf(mem_ctx, name,
 118                                          LOOKUP_NAME_ALL|LOOKUP_NAME_GROUP,
 119                                          NULL, NULL, &sid, &type)) {
 120                                 DEBUG(5, ("lookup_name %s failed\n", name));
 121                                 return False;
 122                         }
 123                         if ((type != SID_NAME_DOM_GRP) &&
 124                             (type != SID_NAME_ALIAS) &&
 125                             (type != SID_NAME_WKN_GRP)) {
 126                                 DEBUG(5, ("%s is a %s, expected a group\n",
 127                                           name, sid_type_lookup(type)));
 128                                 return False;
 129                         }
 130                         if (nt_token_check_sid(&sid, token)) {
 131                                 return True;
 132                         }
 133                         continue;
 134                 }
 135                 if (*prefix == '&') {
 136                         if (username) {
 137                                 if (user_in_netgroup(mem_ctx, username, name)) {
 138                                         return True;
 139                                 }
 140                         }
 141                         continue;
 142                 }
 143                 smb_panic("got invalid prefix from do_groups_check");
 144         }
 145         return False;
 146 }
 147
 148 /*
 149  * Check whether a user is contained in the list provided.
 150  *
 151  * Please note that the user name and share names passed in here mainly for
 152  * the substitution routines that expand the parameter values, the decision
 153  * whether a user is in the list is done after a lookup_name on the expanded
 154  * parameter value, solely based on comparing the SIDs in token.
 155  *
 156  * The other use is the netgroup check when using @group or &group.
 157  */
 158
 159 bool token_contains_name_in_list(const char *username,
 160                                  const char *domain,
 161                                  const char *sharename,
 162                                  const struct security_token *token,
 163                                  const char **list)
 164 {
 165         TALLOC_CTX *mem_ctx;
 166
 167         if (list == NULL) {
 168                 return False;
 169         }
 170
 171         if ( (mem_ctx = talloc_new(NULL)) == NULL ) {
 172                 smb_panic("talloc_new failed");
 173         }
 174
 175         while (*list != NULL) {
 176                 if (token_contains_name(mem_ctx, username, domain, sharename,
 177                                         token, *list)) {
 178                         TALLOC_FREE(mem_ctx);
 179                         return True;
 180                 }
 181                 list += 1;
 182         }
 183
 184         TALLOC_FREE(mem_ctx);
 185         return False;
 186 }
 187
 188 /*
 189  * Check whether the user described by "token" has access to share snum.
 190  *
 191  * This looks at "invalid users", "valid users" and "only user/username"
 192  *
 193  * Please note that the user name and share names passed in here mainly for
 194  * the substitution routines that expand the parameter values, the decision
 195  * whether a user is in the list is done after a lookup_name on the expanded
 196  * parameter value, solely based on comparing the SIDs in token.
 197  *
 198  * The other use is the netgroup check when using @group or &group.
 199  */
 200
 201 bool user_ok_token(const char *username, const char *domain,
 202                    const struct security_token *token, int snum)
 203 {
 204         if (lp_invalid_users(snum) != NULL) {
 205                 if (token_contains_name_in_list(username, domain,
 206                                                 lp_servicename(talloc_tos(), snum),
 207                                                 token,
 208                                                 lp_invalid_users(snum))) {
 209                         DEBUG(10, ("User %s in 'invalid users'\n", username));
 210                         return False;
 211                 }
 212         }
 213
 214         if (lp_valid_users(snum) != NULL) {
 215                 if (!token_contains_name_in_list(username, domain,
 216                                                  lp_servicename(talloc_tos(), snum),
 217                                                  token,
 218                                                  lp_valid_users(snum))) {
 219                         DEBUG(10, ("User %s not in 'valid users'\n",
 220                                    username));
 221                         return False;
 222                 }
 223         }
 224
 225         if (lp_onlyuser(snum)) {
 226                 const char *list[2];
 227                 list[0] = lp_username(talloc_tos(), snum);
 228                 list[1] = NULL;
 229                 if ((list[0] == NULL) || (*list[0] == '\0')) {
 230                         DEBUG(0, ("'only user = yes' and no 'username ='\n"));
 231                         return False;
 232                 }
 233                 if (!token_contains_name_in_list(NULL, domain,
 234                                                  lp_servicename(talloc_tos(), snum),
 235                                                  token, list)) {
 236                         DEBUG(10, ("%s != 'username'\n", username));
 237                         return False;
 238                 }
 239         }
 240
 241         DEBUG(10, ("user_ok_token: share %s is ok for unix user %s\n",
 242                    lp_servicename(talloc_tos(), snum), username));
 243
 244         return True;
 245 }
 246
 247 /*
 248  * Check whether the user described by "token" is restricted to read-only
 249  * access on share snum.
 250  *
 251  * This looks at "invalid users", "valid users" and "only user/username"
 252  *
 253  * Please note that the user name and share names passed in here mainly for
 254  * the substitution routines that expand the parameter values, the decision
 255  * whether a user is in the list is done after a lookup_name on the expanded
 256  * parameter value, solely based on comparing the SIDs in token.
 257  *
 258  * The other use is the netgroup check when using @group or &group.
 259  */
 260
 261 bool is_share_read_only_for_token(const char *username,
 262                                   const char *domain,
 263                                   const struct security_token *token,
 264                                   connection_struct *conn)
 265 {
 266         int snum = SNUM(conn);
 267         bool result = conn->read_only;
 268
 269         if (lp_readlist(snum) != NULL) {
 270                 if (token_contains_name_in_list(username, domain,
 271                                                 lp_servicename(talloc_tos(), snum),
 272                                                 token,
 273                                                 lp_readlist(snum))) {
 274                         result = True;
 275                 }
 276         }
 277
 278         if (lp_writelist(snum) != NULL) {
 279                 if (token_contains_name_in_list(username, domain,
 280                                                 lp_servicename(talloc_tos(), snum),
 281                                                 token,
 282                                                 lp_writelist(snum))) {
 283                         result = False;
 284                 }
 285         }
 286
 287         DEBUG(10,("is_share_read_only_for_user: share %s is %s for unix user "
 288                   "%s\n", lp_servicename(talloc_tos(), snum),
 289                   result ? "read-only" : "read-write", username));
 290
 291         return result;
 292 }