1 // SPDX-License-Identifier: LGPL-2.1+ 2 /* 3 * Copyright (C) International Business Machines Corp., 2007,2008 4 * Author(s): Steve French (sfrench@us.ibm.com) 5 * Copyright (C) 2020 Samsung Electronics Co., Ltd. 6 * Author(s): Namjae Jeon <linkinjeon@kernel.org> 7 */ 8 9 #include <linux/fs.h> 10 #include <linux/slab.h> 11 #include <linux/string.h> 12 #include <linux/mnt_idmapping.h> 13 14 #include "smbacl.h" 15 #include "smb_common.h" 16 #include "server.h" 17 #include "misc.h" 18 #include "mgmt/share_config.h" 19 20 static const struct smb_sid domain = {1, 4, {0, 0, 0, 0, 0, 5}, 21 {cpu_to_le32(21), cpu_to_le32(1), cpu_to_le32(2), cpu_to_le32(3), 22 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }; 23 24 /* security id for everyone/world system group */ 25 static const struct smb_sid creator_owner = { 26 1, 1, {0, 0, 0, 0, 0, 3}, {0} }; 27 /* security id for everyone/world system group */ 28 static const struct smb_sid creator_group = { 29 1, 1, {0, 0, 0, 0, 0, 3}, {cpu_to_le32(1)} }; 30 31 /* security id for everyone/world system group */ 32 static const struct smb_sid sid_everyone = { 33 1, 1, {0, 0, 0, 0, 0, 1}, {0} }; 34 /* security id for Authenticated Users system group */ 35 static const struct smb_sid sid_authusers = { 36 1, 1, {0, 0, 0, 0, 0, 5}, {cpu_to_le32(11)} }; 37 38 /* S-1-22-1 Unmapped Unix users */ 39 static const struct smb_sid sid_unix_users = {1, 1, {0, 0, 0, 0, 0, 22}, 40 {cpu_to_le32(1), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }; 41 42 /* S-1-22-2 Unmapped Unix groups */ 43 static const struct smb_sid sid_unix_groups = { 1, 1, {0, 0, 0, 0, 0, 22}, 44 {cpu_to_le32(2), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }; 45 46 /* 47 * See http://technet.microsoft.com/en-us/library/hh509017(v=ws.10).aspx 48 */ 49 50 /* S-1-5-88 MS NFS and Apple style UID/GID/mode */ 51 52 /* S-1-5-88-1 Unix uid */ 53 static const struct smb_sid sid_unix_NFS_users = { 1, 2, {0, 0, 0, 0, 0, 5}, 54 {cpu_to_le32(88), 55 cpu_to_le32(1), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }; 56 57 /* S-1-5-88-2 Unix gid */ 58 static const struct smb_sid sid_unix_NFS_groups = { 1, 2, {0, 0, 0, 0, 0, 5}, 59 {cpu_to_le32(88), 60 cpu_to_le32(2), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }; 61 62 /* S-1-5-88-3 Unix mode */ 63 static const struct smb_sid sid_unix_NFS_mode = { 1, 2, {0, 0, 0, 0, 0, 5}, 64 {cpu_to_le32(88), 65 cpu_to_le32(3), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }; 66 67 /* 68 * if the two SIDs (roughly equivalent to a UUID for a user or group) are 69 * the same returns zero, if they do not match returns non-zero. 70 */ 71 int compare_sids(const struct smb_sid *ctsid, const struct smb_sid *cwsid) 72 { 73 int i; 74 int num_subauth, num_sat, num_saw; 75 76 if (!ctsid || !cwsid) 77 return 1; 78 79 /* compare the revision */ 80 if (ctsid->revision != cwsid->revision) { 81 if (ctsid->revision > cwsid->revision) 82 return 1; 83 else 84 return -1; 85 } 86 87 /* compare all of the six auth values */ 88 for (i = 0; i < NUM_AUTHS; ++i) { 89 if (ctsid->authority[i] != cwsid->authority[i]) { 90 if (ctsid->authority[i] > cwsid->authority[i]) 91 return 1; 92 else 93 return -1; 94 } 95 } 96 97 /* compare all of the subauth values if any */ 98 num_sat = ctsid->num_subauth; 99 num_saw = cwsid->num_subauth; 100 num_subauth = min(num_sat, num_saw); 101 if (num_subauth) { 102 for (i = 0; i < num_subauth; ++i) { 103 if (ctsid->sub_auth[i] != cwsid->sub_auth[i]) { 104 if (le32_to_cpu(ctsid->sub_auth[i]) > 105 le32_to_cpu(cwsid->sub_auth[i])) 106 return 1; 107 else 108 return -1; 109 } 110 } 111 } 112 113 return 0; /* sids compare/match */ 114 } 115 116 static void smb_copy_sid(struct smb_sid *dst, const struct smb_sid *src) 117 { 118 int i; 119 120 dst->revision = src->revision; 121 dst->num_subauth = min_t(u8, src->num_subauth, SID_MAX_SUB_AUTHORITIES); 122 for (i = 0; i < NUM_AUTHS; ++i) 123 dst->authority[i] = src->authority[i]; 124 for (i = 0; i < dst->num_subauth; ++i) 125 dst->sub_auth[i] = src->sub_auth[i]; 126 } 127 128 /* 129 * change posix mode to reflect permissions 130 * pmode is the existing mode (we only want to overwrite part of this 131 * bits to set can be: S_IRWXU, S_IRWXG or S_IRWXO ie 00700 or 00070 or 00007 132 */ 133 static umode_t access_flags_to_mode(struct smb_fattr *fattr, __le32 ace_flags, 134 int type) 135 { 136 __u32 flags = le32_to_cpu(ace_flags); 137 umode_t mode = 0; 138 139 if (flags & GENERIC_ALL) { 140 mode = 0777; 141 ksmbd_debug(SMB, "all perms\n"); 142 return mode; 143 } 144 145 if ((flags & GENERIC_READ) || (flags & FILE_READ_RIGHTS)) 146 mode = 0444; 147 if ((flags & GENERIC_WRITE) || (flags & FILE_WRITE_RIGHTS)) { 148 mode |= 0222; 149 if (S_ISDIR(fattr->cf_mode)) 150 mode |= 0111; 151 } 152 if ((flags & GENERIC_EXECUTE) || (flags & FILE_EXEC_RIGHTS)) 153 mode |= 0111; 154 155 if (type == ACCESS_DENIED_ACE_TYPE || type == ACCESS_DENIED_OBJECT_ACE_TYPE) 156 mode = ~mode; 157 158 ksmbd_debug(SMB, "access flags 0x%x mode now %04o\n", flags, mode); 159 160 return mode; 161 } 162 163 /* 164 * Generate access flags to reflect permissions mode is the existing mode. 165 * This function is called for every ACE in the DACL whose SID matches 166 * with either owner or group or everyone. 167 */ 168 static void mode_to_access_flags(umode_t mode, umode_t bits_to_use, 169 __u32 *pace_flags) 170 { 171 /* reset access mask */ 172 *pace_flags = 0x0; 173 174 /* bits to use are either S_IRWXU or S_IRWXG or S_IRWXO */ 175 mode &= bits_to_use; 176 177 /* 178 * check for R/W/X UGO since we do not know whose flags 179 * is this but we have cleared all the bits sans RWX for 180 * either user or group or other as per bits_to_use 181 */ 182 if (mode & 0444) 183 *pace_flags |= SET_FILE_READ_RIGHTS; 184 if (mode & 0222) 185 *pace_flags |= FILE_WRITE_RIGHTS; 186 if (mode & 0111) 187 *pace_flags |= SET_FILE_EXEC_RIGHTS; 188 189 ksmbd_debug(SMB, "mode: %o, access flags now 0x%x\n", 190 mode, *pace_flags); 191 } 192 193 static __u16 fill_ace_for_sid(struct smb_ace *pntace, 194 const struct smb_sid *psid, int type, int flags, 195 umode_t mode, umode_t bits) 196 { 197 int i; 198 __u16 size = 0; 199 __u32 access_req = 0; 200 201 pntace->type = type; 202 pntace->flags = flags; 203 mode_to_access_flags(mode, bits, &access_req); 204 if (!access_req) 205 access_req = SET_MINIMUM_RIGHTS; 206 pntace->access_req = cpu_to_le32(access_req); 207 208 pntace->sid.revision = psid->revision; 209 pntace->sid.num_subauth = psid->num_subauth; 210 for (i = 0; i < NUM_AUTHS; i++) 211 pntace->sid.authority[i] = psid->authority[i]; 212 for (i = 0; i < psid->num_subauth; i++) 213 pntace->sid.sub_auth[i] = psid->sub_auth[i]; 214 215 size = 1 + 1 + 2 + 4 + 1 + 1 + 6 + (psid->num_subauth * 4); 216 pntace->size = cpu_to_le16(size); 217 218 return size; 219 } 220 221 void id_to_sid(unsigned int cid, uint sidtype, struct smb_sid *ssid) 222 { 223 switch (sidtype) { 224 case SIDOWNER: 225 smb_copy_sid(ssid, &server_conf.domain_sid); 226 break; 227 case SIDUNIX_USER: 228 smb_copy_sid(ssid, &sid_unix_users); 229 break; 230 case SIDUNIX_GROUP: 231 smb_copy_sid(ssid, &sid_unix_groups); 232 break; 233 case SIDCREATOR_OWNER: 234 smb_copy_sid(ssid, &creator_owner); 235 return; 236 case SIDCREATOR_GROUP: 237 smb_copy_sid(ssid, &creator_group); 238 return; 239 case SIDNFS_USER: 240 smb_copy_sid(ssid, &sid_unix_NFS_users); 241 break; 242 case SIDNFS_GROUP: 243 smb_copy_sid(ssid, &sid_unix_NFS_groups); 244 break; 245 case SIDNFS_MODE: 246 smb_copy_sid(ssid, &sid_unix_NFS_mode); 247 break; 248 default: 249 return; 250 } 251 252 /* RID */ 253 ssid->sub_auth[ssid->num_subauth] = cpu_to_le32(cid); 254 ssid->num_subauth++; 255 } 256 257 static int sid_to_id(struct mnt_idmap *idmap, 258 struct smb_sid *psid, uint sidtype, 259 struct smb_fattr *fattr) 260 { 261 int rc = -EINVAL; 262 263 /* 264 * If we have too many subauthorities, then something is really wrong. 265 * Just return an error. 266 */ 267 if (unlikely(psid->num_subauth > SID_MAX_SUB_AUTHORITIES)) { 268 pr_err("%s: %u subauthorities is too many!\n", 269 __func__, psid->num_subauth); 270 return -EIO; 271 } 272 273 if (psid->num_subauth == 0) { 274 pr_err("%s: zero subauthorities!\n", __func__); 275 return -EIO; 276 } 277 278 if (sidtype == SIDOWNER) { 279 kuid_t uid; 280 uid_t id; 281 282 id = le32_to_cpu(psid->sub_auth[psid->num_subauth - 1]); 283 uid = KUIDT_INIT(id); 284 uid = from_vfsuid(idmap, &init_user_ns, VFSUIDT_INIT(uid)); 285 if (uid_valid(uid)) { 286 fattr->cf_uid = uid; 287 rc = 0; 288 } 289 } else { 290 kgid_t gid; 291 gid_t id; 292 293 id = le32_to_cpu(psid->sub_auth[psid->num_subauth - 1]); 294 gid = KGIDT_INIT(id); 295 gid = from_vfsgid(idmap, &init_user_ns, VFSGIDT_INIT(gid)); 296 if (gid_valid(gid)) { 297 fattr->cf_gid = gid; 298 rc = 0; 299 } 300 } 301 302 return rc; 303 } 304 305 void posix_state_to_acl(struct posix_acl_state *state, 306 struct posix_acl_entry *pace) 307 { 308 int i; 309 310 pace->e_tag = ACL_USER_OBJ; 311 pace->e_perm = state->owner.allow; 312 for (i = 0; i < state->users->n; i++) { 313 pace++; 314 pace->e_tag = ACL_USER; 315 pace->e_uid = state->users->aces[i].uid; 316 pace->e_perm = state->users->aces[i].perms.allow; 317 } 318 319 pace++; 320 pace->e_tag = ACL_GROUP_OBJ; 321 pace->e_perm = state->group.allow; 322 323 for (i = 0; i < state->groups->n; i++) { 324 pace++; 325 pace->e_tag = ACL_GROUP; 326 pace->e_gid = state->groups->aces[i].gid; 327 pace->e_perm = state->groups->aces[i].perms.allow; 328 } 329 330 if (state->users->n || state->groups->n) { 331 pace++; 332 pace->e_tag = ACL_MASK; 333 pace->e_perm = state->mask.allow; 334 } 335 336 pace++; 337 pace->e_tag = ACL_OTHER; 338 pace->e_perm = state->other.allow; 339 } 340 341 int init_acl_state(struct posix_acl_state *state, int cnt) 342 { 343 int alloc; 344 345 memset(state, 0, sizeof(struct posix_acl_state)); 346 /* 347 * In the worst case, each individual acl could be for a distinct 348 * named user or group, but we don't know which, so we allocate 349 * enough space for either: 350 */ 351 alloc = sizeof(struct posix_ace_state_array) 352 + cnt * sizeof(struct posix_user_ace_state); 353 state->users = kzalloc(alloc, GFP_KERNEL); 354 if (!state->users) 355 return -ENOMEM; 356 state->groups = kzalloc(alloc, GFP_KERNEL); 357 if (!state->groups) { 358 kfree(state->users); 359 return -ENOMEM; 360 } 361 return 0; 362 } 363 364 void free_acl_state(struct posix_acl_state *state) 365 { 366 kfree(state->users); 367 kfree(state->groups); 368 } 369 370 static void parse_dacl(struct mnt_idmap *idmap, 371 struct smb_acl *pdacl, char *end_of_acl, 372 struct smb_sid *pownersid, struct smb_sid *pgrpsid, 373 struct smb_fattr *fattr) 374 { 375 int i, ret; 376 int num_aces = 0; 377 unsigned int acl_size; 378 char *acl_base; 379 struct smb_ace **ppace; 380 struct posix_acl_entry *cf_pace, *cf_pdace; 381 struct posix_acl_state acl_state, default_acl_state; 382 umode_t mode = 0, acl_mode; 383 bool owner_found = false, group_found = false, others_found = false; 384 385 if (!pdacl) 386 return; 387 388 /* validate that we do not go past end of acl */ 389 if (end_of_acl < (char *)pdacl + sizeof(struct smb_acl) || 390 end_of_acl < (char *)pdacl + le16_to_cpu(pdacl->size)) { 391 pr_err("ACL too small to parse DACL\n"); 392 return; 393 } 394 395 ksmbd_debug(SMB, "DACL revision %d size %d num aces %d\n", 396 le16_to_cpu(pdacl->revision), le16_to_cpu(pdacl->size), 397 le32_to_cpu(pdacl->num_aces)); 398 399 acl_base = (char *)pdacl; 400 acl_size = sizeof(struct smb_acl); 401 402 num_aces = le32_to_cpu(pdacl->num_aces); 403 if (num_aces <= 0) 404 return; 405 406 if (num_aces > (le16_to_cpu(pdacl->size) - sizeof(struct smb_acl)) / 407 (offsetof(struct smb_ace, sid) + 408 offsetof(struct smb_sid, sub_auth) + sizeof(__le16))) 409 return; 410 411 ret = init_acl_state(&acl_state, num_aces); 412 if (ret) 413 return; 414 ret = init_acl_state(&default_acl_state, num_aces); 415 if (ret) { 416 free_acl_state(&acl_state); 417 return; 418 } 419 420 ppace = kmalloc_array(num_aces, sizeof(struct smb_ace *), GFP_KERNEL); 421 if (!ppace) { 422 free_acl_state(&default_acl_state); 423 free_acl_state(&acl_state); 424 return; 425 } 426 427 /* 428 * reset rwx permissions for user/group/other. 429 * Also, if num_aces is 0 i.e. DACL has no ACEs, 430 * user/group/other have no permissions 431 */ 432 for (i = 0; i < num_aces; ++i) { 433 if (end_of_acl - acl_base < acl_size) 434 break; 435 436 ppace[i] = (struct smb_ace *)(acl_base + acl_size); 437 acl_base = (char *)ppace[i]; 438 acl_size = offsetof(struct smb_ace, sid) + 439 offsetof(struct smb_sid, sub_auth); 440 441 if (end_of_acl - acl_base < acl_size || 442 ppace[i]->sid.num_subauth == 0 || 443 ppace[i]->sid.num_subauth > SID_MAX_SUB_AUTHORITIES || 444 (end_of_acl - acl_base < 445 acl_size + sizeof(__le32) * ppace[i]->sid.num_subauth) || 446 (le16_to_cpu(ppace[i]->size) < 447 acl_size + sizeof(__le32) * ppace[i]->sid.num_subauth)) 448 break; 449 450 acl_size = le16_to_cpu(ppace[i]->size); 451 ppace[i]->access_req = 452 smb_map_generic_desired_access(ppace[i]->access_req); 453 454 if (!(compare_sids(&ppace[i]->sid, &sid_unix_NFS_mode))) { 455 fattr->cf_mode = 456 le32_to_cpu(ppace[i]->sid.sub_auth[2]); 457 break; 458 } else if (!compare_sids(&ppace[i]->sid, pownersid)) { 459 acl_mode = access_flags_to_mode(fattr, 460 ppace[i]->access_req, 461 ppace[i]->type); 462 acl_mode &= 0700; 463 464 if (!owner_found) { 465 mode &= ~(0700); 466 mode |= acl_mode; 467 } 468 owner_found = true; 469 } else if (!compare_sids(&ppace[i]->sid, pgrpsid) || 470 ppace[i]->sid.sub_auth[ppace[i]->sid.num_subauth - 1] == 471 DOMAIN_USER_RID_LE) { 472 acl_mode = access_flags_to_mode(fattr, 473 ppace[i]->access_req, 474 ppace[i]->type); 475 acl_mode &= 0070; 476 if (!group_found) { 477 mode &= ~(0070); 478 mode |= acl_mode; 479 } 480 group_found = true; 481 } else if (!compare_sids(&ppace[i]->sid, &sid_everyone)) { 482 acl_mode = access_flags_to_mode(fattr, 483 ppace[i]->access_req, 484 ppace[i]->type); 485 acl_mode &= 0007; 486 if (!others_found) { 487 mode &= ~(0007); 488 mode |= acl_mode; 489 } 490 others_found = true; 491 } else if (!compare_sids(&ppace[i]->sid, &creator_owner)) { 492 continue; 493 } else if (!compare_sids(&ppace[i]->sid, &creator_group)) { 494 continue; 495 } else if (!compare_sids(&ppace[i]->sid, &sid_authusers)) { 496 continue; 497 } else { 498 struct smb_fattr temp_fattr; 499 500 acl_mode = access_flags_to_mode(fattr, ppace[i]->access_req, 501 ppace[i]->type); 502 temp_fattr.cf_uid = INVALID_UID; 503 ret = sid_to_id(idmap, &ppace[i]->sid, SIDOWNER, &temp_fattr); 504 if (ret || uid_eq(temp_fattr.cf_uid, INVALID_UID)) { 505 pr_err("%s: Error %d mapping Owner SID to uid\n", 506 __func__, ret); 507 continue; 508 } 509 510 acl_state.owner.allow = ((acl_mode & 0700) >> 6) | 0004; 511 acl_state.users->aces[acl_state.users->n].uid = 512 temp_fattr.cf_uid; 513 acl_state.users->aces[acl_state.users->n++].perms.allow = 514 ((acl_mode & 0700) >> 6) | 0004; 515 default_acl_state.owner.allow = ((acl_mode & 0700) >> 6) | 0004; 516 default_acl_state.users->aces[default_acl_state.users->n].uid = 517 temp_fattr.cf_uid; 518 default_acl_state.users->aces[default_acl_state.users->n++].perms.allow = 519 ((acl_mode & 0700) >> 6) | 0004; 520 } 521 } 522 kfree(ppace); 523 524 if (owner_found) { 525 /* The owner must be set to at least read-only. */ 526 acl_state.owner.allow = ((mode & 0700) >> 6) | 0004; 527 acl_state.users->aces[acl_state.users->n].uid = fattr->cf_uid; 528 acl_state.users->aces[acl_state.users->n++].perms.allow = 529 ((mode & 0700) >> 6) | 0004; 530 default_acl_state.owner.allow = ((mode & 0700) >> 6) | 0004; 531 default_acl_state.users->aces[default_acl_state.users->n].uid = 532 fattr->cf_uid; 533 default_acl_state.users->aces[default_acl_state.users->n++].perms.allow = 534 ((mode & 0700) >> 6) | 0004; 535 } 536 537 if (group_found) { 538 acl_state.group.allow = (mode & 0070) >> 3; 539 acl_state.groups->aces[acl_state.groups->n].gid = 540 fattr->cf_gid; 541 acl_state.groups->aces[acl_state.groups->n++].perms.allow = 542 (mode & 0070) >> 3; 543 default_acl_state.group.allow = (mode & 0070) >> 3; 544 default_acl_state.groups->aces[default_acl_state.groups->n].gid = 545 fattr->cf_gid; 546 default_acl_state.groups->aces[default_acl_state.groups->n++].perms.allow = 547 (mode & 0070) >> 3; 548 } 549 550 if (others_found) { 551 fattr->cf_mode &= ~(0007); 552 fattr->cf_mode |= mode & 0007; 553 554 acl_state.other.allow = mode & 0007; 555 default_acl_state.other.allow = mode & 0007; 556 } 557 558 if (acl_state.users->n || acl_state.groups->n) { 559 acl_state.mask.allow = 0x07; 560 561 if (IS_ENABLED(CONFIG_FS_POSIX_ACL)) { 562 fattr->cf_acls = 563 posix_acl_alloc(acl_state.users->n + 564 acl_state.groups->n + 4, GFP_KERNEL); 565 if (fattr->cf_acls) { 566 cf_pace = fattr->cf_acls->a_entries; 567 posix_state_to_acl(&acl_state, cf_pace); 568 } 569 } 570 } 571 572 if (default_acl_state.users->n || default_acl_state.groups->n) { 573 default_acl_state.mask.allow = 0x07; 574 575 if (IS_ENABLED(CONFIG_FS_POSIX_ACL)) { 576 fattr->cf_dacls = 577 posix_acl_alloc(default_acl_state.users->n + 578 default_acl_state.groups->n + 4, GFP_KERNEL); 579 if (fattr->cf_dacls) { 580 cf_pdace = fattr->cf_dacls->a_entries; 581 posix_state_to_acl(&default_acl_state, cf_pdace); 582 } 583 } 584 } 585 free_acl_state(&acl_state); 586 free_acl_state(&default_acl_state); 587 } 588 589 static void set_posix_acl_entries_dacl(struct mnt_idmap *idmap, 590 struct smb_ace *pndace, 591 struct smb_fattr *fattr, u32 *num_aces, 592 u16 *size, u32 nt_aces_num) 593 { 594 struct posix_acl_entry *pace; 595 struct smb_sid *sid; 596 struct smb_ace *ntace; 597 int i, j; 598 599 if (!fattr->cf_acls) 600 goto posix_default_acl; 601 602 pace = fattr->cf_acls->a_entries; 603 for (i = 0; i < fattr->cf_acls->a_count; i++, pace++) { 604 int flags = 0; 605 606 sid = kmalloc(sizeof(struct smb_sid), GFP_KERNEL); 607 if (!sid) 608 break; 609 610 if (pace->e_tag == ACL_USER) { 611 uid_t uid; 612 unsigned int sid_type = SIDOWNER; 613 614 uid = posix_acl_uid_translate(idmap, pace); 615 if (!uid) 616 sid_type = SIDUNIX_USER; 617 id_to_sid(uid, sid_type, sid); 618 } else if (pace->e_tag == ACL_GROUP) { 619 gid_t gid; 620 621 gid = posix_acl_gid_translate(idmap, pace); 622 id_to_sid(gid, SIDUNIX_GROUP, sid); 623 } else if (pace->e_tag == ACL_OTHER && !nt_aces_num) { 624 smb_copy_sid(sid, &sid_everyone); 625 } else { 626 kfree(sid); 627 continue; 628 } 629 ntace = pndace; 630 for (j = 0; j < nt_aces_num; j++) { 631 if (ntace->sid.sub_auth[ntace->sid.num_subauth - 1] == 632 sid->sub_auth[sid->num_subauth - 1]) 633 goto pass_same_sid; 634 ntace = (struct smb_ace *)((char *)ntace + 635 le16_to_cpu(ntace->size)); 636 } 637 638 if (S_ISDIR(fattr->cf_mode) && pace->e_tag == ACL_OTHER) 639 flags = 0x03; 640 641 ntace = (struct smb_ace *)((char *)pndace + *size); 642 *size += fill_ace_for_sid(ntace, sid, ACCESS_ALLOWED, flags, 643 pace->e_perm, 0777); 644 (*num_aces)++; 645 if (pace->e_tag == ACL_USER) 646 ntace->access_req |= 647 FILE_DELETE_LE | FILE_DELETE_CHILD_LE; 648 649 if (S_ISDIR(fattr->cf_mode) && 650 (pace->e_tag == ACL_USER || pace->e_tag == ACL_GROUP)) { 651 ntace = (struct smb_ace *)((char *)pndace + *size); 652 *size += fill_ace_for_sid(ntace, sid, ACCESS_ALLOWED, 653 0x03, pace->e_perm, 0777); 654 (*num_aces)++; 655 if (pace->e_tag == ACL_USER) 656 ntace->access_req |= 657 FILE_DELETE_LE | FILE_DELETE_CHILD_LE; 658 } 659 660 pass_same_sid: 661 kfree(sid); 662 } 663 664 if (nt_aces_num) 665 return; 666 667 posix_default_acl: 668 if (!fattr->cf_dacls) 669 return; 670 671 pace = fattr->cf_dacls->a_entries; 672 for (i = 0; i < fattr->cf_dacls->a_count; i++, pace++) { 673 sid = kmalloc(sizeof(struct smb_sid), GFP_KERNEL); 674 if (!sid) 675 break; 676 677 if (pace->e_tag == ACL_USER) { 678 uid_t uid; 679 680 uid = posix_acl_uid_translate(idmap, pace); 681 id_to_sid(uid, SIDCREATOR_OWNER, sid); 682 } else if (pace->e_tag == ACL_GROUP) { 683 gid_t gid; 684 685 gid = posix_acl_gid_translate(idmap, pace); 686 id_to_sid(gid, SIDCREATOR_GROUP, sid); 687 } else { 688 kfree(sid); 689 continue; 690 } 691 692 ntace = (struct smb_ace *)((char *)pndace + *size); 693 *size += fill_ace_for_sid(ntace, sid, ACCESS_ALLOWED, 0x0b, 694 pace->e_perm, 0777); 695 (*num_aces)++; 696 if (pace->e_tag == ACL_USER) 697 ntace->access_req |= 698 FILE_DELETE_LE | FILE_DELETE_CHILD_LE; 699 kfree(sid); 700 } 701 } 702 703 static void set_ntacl_dacl(struct mnt_idmap *idmap, 704 struct smb_acl *pndacl, 705 struct smb_acl *nt_dacl, 706 unsigned int aces_size, 707 const struct smb_sid *pownersid, 708 const struct smb_sid *pgrpsid, 709 struct smb_fattr *fattr) 710 { 711 struct smb_ace *ntace, *pndace; 712 int nt_num_aces = le32_to_cpu(nt_dacl->num_aces), num_aces = 0; 713 unsigned short size = 0; 714 int i; 715 716 pndace = (struct smb_ace *)((char *)pndacl + sizeof(struct smb_acl)); 717 if (nt_num_aces) { 718 ntace = (struct smb_ace *)((char *)nt_dacl + sizeof(struct smb_acl)); 719 for (i = 0; i < nt_num_aces; i++) { 720 unsigned short nt_ace_size; 721 722 if (offsetof(struct smb_ace, access_req) > aces_size) 723 break; 724 725 nt_ace_size = le16_to_cpu(ntace->size); 726 if (nt_ace_size > aces_size) 727 break; 728 729 memcpy((char *)pndace + size, ntace, nt_ace_size); 730 size += nt_ace_size; 731 aces_size -= nt_ace_size; 732 ntace = (struct smb_ace *)((char *)ntace + nt_ace_size); 733 num_aces++; 734 } 735 } 736 737 set_posix_acl_entries_dacl(idmap, pndace, fattr, 738 &num_aces, &size, nt_num_aces); 739 pndacl->num_aces = cpu_to_le32(num_aces); 740 pndacl->size = cpu_to_le16(le16_to_cpu(pndacl->size) + size); 741 } 742 743 static void set_mode_dacl(struct mnt_idmap *idmap, 744 struct smb_acl *pndacl, struct smb_fattr *fattr) 745 { 746 struct smb_ace *pace, *pndace; 747 u32 num_aces = 0; 748 u16 size = 0, ace_size = 0; 749 uid_t uid; 750 const struct smb_sid *sid; 751 752 pace = pndace = (struct smb_ace *)((char *)pndacl + sizeof(struct smb_acl)); 753 754 if (fattr->cf_acls) { 755 set_posix_acl_entries_dacl(idmap, pndace, fattr, 756 &num_aces, &size, num_aces); 757 goto out; 758 } 759 760 /* owner RID */ 761 uid = from_kuid(&init_user_ns, fattr->cf_uid); 762 if (uid) 763 sid = &server_conf.domain_sid; 764 else 765 sid = &sid_unix_users; 766 ace_size = fill_ace_for_sid(pace, sid, ACCESS_ALLOWED, 0, 767 fattr->cf_mode, 0700); 768 pace->sid.sub_auth[pace->sid.num_subauth++] = cpu_to_le32(uid); 769 pace->size = cpu_to_le16(ace_size + 4); 770 size += le16_to_cpu(pace->size); 771 pace = (struct smb_ace *)((char *)pndace + size); 772 773 /* Group RID */ 774 ace_size = fill_ace_for_sid(pace, &sid_unix_groups, 775 ACCESS_ALLOWED, 0, fattr->cf_mode, 0070); 776 pace->sid.sub_auth[pace->sid.num_subauth++] = 777 cpu_to_le32(from_kgid(&init_user_ns, fattr->cf_gid)); 778 pace->size = cpu_to_le16(ace_size + 4); 779 size += le16_to_cpu(pace->size); 780 pace = (struct smb_ace *)((char *)pndace + size); 781 num_aces = 3; 782 783 if (S_ISDIR(fattr->cf_mode)) { 784 pace = (struct smb_ace *)((char *)pndace + size); 785 786 /* creator owner */ 787 size += fill_ace_for_sid(pace, &creator_owner, ACCESS_ALLOWED, 788 0x0b, fattr->cf_mode, 0700); 789 pace = (struct smb_ace *)((char *)pndace + size); 790 791 /* creator group */ 792 size += fill_ace_for_sid(pace, &creator_group, ACCESS_ALLOWED, 793 0x0b, fattr->cf_mode, 0070); 794 pace = (struct smb_ace *)((char *)pndace + size); 795 num_aces = 5; 796 } 797 798 /* other */ 799 size += fill_ace_for_sid(pace, &sid_everyone, ACCESS_ALLOWED, 0, 800 fattr->cf_mode, 0007); 801 802 out: 803 pndacl->num_aces = cpu_to_le32(num_aces); 804 pndacl->size = cpu_to_le16(le16_to_cpu(pndacl->size) + size); 805 } 806 807 static int parse_sid(struct smb_sid *psid, char *end_of_acl) 808 { 809 /* 810 * validate that we do not go past end of ACL - sid must be at least 8 811 * bytes long (assuming no sub-auths - e.g. the null SID 812 */ 813 if (end_of_acl < (char *)psid + 8) { 814 pr_err("ACL too small to parse SID %p\n", psid); 815 return -EINVAL; 816 } 817 818 if (!psid->num_subauth) 819 return 0; 820 821 if (psid->num_subauth > SID_MAX_SUB_AUTHORITIES || 822 end_of_acl < (char *)psid + 8 + sizeof(__le32) * psid->num_subauth) 823 return -EINVAL; 824 825 return 0; 826 } 827 828 /* Convert CIFS ACL to POSIX form */ 829 int parse_sec_desc(struct mnt_idmap *idmap, struct smb_ntsd *pntsd, 830 int acl_len, struct smb_fattr *fattr) 831 { 832 int rc = 0; 833 struct smb_sid *owner_sid_ptr, *group_sid_ptr; 834 struct smb_acl *dacl_ptr; /* no need for SACL ptr */ 835 char *end_of_acl = ((char *)pntsd) + acl_len; 836 __u32 dacloffset; 837 int pntsd_type; 838 839 if (!pntsd) 840 return -EIO; 841 842 if (acl_len < sizeof(struct smb_ntsd)) 843 return -EINVAL; 844 845 owner_sid_ptr = (struct smb_sid *)((char *)pntsd + 846 le32_to_cpu(pntsd->osidoffset)); 847 group_sid_ptr = (struct smb_sid *)((char *)pntsd + 848 le32_to_cpu(pntsd->gsidoffset)); 849 dacloffset = le32_to_cpu(pntsd->dacloffset); 850 dacl_ptr = (struct smb_acl *)((char *)pntsd + dacloffset); 851 ksmbd_debug(SMB, 852 "revision %d type 0x%x ooffset 0x%x goffset 0x%x sacloffset 0x%x dacloffset 0x%x\n", 853 pntsd->revision, pntsd->type, le32_to_cpu(pntsd->osidoffset), 854 le32_to_cpu(pntsd->gsidoffset), 855 le32_to_cpu(pntsd->sacloffset), dacloffset); 856 857 pntsd_type = le16_to_cpu(pntsd->type); 858 if (!(pntsd_type & DACL_PRESENT)) { 859 ksmbd_debug(SMB, "DACL_PRESENT in DACL type is not set\n"); 860 return rc; 861 } 862 863 pntsd->type = cpu_to_le16(DACL_PRESENT); 864 865 if (pntsd->osidoffset) { 866 if (le32_to_cpu(pntsd->osidoffset) < sizeof(struct smb_ntsd)) 867 return -EINVAL; 868 869 rc = parse_sid(owner_sid_ptr, end_of_acl); 870 if (rc) { 871 pr_err("%s: Error %d parsing Owner SID\n", __func__, rc); 872 return rc; 873 } 874 875 rc = sid_to_id(idmap, owner_sid_ptr, SIDOWNER, fattr); 876 if (rc) { 877 pr_err("%s: Error %d mapping Owner SID to uid\n", 878 __func__, rc); 879 owner_sid_ptr = NULL; 880 } 881 } 882 883 if (pntsd->gsidoffset) { 884 if (le32_to_cpu(pntsd->gsidoffset) < sizeof(struct smb_ntsd)) 885 return -EINVAL; 886 887 rc = parse_sid(group_sid_ptr, end_of_acl); 888 if (rc) { 889 pr_err("%s: Error %d mapping Owner SID to gid\n", 890 __func__, rc); 891 return rc; 892 } 893 rc = sid_to_id(idmap, group_sid_ptr, SIDUNIX_GROUP, fattr); 894 if (rc) { 895 pr_err("%s: Error %d mapping Group SID to gid\n", 896 __func__, rc); 897 group_sid_ptr = NULL; 898 } 899 } 900 901 if ((pntsd_type & (DACL_AUTO_INHERITED | DACL_AUTO_INHERIT_REQ)) == 902 (DACL_AUTO_INHERITED | DACL_AUTO_INHERIT_REQ)) 903 pntsd->type |= cpu_to_le16(DACL_AUTO_INHERITED); 904 if (pntsd_type & DACL_PROTECTED) 905 pntsd->type |= cpu_to_le16(DACL_PROTECTED); 906 907 if (dacloffset) { 908 if (dacloffset < sizeof(struct smb_ntsd)) 909 return -EINVAL; 910 911 parse_dacl(idmap, dacl_ptr, end_of_acl, 912 owner_sid_ptr, group_sid_ptr, fattr); 913 } 914 915 return 0; 916 } 917 918 /* Convert permission bits from mode to equivalent CIFS ACL */ 919 int build_sec_desc(struct mnt_idmap *idmap, 920 struct smb_ntsd *pntsd, struct smb_ntsd *ppntsd, 921 int ppntsd_size, int addition_info, __u32 *secdesclen, 922 struct smb_fattr *fattr) 923 { 924 int rc = 0; 925 __u32 offset; 926 struct smb_sid *owner_sid_ptr, *group_sid_ptr; 927 struct smb_sid *nowner_sid_ptr, *ngroup_sid_ptr; 928 struct smb_acl *dacl_ptr = NULL; /* no need for SACL ptr */ 929 uid_t uid; 930 gid_t gid; 931 unsigned int sid_type = SIDOWNER; 932 933 nowner_sid_ptr = kmalloc(sizeof(struct smb_sid), GFP_KERNEL); 934 if (!nowner_sid_ptr) 935 return -ENOMEM; 936 937 uid = from_kuid(&init_user_ns, fattr->cf_uid); 938 if (!uid) 939 sid_type = SIDUNIX_USER; 940 id_to_sid(uid, sid_type, nowner_sid_ptr); 941 942 ngroup_sid_ptr = kmalloc(sizeof(struct smb_sid), GFP_KERNEL); 943 if (!ngroup_sid_ptr) { 944 kfree(nowner_sid_ptr); 945 return -ENOMEM; 946 } 947 948 gid = from_kgid(&init_user_ns, fattr->cf_gid); 949 id_to_sid(gid, SIDUNIX_GROUP, ngroup_sid_ptr); 950 951 offset = sizeof(struct smb_ntsd); 952 pntsd->sacloffset = 0; 953 pntsd->revision = cpu_to_le16(1); 954 pntsd->type = cpu_to_le16(SELF_RELATIVE); 955 if (ppntsd) 956 pntsd->type |= ppntsd->type; 957 958 if (addition_info & OWNER_SECINFO) { 959 pntsd->osidoffset = cpu_to_le32(offset); 960 owner_sid_ptr = (struct smb_sid *)((char *)pntsd + offset); 961 smb_copy_sid(owner_sid_ptr, nowner_sid_ptr); 962 offset += 1 + 1 + 6 + (nowner_sid_ptr->num_subauth * 4); 963 } 964 965 if (addition_info & GROUP_SECINFO) { 966 pntsd->gsidoffset = cpu_to_le32(offset); 967 group_sid_ptr = (struct smb_sid *)((char *)pntsd + offset); 968 smb_copy_sid(group_sid_ptr, ngroup_sid_ptr); 969 offset += 1 + 1 + 6 + (ngroup_sid_ptr->num_subauth * 4); 970 } 971 972 if (addition_info & DACL_SECINFO) { 973 pntsd->type |= cpu_to_le16(DACL_PRESENT); 974 dacl_ptr = (struct smb_acl *)((char *)pntsd + offset); 975 dacl_ptr->revision = cpu_to_le16(2); 976 dacl_ptr->size = cpu_to_le16(sizeof(struct smb_acl)); 977 dacl_ptr->num_aces = 0; 978 979 if (!ppntsd) { 980 set_mode_dacl(idmap, dacl_ptr, fattr); 981 } else { 982 struct smb_acl *ppdacl_ptr; 983 unsigned int dacl_offset = le32_to_cpu(ppntsd->dacloffset); 984 int ppdacl_size, ntacl_size = ppntsd_size - dacl_offset; 985 986 if (!dacl_offset || 987 (dacl_offset + sizeof(struct smb_acl) > ppntsd_size)) 988 goto out; 989 990 ppdacl_ptr = (struct smb_acl *)((char *)ppntsd + dacl_offset); 991 ppdacl_size = le16_to_cpu(ppdacl_ptr->size); 992 if (ppdacl_size > ntacl_size || 993 ppdacl_size < sizeof(struct smb_acl)) 994 goto out; 995 996 set_ntacl_dacl(idmap, dacl_ptr, ppdacl_ptr, 997 ntacl_size - sizeof(struct smb_acl), 998 nowner_sid_ptr, ngroup_sid_ptr, 999 fattr); 1000 } 1001 pntsd->dacloffset = cpu_to_le32(offset); 1002 offset += le16_to_cpu(dacl_ptr->size); 1003 } 1004 1005 out: 1006 kfree(nowner_sid_ptr); 1007 kfree(ngroup_sid_ptr); 1008 *secdesclen = offset; 1009 return rc; 1010 } 1011 1012 static void smb_set_ace(struct smb_ace *ace, const struct smb_sid *sid, u8 type, 1013 u8 flags, __le32 access_req) 1014 { 1015 ace->type = type; 1016 ace->flags = flags; 1017 ace->access_req = access_req; 1018 smb_copy_sid(&ace->sid, sid); 1019 ace->size = cpu_to_le16(1 + 1 + 2 + 4 + 1 + 1 + 6 + (sid->num_subauth * 4)); 1020 } 1021 1022 int smb_inherit_dacl(struct ksmbd_conn *conn, 1023 const struct path *path, 1024 unsigned int uid, unsigned int gid) 1025 { 1026 const struct smb_sid *psid, *creator = NULL; 1027 struct smb_ace *parent_aces, *aces; 1028 struct smb_acl *parent_pdacl; 1029 struct smb_ntsd *parent_pntsd = NULL; 1030 struct smb_sid owner_sid, group_sid; 1031 struct dentry *parent = path->dentry->d_parent; 1032 struct mnt_idmap *idmap = mnt_idmap(path->mnt); 1033 int inherited_flags = 0, flags = 0, i, ace_cnt = 0, nt_size = 0, pdacl_size; 1034 int rc = 0, num_aces, dacloffset, pntsd_type, pntsd_size, acl_len, aces_size; 1035 char *aces_base; 1036 bool is_dir = S_ISDIR(d_inode(path->dentry)->i_mode); 1037 1038 pntsd_size = ksmbd_vfs_get_sd_xattr(conn, idmap, 1039 parent, &parent_pntsd); 1040 if (pntsd_size <= 0) 1041 return -ENOENT; 1042 dacloffset = le32_to_cpu(parent_pntsd->dacloffset); 1043 if (!dacloffset || (dacloffset + sizeof(struct smb_acl) > pntsd_size)) { 1044 rc = -EINVAL; 1045 goto free_parent_pntsd; 1046 } 1047 1048 parent_pdacl = (struct smb_acl *)((char *)parent_pntsd + dacloffset); 1049 acl_len = pntsd_size - dacloffset; 1050 num_aces = le32_to_cpu(parent_pdacl->num_aces); 1051 pntsd_type = le16_to_cpu(parent_pntsd->type); 1052 pdacl_size = le16_to_cpu(parent_pdacl->size); 1053 1054 if (pdacl_size > acl_len || pdacl_size < sizeof(struct smb_acl)) { 1055 rc = -EINVAL; 1056 goto free_parent_pntsd; 1057 } 1058 1059 aces_base = kmalloc(sizeof(struct smb_ace) * num_aces * 2, GFP_KERNEL); 1060 if (!aces_base) { 1061 rc = -ENOMEM; 1062 goto free_parent_pntsd; 1063 } 1064 1065 aces = (struct smb_ace *)aces_base; 1066 parent_aces = (struct smb_ace *)((char *)parent_pdacl + 1067 sizeof(struct smb_acl)); 1068 aces_size = acl_len - sizeof(struct smb_acl); 1069 1070 if (pntsd_type & DACL_AUTO_INHERITED) 1071 inherited_flags = INHERITED_ACE; 1072 1073 for (i = 0; i < num_aces; i++) { 1074 int pace_size; 1075 1076 if (offsetof(struct smb_ace, access_req) > aces_size) 1077 break; 1078 1079 pace_size = le16_to_cpu(parent_aces->size); 1080 if (pace_size > aces_size) 1081 break; 1082 1083 aces_size -= pace_size; 1084 1085 flags = parent_aces->flags; 1086 if (!smb_inherit_flags(flags, is_dir)) 1087 goto pass; 1088 if (is_dir) { 1089 flags &= ~(INHERIT_ONLY_ACE | INHERITED_ACE); 1090 if (!(flags & CONTAINER_INHERIT_ACE)) 1091 flags |= INHERIT_ONLY_ACE; 1092 if (flags & NO_PROPAGATE_INHERIT_ACE) 1093 flags = 0; 1094 } else { 1095 flags = 0; 1096 } 1097 1098 if (!compare_sids(&creator_owner, &parent_aces->sid)) { 1099 creator = &creator_owner; 1100 id_to_sid(uid, SIDOWNER, &owner_sid); 1101 psid = &owner_sid; 1102 } else if (!compare_sids(&creator_group, &parent_aces->sid)) { 1103 creator = &creator_group; 1104 id_to_sid(gid, SIDUNIX_GROUP, &group_sid); 1105 psid = &group_sid; 1106 } else { 1107 creator = NULL; 1108 psid = &parent_aces->sid; 1109 } 1110 1111 if (is_dir && creator && flags & CONTAINER_INHERIT_ACE) { 1112 smb_set_ace(aces, psid, parent_aces->type, inherited_flags, 1113 parent_aces->access_req); 1114 nt_size += le16_to_cpu(aces->size); 1115 ace_cnt++; 1116 aces = (struct smb_ace *)((char *)aces + le16_to_cpu(aces->size)); 1117 flags |= INHERIT_ONLY_ACE; 1118 psid = creator; 1119 } else if (is_dir && !(parent_aces->flags & NO_PROPAGATE_INHERIT_ACE)) { 1120 psid = &parent_aces->sid; 1121 } 1122 1123 smb_set_ace(aces, psid, parent_aces->type, flags | inherited_flags, 1124 parent_aces->access_req); 1125 nt_size += le16_to_cpu(aces->size); 1126 aces = (struct smb_ace *)((char *)aces + le16_to_cpu(aces->size)); 1127 ace_cnt++; 1128 pass: 1129 parent_aces = (struct smb_ace *)((char *)parent_aces + pace_size); 1130 } 1131 1132 if (nt_size > 0) { 1133 struct smb_ntsd *pntsd; 1134 struct smb_acl *pdacl; 1135 struct smb_sid *powner_sid = NULL, *pgroup_sid = NULL; 1136 int powner_sid_size = 0, pgroup_sid_size = 0, pntsd_size; 1137 int pntsd_alloc_size; 1138 1139 if (parent_pntsd->osidoffset) { 1140 powner_sid = (struct smb_sid *)((char *)parent_pntsd + 1141 le32_to_cpu(parent_pntsd->osidoffset)); 1142 powner_sid_size = 1 + 1 + 6 + (powner_sid->num_subauth * 4); 1143 } 1144 if (parent_pntsd->gsidoffset) { 1145 pgroup_sid = (struct smb_sid *)((char *)parent_pntsd + 1146 le32_to_cpu(parent_pntsd->gsidoffset)); 1147 pgroup_sid_size = 1 + 1 + 6 + (pgroup_sid->num_subauth * 4); 1148 } 1149 1150 pntsd_alloc_size = sizeof(struct smb_ntsd) + powner_sid_size + 1151 pgroup_sid_size + sizeof(struct smb_acl) + nt_size; 1152 1153 pntsd = kzalloc(pntsd_alloc_size, GFP_KERNEL); 1154 if (!pntsd) { 1155 rc = -ENOMEM; 1156 goto free_aces_base; 1157 } 1158 1159 pntsd->revision = cpu_to_le16(1); 1160 pntsd->type = cpu_to_le16(SELF_RELATIVE | DACL_PRESENT); 1161 if (le16_to_cpu(parent_pntsd->type) & DACL_AUTO_INHERITED) 1162 pntsd->type |= cpu_to_le16(DACL_AUTO_INHERITED); 1163 pntsd_size = sizeof(struct smb_ntsd); 1164 pntsd->osidoffset = parent_pntsd->osidoffset; 1165 pntsd->gsidoffset = parent_pntsd->gsidoffset; 1166 pntsd->dacloffset = parent_pntsd->dacloffset; 1167 1168 if ((u64)le32_to_cpu(pntsd->osidoffset) + powner_sid_size > 1169 pntsd_alloc_size) { 1170 rc = -EINVAL; 1171 kfree(pntsd); 1172 goto free_aces_base; 1173 } 1174 1175 if ((u64)le32_to_cpu(pntsd->gsidoffset) + pgroup_sid_size > 1176 pntsd_alloc_size) { 1177 rc = -EINVAL; 1178 kfree(pntsd); 1179 goto free_aces_base; 1180 } 1181 1182 if ((u64)le32_to_cpu(pntsd->dacloffset) + sizeof(struct smb_acl) + nt_size > 1183 pntsd_alloc_size) { 1184 rc = -EINVAL; 1185 kfree(pntsd); 1186 goto free_aces_base; 1187 } 1188 1189 if (pntsd->osidoffset) { 1190 struct smb_sid *owner_sid = (struct smb_sid *)((char *)pntsd + 1191 le32_to_cpu(pntsd->osidoffset)); 1192 memcpy(owner_sid, powner_sid, powner_sid_size); 1193 pntsd_size += powner_sid_size; 1194 } 1195 1196 if (pntsd->gsidoffset) { 1197 struct smb_sid *group_sid = (struct smb_sid *)((char *)pntsd + 1198 le32_to_cpu(pntsd->gsidoffset)); 1199 memcpy(group_sid, pgroup_sid, pgroup_sid_size); 1200 pntsd_size += pgroup_sid_size; 1201 } 1202 1203 if (pntsd->dacloffset) { 1204 struct smb_ace *pace; 1205 1206 pdacl = (struct smb_acl *)((char *)pntsd + le32_to_cpu(pntsd->dacloffset)); 1207 pdacl->revision = cpu_to_le16(2); 1208 pdacl->size = cpu_to_le16(sizeof(struct smb_acl) + nt_size); 1209 pdacl->num_aces = cpu_to_le32(ace_cnt); 1210 pace = (struct smb_ace *)((char *)pdacl + sizeof(struct smb_acl)); 1211 memcpy(pace, aces_base, nt_size); 1212 pntsd_size += sizeof(struct smb_acl) + nt_size; 1213 } 1214 1215 ksmbd_vfs_set_sd_xattr(conn, idmap, path, pntsd, pntsd_size, false); 1216 kfree(pntsd); 1217 } 1218 1219 free_aces_base: 1220 kfree(aces_base); 1221 free_parent_pntsd: 1222 kfree(parent_pntsd); 1223 return rc; 1224 } 1225 1226 bool smb_inherit_flags(int flags, bool is_dir) 1227 { 1228 if (!is_dir) 1229 return (flags & OBJECT_INHERIT_ACE) != 0; 1230 1231 if (flags & OBJECT_INHERIT_ACE && !(flags & NO_PROPAGATE_INHERIT_ACE)) 1232 return true; 1233 1234 if (flags & CONTAINER_INHERIT_ACE) 1235 return true; 1236 return false; 1237 } 1238 1239 int smb_check_perm_dacl(struct ksmbd_conn *conn, const struct path *path, 1240 __le32 *pdaccess, int uid) 1241 { 1242 struct mnt_idmap *idmap = mnt_idmap(path->mnt); 1243 struct smb_ntsd *pntsd = NULL; 1244 struct smb_acl *pdacl; 1245 struct posix_acl *posix_acls; 1246 int rc = 0, pntsd_size, acl_size, aces_size, pdacl_size, dacl_offset; 1247 struct smb_sid sid; 1248 int granted = le32_to_cpu(*pdaccess & ~FILE_MAXIMAL_ACCESS_LE); 1249 struct smb_ace *ace; 1250 int i, found = 0; 1251 unsigned int access_bits = 0; 1252 struct smb_ace *others_ace = NULL; 1253 struct posix_acl_entry *pa_entry; 1254 unsigned int sid_type = SIDOWNER; 1255 unsigned short ace_size; 1256 1257 ksmbd_debug(SMB, "check permission using windows acl\n"); 1258 pntsd_size = ksmbd_vfs_get_sd_xattr(conn, idmap, 1259 path->dentry, &pntsd); 1260 if (pntsd_size <= 0 || !pntsd) 1261 goto err_out; 1262 1263 dacl_offset = le32_to_cpu(pntsd->dacloffset); 1264 if (!dacl_offset || 1265 (dacl_offset + sizeof(struct smb_acl) > pntsd_size)) 1266 goto err_out; 1267 1268 pdacl = (struct smb_acl *)((char *)pntsd + le32_to_cpu(pntsd->dacloffset)); 1269 acl_size = pntsd_size - dacl_offset; 1270 pdacl_size = le16_to_cpu(pdacl->size); 1271 1272 if (pdacl_size > acl_size || pdacl_size < sizeof(struct smb_acl)) 1273 goto err_out; 1274 1275 if (!pdacl->num_aces) { 1276 if (!(pdacl_size - sizeof(struct smb_acl)) && 1277 *pdaccess & ~(FILE_READ_CONTROL_LE | FILE_WRITE_DAC_LE)) { 1278 rc = -EACCES; 1279 goto err_out; 1280 } 1281 goto err_out; 1282 } 1283 1284 if (*pdaccess & FILE_MAXIMAL_ACCESS_LE) { 1285 granted = READ_CONTROL | WRITE_DAC | FILE_READ_ATTRIBUTES | 1286 DELETE; 1287 1288 ace = (struct smb_ace *)((char *)pdacl + sizeof(struct smb_acl)); 1289 aces_size = acl_size - sizeof(struct smb_acl); 1290 for (i = 0; i < le32_to_cpu(pdacl->num_aces); i++) { 1291 if (offsetof(struct smb_ace, access_req) > aces_size) 1292 break; 1293 ace_size = le16_to_cpu(ace->size); 1294 if (ace_size > aces_size) 1295 break; 1296 aces_size -= ace_size; 1297 granted |= le32_to_cpu(ace->access_req); 1298 ace = (struct smb_ace *)((char *)ace + le16_to_cpu(ace->size)); 1299 } 1300 1301 if (!pdacl->num_aces) 1302 granted = GENERIC_ALL_FLAGS; 1303 } 1304 1305 if (!uid) 1306 sid_type = SIDUNIX_USER; 1307 id_to_sid(uid, sid_type, &sid); 1308 1309 ace = (struct smb_ace *)((char *)pdacl + sizeof(struct smb_acl)); 1310 aces_size = acl_size - sizeof(struct smb_acl); 1311 for (i = 0; i < le32_to_cpu(pdacl->num_aces); i++) { 1312 if (offsetof(struct smb_ace, access_req) > aces_size) 1313 break; 1314 ace_size = le16_to_cpu(ace->size); 1315 if (ace_size > aces_size) 1316 break; 1317 aces_size -= ace_size; 1318 1319 if (!compare_sids(&sid, &ace->sid) || 1320 !compare_sids(&sid_unix_NFS_mode, &ace->sid)) { 1321 found = 1; 1322 break; 1323 } 1324 if (!compare_sids(&sid_everyone, &ace->sid)) 1325 others_ace = ace; 1326 1327 ace = (struct smb_ace *)((char *)ace + le16_to_cpu(ace->size)); 1328 } 1329 1330 if (*pdaccess & FILE_MAXIMAL_ACCESS_LE && found) { 1331 granted = READ_CONTROL | WRITE_DAC | FILE_READ_ATTRIBUTES | 1332 DELETE; 1333 1334 granted |= le32_to_cpu(ace->access_req); 1335 1336 if (!pdacl->num_aces) 1337 granted = GENERIC_ALL_FLAGS; 1338 } 1339 1340 if (IS_ENABLED(CONFIG_FS_POSIX_ACL)) { 1341 posix_acls = get_inode_acl(d_inode(path->dentry), ACL_TYPE_ACCESS); 1342 if (!IS_ERR_OR_NULL(posix_acls) && !found) { 1343 unsigned int id = -1; 1344 1345 pa_entry = posix_acls->a_entries; 1346 for (i = 0; i < posix_acls->a_count; i++, pa_entry++) { 1347 if (pa_entry->e_tag == ACL_USER) 1348 id = posix_acl_uid_translate(idmap, pa_entry); 1349 else if (pa_entry->e_tag == ACL_GROUP) 1350 id = posix_acl_gid_translate(idmap, pa_entry); 1351 else 1352 continue; 1353 1354 if (id == uid) { 1355 mode_to_access_flags(pa_entry->e_perm, 1356 0777, 1357 &access_bits); 1358 if (!access_bits) 1359 access_bits = 1360 SET_MINIMUM_RIGHTS; 1361 posix_acl_release(posix_acls); 1362 goto check_access_bits; 1363 } 1364 } 1365 } 1366 if (!IS_ERR_OR_NULL(posix_acls)) 1367 posix_acl_release(posix_acls); 1368 } 1369 1370 if (!found) { 1371 if (others_ace) { 1372 ace = others_ace; 1373 } else { 1374 ksmbd_debug(SMB, "Can't find corresponding sid\n"); 1375 rc = -EACCES; 1376 goto err_out; 1377 } 1378 } 1379 1380 switch (ace->type) { 1381 case ACCESS_ALLOWED_ACE_TYPE: 1382 access_bits = le32_to_cpu(ace->access_req); 1383 break; 1384 case ACCESS_DENIED_ACE_TYPE: 1385 case ACCESS_DENIED_CALLBACK_ACE_TYPE: 1386 access_bits = le32_to_cpu(~ace->access_req); 1387 break; 1388 } 1389 1390 check_access_bits: 1391 if (granted & 1392 ~(access_bits | FILE_READ_ATTRIBUTES | READ_CONTROL | WRITE_DAC | DELETE)) { 1393 ksmbd_debug(SMB, "Access denied with winACL, granted : %x, access_req : %x\n", 1394 granted, le32_to_cpu(ace->access_req)); 1395 rc = -EACCES; 1396 goto err_out; 1397 } 1398 1399 *pdaccess = cpu_to_le32(granted); 1400 err_out: 1401 kfree(pntsd); 1402 return rc; 1403 } 1404 1405 int set_info_sec(struct ksmbd_conn *conn, struct ksmbd_tree_connect *tcon, 1406 const struct path *path, struct smb_ntsd *pntsd, int ntsd_len, 1407 bool type_check, bool get_write) 1408 { 1409 int rc; 1410 struct smb_fattr fattr = {{0}}; 1411 struct inode *inode = d_inode(path->dentry); 1412 struct mnt_idmap *idmap = mnt_idmap(path->mnt); 1413 struct iattr newattrs; 1414 1415 fattr.cf_uid = INVALID_UID; 1416 fattr.cf_gid = INVALID_GID; 1417 fattr.cf_mode = inode->i_mode; 1418 1419 rc = parse_sec_desc(idmap, pntsd, ntsd_len, &fattr); 1420 if (rc) 1421 goto out; 1422 1423 newattrs.ia_valid = ATTR_CTIME; 1424 if (!uid_eq(fattr.cf_uid, INVALID_UID)) { 1425 newattrs.ia_valid |= ATTR_UID; 1426 newattrs.ia_uid = fattr.cf_uid; 1427 } 1428 if (!gid_eq(fattr.cf_gid, INVALID_GID)) { 1429 newattrs.ia_valid |= ATTR_GID; 1430 newattrs.ia_gid = fattr.cf_gid; 1431 } 1432 newattrs.ia_valid |= ATTR_MODE; 1433 newattrs.ia_mode = (inode->i_mode & ~0777) | (fattr.cf_mode & 0777); 1434 1435 ksmbd_vfs_remove_acl_xattrs(idmap, path); 1436 /* Update posix acls */ 1437 if (IS_ENABLED(CONFIG_FS_POSIX_ACL) && fattr.cf_dacls) { 1438 rc = set_posix_acl(idmap, path->dentry, 1439 ACL_TYPE_ACCESS, fattr.cf_acls); 1440 if (rc < 0) 1441 ksmbd_debug(SMB, 1442 "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n", 1443 rc); 1444 if (S_ISDIR(inode->i_mode) && fattr.cf_dacls) { 1445 rc = set_posix_acl(idmap, path->dentry, 1446 ACL_TYPE_DEFAULT, fattr.cf_dacls); 1447 if (rc) 1448 ksmbd_debug(SMB, 1449 "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n", 1450 rc); 1451 } 1452 } 1453 1454 inode_lock(inode); 1455 rc = notify_change(idmap, path->dentry, &newattrs, NULL); 1456 inode_unlock(inode); 1457 if (rc) 1458 goto out; 1459 1460 /* Check it only calling from SD BUFFER context */ 1461 if (type_check && !(le16_to_cpu(pntsd->type) & DACL_PRESENT)) 1462 goto out; 1463 1464 if (test_share_config_flag(tcon->share_conf, KSMBD_SHARE_FLAG_ACL_XATTR)) { 1465 /* Update WinACL in xattr */ 1466 ksmbd_vfs_remove_sd_xattrs(idmap, path); 1467 ksmbd_vfs_set_sd_xattr(conn, idmap, path, pntsd, ntsd_len, 1468 get_write); 1469 } 1470 1471 out: 1472 posix_acl_release(fattr.cf_acls); 1473 posix_acl_release(fattr.cf_dacls); 1474 return rc; 1475 } 1476 1477 void ksmbd_init_domain(u32 *sub_auth) 1478 { 1479 int i; 1480 1481 memcpy(&server_conf.domain_sid, &domain, sizeof(struct smb_sid)); 1482 for (i = 0; i < 3; ++i) 1483 server_conf.domain_sid.sub_auth[i + 1] = cpu_to_le32(sub_auth[i]); 1484 } 1485