smbacl.c

   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
  20static 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 */
  25static const struct smb_sid creator_owner = {
  26	1, 1, {0, 0, 0, 0, 0, 3}, {0} };
  27/* security id for everyone/world system group */
  28static 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 */
  32static const struct smb_sid sid_everyone = {
  33	1, 1, {0, 0, 0, 0, 0, 1}, {0} };
  34/* security id for Authenticated Users system group */
  35static 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 */
  39static 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 */
  43static 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 */
  53static 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 */
  58static 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 */
  63static 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 */
  71int 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
 116static 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 */
 133static 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 */
 168static 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
 193static __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
 221void 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
 257static 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
 305void 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
 341int init_acl_state(struct posix_acl_state *state, u16 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, KSMBD_DEFAULT_GFP);
 354	if (!state->users)
 355		return -ENOMEM;
 356	state->groups = kzalloc(alloc, KSMBD_DEFAULT_GFP);
 357	if (!state->groups) {
 358		kfree(state->users);
 359		return -ENOMEM;
 360	}
 361	return 0;
 362}
 363
 364void free_acl_state(struct posix_acl_state *state)
 365{
 366	kfree(state->users);
 367	kfree(state->groups);
 368}
 369
 370static 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	u16 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		    le16_to_cpu(pdacl->num_aces));
 398
 399	acl_base = (char *)pdacl;
 400	acl_size = sizeof(struct smb_acl);
 401
 402	num_aces = le16_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 *), KSMBD_DEFAULT_GFP);
 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 (ppace[i]->sid.num_subauth >= 3 &&
 455		    !(compare_sids(&ppace[i]->sid, &sid_unix_NFS_mode))) {
 456			fattr->cf_mode =
 457				le32_to_cpu(ppace[i]->sid.sub_auth[2]);
 458			break;
 459		} else if (!compare_sids(&ppace[i]->sid, pownersid)) {
 460			acl_mode = access_flags_to_mode(fattr,
 461							ppace[i]->access_req,
 462							ppace[i]->type);
 463			acl_mode &= 0700;
 464
 465			if (!owner_found) {
 466				mode &= ~(0700);
 467				mode |= acl_mode;
 468			}
 469			owner_found = true;
 470		} else if (!compare_sids(&ppace[i]->sid, pgrpsid) ||
 471			   ppace[i]->sid.sub_auth[ppace[i]->sid.num_subauth - 1] ==
 472			    DOMAIN_USER_RID_LE) {
 473			acl_mode = access_flags_to_mode(fattr,
 474							ppace[i]->access_req,
 475							ppace[i]->type);
 476			acl_mode &= 0070;
 477			if (!group_found) {
 478				mode &= ~(0070);
 479				mode |= acl_mode;
 480			}
 481			group_found = true;
 482		} else if (!compare_sids(&ppace[i]->sid, &sid_everyone)) {
 483			acl_mode = access_flags_to_mode(fattr,
 484							ppace[i]->access_req,
 485							ppace[i]->type);
 486			acl_mode &= 0007;
 487			if (!others_found) {
 488				mode &= ~(0007);
 489				mode |= acl_mode;
 490			}
 491			others_found = true;
 492		} else if (!compare_sids(&ppace[i]->sid, &creator_owner)) {
 493			continue;
 494		} else if (!compare_sids(&ppace[i]->sid, &creator_group)) {
 495			continue;
 496		} else if (!compare_sids(&ppace[i]->sid, &sid_authusers)) {
 497			continue;
 498		} else {
 499			struct smb_fattr temp_fattr;
 500
 501			acl_mode = access_flags_to_mode(fattr, ppace[i]->access_req,
 502							ppace[i]->type);
 503			temp_fattr.cf_uid = INVALID_UID;
 504			ret = sid_to_id(idmap, &ppace[i]->sid, SIDOWNER, &temp_fattr);
 505			if (ret || uid_eq(temp_fattr.cf_uid, INVALID_UID)) {
 506				pr_err("%s: Error %d mapping Owner SID to uid\n",
 507				       __func__, ret);
 508				continue;
 509			}
 510
 511			acl_state.owner.allow = ((acl_mode & 0700) >> 6) | 0004;
 512			acl_state.users->aces[acl_state.users->n].uid =
 513				temp_fattr.cf_uid;
 514			acl_state.users->aces[acl_state.users->n++].perms.allow =
 515				((acl_mode & 0700) >> 6) | 0004;
 516			default_acl_state.owner.allow = ((acl_mode & 0700) >> 6) | 0004;
 517			default_acl_state.users->aces[default_acl_state.users->n].uid =
 518				temp_fattr.cf_uid;
 519			default_acl_state.users->aces[default_acl_state.users->n++].perms.allow =
 520				((acl_mode & 0700) >> 6) | 0004;
 521		}
 522	}
 523	kfree(ppace);
 524
 525	if (owner_found) {
 526		/* The owner must be set to at least read-only. */
 527		acl_state.owner.allow = ((mode & 0700) >> 6) | 0004;
 528		acl_state.users->aces[acl_state.users->n].uid = fattr->cf_uid;
 529		acl_state.users->aces[acl_state.users->n++].perms.allow =
 530			((mode & 0700) >> 6) | 0004;
 531		default_acl_state.owner.allow = ((mode & 0700) >> 6) | 0004;
 532		default_acl_state.users->aces[default_acl_state.users->n].uid =
 533			fattr->cf_uid;
 534		default_acl_state.users->aces[default_acl_state.users->n++].perms.allow =
 535			((mode & 0700) >> 6) | 0004;
 536	}
 537
 538	if (group_found) {
 539		acl_state.group.allow = (mode & 0070) >> 3;
 540		acl_state.groups->aces[acl_state.groups->n].gid =
 541			fattr->cf_gid;
 542		acl_state.groups->aces[acl_state.groups->n++].perms.allow =
 543			(mode & 0070) >> 3;
 544		default_acl_state.group.allow = (mode & 0070) >> 3;
 545		default_acl_state.groups->aces[default_acl_state.groups->n].gid =
 546			fattr->cf_gid;
 547		default_acl_state.groups->aces[default_acl_state.groups->n++].perms.allow =
 548			(mode & 0070) >> 3;
 549	}
 550
 551	if (others_found) {
 552		fattr->cf_mode &= ~(0007);
 553		fattr->cf_mode |= mode & 0007;
 554
 555		acl_state.other.allow = mode & 0007;
 556		default_acl_state.other.allow = mode & 0007;
 557	}
 558
 559	if (acl_state.users->n || acl_state.groups->n) {
 560		acl_state.mask.allow = 0x07;
 561
 562		if (IS_ENABLED(CONFIG_FS_POSIX_ACL)) {
 563			fattr->cf_acls =
 564				posix_acl_alloc(acl_state.users->n +
 565					acl_state.groups->n + 4, KSMBD_DEFAULT_GFP);
 566			if (fattr->cf_acls) {
 567				cf_pace = fattr->cf_acls->a_entries;
 568				posix_state_to_acl(&acl_state, cf_pace);
 569			}
 570		}
 571	}
 572
 573	if (default_acl_state.users->n || default_acl_state.groups->n) {
 574		default_acl_state.mask.allow = 0x07;
 575
 576		if (IS_ENABLED(CONFIG_FS_POSIX_ACL)) {
 577			fattr->cf_dacls =
 578				posix_acl_alloc(default_acl_state.users->n +
 579				default_acl_state.groups->n + 4, KSMBD_DEFAULT_GFP);
 580			if (fattr->cf_dacls) {
 581				cf_pdace = fattr->cf_dacls->a_entries;
 582				posix_state_to_acl(&default_acl_state, cf_pdace);
 583			}
 584		}
 585	}
 586	free_acl_state(&acl_state);
 587	free_acl_state(&default_acl_state);
 588}
 589
 590static void set_posix_acl_entries_dacl(struct mnt_idmap *idmap,
 591				       struct smb_ace *pndace,
 592				       struct smb_fattr *fattr, u16 *num_aces,
 593				       u16 *size, u32 nt_aces_num)
 594{
 595	struct posix_acl_entry *pace;
 596	struct smb_sid *sid;
 597	struct smb_ace *ntace;
 598	int i, j;
 599
 600	if (!fattr->cf_acls)
 601		goto posix_default_acl;
 602
 603	pace = fattr->cf_acls->a_entries;
 604	for (i = 0; i < fattr->cf_acls->a_count; i++, pace++) {
 605		int flags = 0;
 606
 607		sid = kmalloc(sizeof(struct smb_sid), KSMBD_DEFAULT_GFP);
 608		if (!sid)
 609			break;
 610
 611		if (pace->e_tag == ACL_USER) {
 612			uid_t uid;
 613			unsigned int sid_type = SIDOWNER;
 614
 615			uid = posix_acl_uid_translate(idmap, pace);
 616			if (!uid)
 617				sid_type = SIDUNIX_USER;
 618			id_to_sid(uid, sid_type, sid);
 619		} else if (pace->e_tag == ACL_GROUP) {
 620			gid_t gid;
 621
 622			gid = posix_acl_gid_translate(idmap, pace);
 623			id_to_sid(gid, SIDUNIX_GROUP, sid);
 624		} else if (pace->e_tag == ACL_OTHER && !nt_aces_num) {
 625			smb_copy_sid(sid, &sid_everyone);
 626		} else {
 627			kfree(sid);
 628			continue;
 629		}
 630		ntace = pndace;
 631		for (j = 0; j < nt_aces_num; j++) {
 632			if (ntace->sid.sub_auth[ntace->sid.num_subauth - 1] ==
 633					sid->sub_auth[sid->num_subauth - 1])
 634				goto pass_same_sid;
 635			ntace = (struct smb_ace *)((char *)ntace +
 636					le16_to_cpu(ntace->size));
 637		}
 638
 639		if (S_ISDIR(fattr->cf_mode) && pace->e_tag == ACL_OTHER)
 640			flags = 0x03;
 641
 642		ntace = (struct smb_ace *)((char *)pndace + *size);
 643		*size += fill_ace_for_sid(ntace, sid, ACCESS_ALLOWED, flags,
 644				pace->e_perm, 0777);
 645		(*num_aces)++;
 646		if (pace->e_tag == ACL_USER)
 647			ntace->access_req |=
 648				FILE_DELETE_LE | FILE_DELETE_CHILD_LE;
 649
 650		if (S_ISDIR(fattr->cf_mode) &&
 651		    (pace->e_tag == ACL_USER || pace->e_tag == ACL_GROUP)) {
 652			ntace = (struct smb_ace *)((char *)pndace + *size);
 653			*size += fill_ace_for_sid(ntace, sid, ACCESS_ALLOWED,
 654					0x03, pace->e_perm, 0777);
 655			(*num_aces)++;
 656			if (pace->e_tag == ACL_USER)
 657				ntace->access_req |=
 658					FILE_DELETE_LE | FILE_DELETE_CHILD_LE;
 659		}
 660
 661pass_same_sid:
 662		kfree(sid);
 663	}
 664
 665	if (nt_aces_num)
 666		return;
 667
 668posix_default_acl:
 669	if (!fattr->cf_dacls)
 670		return;
 671
 672	pace = fattr->cf_dacls->a_entries;
 673	for (i = 0; i < fattr->cf_dacls->a_count; i++, pace++) {
 674		sid = kmalloc(sizeof(struct smb_sid), KSMBD_DEFAULT_GFP);
 675		if (!sid)
 676			break;
 677
 678		if (pace->e_tag == ACL_USER) {
 679			uid_t uid;
 680
 681			uid = posix_acl_uid_translate(idmap, pace);
 682			id_to_sid(uid, SIDCREATOR_OWNER, sid);
 683		} else if (pace->e_tag == ACL_GROUP) {
 684			gid_t gid;
 685
 686			gid = posix_acl_gid_translate(idmap, pace);
 687			id_to_sid(gid, SIDCREATOR_GROUP, sid);
 688		} else {
 689			kfree(sid);
 690			continue;
 691		}
 692
 693		ntace = (struct smb_ace *)((char *)pndace + *size);
 694		*size += fill_ace_for_sid(ntace, sid, ACCESS_ALLOWED, 0x0b,
 695				pace->e_perm, 0777);
 696		(*num_aces)++;
 697		if (pace->e_tag == ACL_USER)
 698			ntace->access_req |=
 699				FILE_DELETE_LE | FILE_DELETE_CHILD_LE;
 700		kfree(sid);
 701	}
 702}
 703
 704static void set_ntacl_dacl(struct mnt_idmap *idmap,
 705			   struct smb_acl *pndacl,
 706			   struct smb_acl *nt_dacl,
 707			   unsigned int aces_size,
 708			   const struct smb_sid *pownersid,
 709			   const struct smb_sid *pgrpsid,
 710			   struct smb_fattr *fattr)
 711{
 712	struct smb_ace *ntace, *pndace;
 713	u16 nt_num_aces = le16_to_cpu(nt_dacl->num_aces), num_aces = 0;
 714	unsigned short size = 0;
 715	int i;
 716
 717	pndace = (struct smb_ace *)((char *)pndacl + sizeof(struct smb_acl));
 718	if (nt_num_aces) {
 719		ntace = (struct smb_ace *)((char *)nt_dacl + sizeof(struct smb_acl));
 720		for (i = 0; i < nt_num_aces; i++) {
 721			unsigned short nt_ace_size;
 722
 723			if (offsetof(struct smb_ace, access_req) > aces_size)
 724				break;
 725
 726			nt_ace_size = le16_to_cpu(ntace->size);
 727			if (nt_ace_size > aces_size)
 728				break;
 729
 730			memcpy((char *)pndace + size, ntace, nt_ace_size);
 731			size += nt_ace_size;
 732			aces_size -= nt_ace_size;
 733			ntace = (struct smb_ace *)((char *)ntace + nt_ace_size);
 734			num_aces++;
 735		}
 736	}
 737
 738	set_posix_acl_entries_dacl(idmap, pndace, fattr,
 739				   &num_aces, &size, nt_num_aces);
 740	pndacl->num_aces = cpu_to_le16(num_aces);
 741	pndacl->size = cpu_to_le16(le16_to_cpu(pndacl->size) + size);
 742}
 743
 744static void set_mode_dacl(struct mnt_idmap *idmap,
 745			  struct smb_acl *pndacl, struct smb_fattr *fattr)
 746{
 747	struct smb_ace *pace, *pndace;
 748	u16 num_aces = 0;
 749	u16 size = 0, ace_size = 0;
 750	uid_t uid;
 751	const struct smb_sid *sid;
 752
 753	pace = pndace = (struct smb_ace *)((char *)pndacl + sizeof(struct smb_acl));
 754
 755	if (fattr->cf_acls) {
 756		set_posix_acl_entries_dacl(idmap, pndace, fattr,
 757					   &num_aces, &size, num_aces);
 758		goto out;
 759	}
 760
 761	/* owner RID */
 762	uid = from_kuid(&init_user_ns, fattr->cf_uid);
 763	if (uid)
 764		sid = &server_conf.domain_sid;
 765	else
 766		sid = &sid_unix_users;
 767	ace_size = fill_ace_for_sid(pace, sid, ACCESS_ALLOWED, 0,
 768				    fattr->cf_mode, 0700);
 769	pace->sid.sub_auth[pace->sid.num_subauth++] = cpu_to_le32(uid);
 770	pace->size = cpu_to_le16(ace_size + 4);
 771	size += le16_to_cpu(pace->size);
 772	pace = (struct smb_ace *)((char *)pndace + size);
 773
 774	/* Group RID */
 775	ace_size = fill_ace_for_sid(pace, &sid_unix_groups,
 776				    ACCESS_ALLOWED, 0, fattr->cf_mode, 0070);
 777	pace->sid.sub_auth[pace->sid.num_subauth++] =
 778		cpu_to_le32(from_kgid(&init_user_ns, fattr->cf_gid));
 779	pace->size = cpu_to_le16(ace_size + 4);
 780	size += le16_to_cpu(pace->size);
 781	pace = (struct smb_ace *)((char *)pndace + size);
 782	num_aces = 3;
 783
 784	if (S_ISDIR(fattr->cf_mode)) {
 785		pace = (struct smb_ace *)((char *)pndace + size);
 786
 787		/* creator owner */
 788		size += fill_ace_for_sid(pace, &creator_owner, ACCESS_ALLOWED,
 789					 0x0b, fattr->cf_mode, 0700);
 790		pace = (struct smb_ace *)((char *)pndace + size);
 791
 792		/* creator group */
 793		size += fill_ace_for_sid(pace, &creator_group, ACCESS_ALLOWED,
 794					 0x0b, fattr->cf_mode, 0070);
 795		pace = (struct smb_ace *)((char *)pndace + size);
 796		num_aces = 5;
 797	}
 798
 799	/* other */
 800	size += fill_ace_for_sid(pace, &sid_everyone, ACCESS_ALLOWED, 0,
 801				 fattr->cf_mode, 0007);
 802
 803out:
 804	pndacl->num_aces = cpu_to_le16(num_aces);
 805	pndacl->size = cpu_to_le16(le16_to_cpu(pndacl->size) + size);
 806}
 807
 808static int parse_sid(struct smb_sid *psid, char *end_of_acl)
 809{
 810	/*
 811	 * validate that we do not go past end of ACL - sid must be at least 8
 812	 * bytes long (assuming no sub-auths - e.g. the null SID
 813	 */
 814	if (end_of_acl < (char *)psid + 8) {
 815		pr_err("ACL too small to parse SID %p\n", psid);
 816		return -EINVAL;
 817	}
 818
 819	if (!psid->num_subauth)
 820		return 0;
 821
 822	if (psid->num_subauth > SID_MAX_SUB_AUTHORITIES ||
 823	    end_of_acl < (char *)psid + 8 + sizeof(__le32) * psid->num_subauth)
 824		return -EINVAL;
 825
 826	return 0;
 827}
 828
 829/* Convert CIFS ACL to POSIX form */
 830int parse_sec_desc(struct mnt_idmap *idmap, struct smb_ntsd *pntsd,
 831		   int acl_len, struct smb_fattr *fattr)
 832{
 833	int rc = 0;
 834	struct smb_sid *owner_sid_ptr, *group_sid_ptr;
 835	struct smb_acl *dacl_ptr; /* no need for SACL ptr */
 836	char *end_of_acl = ((char *)pntsd) + acl_len;
 837	__u32 dacloffset;
 838	int pntsd_type;
 839
 840	if (!pntsd)
 841		return -EIO;
 842
 843	if (acl_len < sizeof(struct smb_ntsd))
 844		return -EINVAL;
 845
 846	owner_sid_ptr = (struct smb_sid *)((char *)pntsd +
 847			le32_to_cpu(pntsd->osidoffset));
 848	group_sid_ptr = (struct smb_sid *)((char *)pntsd +
 849			le32_to_cpu(pntsd->gsidoffset));
 850	dacloffset = le32_to_cpu(pntsd->dacloffset);
 851	dacl_ptr = (struct smb_acl *)((char *)pntsd + dacloffset);
 852	ksmbd_debug(SMB,
 853		    "revision %d type 0x%x ooffset 0x%x goffset 0x%x sacloffset 0x%x dacloffset 0x%x\n",
 854		    pntsd->revision, pntsd->type, le32_to_cpu(pntsd->osidoffset),
 855		    le32_to_cpu(pntsd->gsidoffset),
 856		    le32_to_cpu(pntsd->sacloffset), dacloffset);
 857
 858	pntsd_type = le16_to_cpu(pntsd->type);
 859	if (!(pntsd_type & DACL_PRESENT)) {
 860		ksmbd_debug(SMB, "DACL_PRESENT in DACL type is not set\n");
 861		return rc;
 862	}
 863
 864	pntsd->type = cpu_to_le16(DACL_PRESENT);
 865
 866	if (pntsd->osidoffset) {
 867		if (le32_to_cpu(pntsd->osidoffset) < sizeof(struct smb_ntsd))
 868			return -EINVAL;
 869
 870		rc = parse_sid(owner_sid_ptr, end_of_acl);
 871		if (rc) {
 872			pr_err("%s: Error %d parsing Owner SID\n", __func__, rc);
 873			return rc;
 874		}
 875
 876		rc = sid_to_id(idmap, owner_sid_ptr, SIDOWNER, fattr);
 877		if (rc) {
 878			pr_err("%s: Error %d mapping Owner SID to uid\n",
 879			       __func__, rc);
 880			owner_sid_ptr = NULL;
 881		}
 882	}
 883
 884	if (pntsd->gsidoffset) {
 885		if (le32_to_cpu(pntsd->gsidoffset) < sizeof(struct smb_ntsd))
 886			return -EINVAL;
 887
 888		rc = parse_sid(group_sid_ptr, end_of_acl);
 889		if (rc) {
 890			pr_err("%s: Error %d mapping Owner SID to gid\n",
 891			       __func__, rc);
 892			return rc;
 893		}
 894		rc = sid_to_id(idmap, group_sid_ptr, SIDUNIX_GROUP, fattr);
 895		if (rc) {
 896			pr_err("%s: Error %d mapping Group SID to gid\n",
 897			       __func__, rc);
 898			group_sid_ptr = NULL;
 899		}
 900	}
 901
 902	if ((pntsd_type & (DACL_AUTO_INHERITED | DACL_AUTO_INHERIT_REQ)) ==
 903	    (DACL_AUTO_INHERITED | DACL_AUTO_INHERIT_REQ))
 904		pntsd->type |= cpu_to_le16(DACL_AUTO_INHERITED);
 905	if (pntsd_type & DACL_PROTECTED)
 906		pntsd->type |= cpu_to_le16(DACL_PROTECTED);
 907
 908	if (dacloffset) {
 909		if (dacloffset < sizeof(struct smb_ntsd))
 910			return -EINVAL;
 911
 912		parse_dacl(idmap, dacl_ptr, end_of_acl,
 913			   owner_sid_ptr, group_sid_ptr, fattr);
 914	}
 915
 916	return 0;
 917}
 918
 919size_t smb_acl_sec_desc_scratch_len(struct smb_fattr *fattr,
 920		struct smb_ntsd *ppntsd, int ppntsd_size, int addition_info)
 921{
 922	size_t len = sizeof(struct smb_ntsd);
 923	size_t tmp;
 924
 925	if (addition_info & OWNER_SECINFO)
 926		len += sizeof(struct smb_sid);
 927	if (addition_info & GROUP_SECINFO)
 928		len += sizeof(struct smb_sid);
 929	if (!(addition_info & DACL_SECINFO))
 930		return len;
 931
 932	len += sizeof(struct smb_acl);
 933	if (ppntsd && ppntsd_size > 0) {
 934		unsigned int dacl_offset = le32_to_cpu(ppntsd->dacloffset);
 935
 936		if (dacl_offset < ppntsd_size &&
 937		    check_add_overflow(len, ppntsd_size - dacl_offset, &len))
 938			return 0;
 939	}
 940
 941	if (fattr->cf_acls) {
 942		if (check_mul_overflow((size_t)fattr->cf_acls->a_count,
 943					2 * sizeof(struct smb_ace), &tmp) ||
 944		    check_add_overflow(len, tmp, &len))
 945			return 0;
 946	} else {
 947		/* default/minimum DACL */
 948		if (check_add_overflow(len, 5 * sizeof(struct smb_ace), &len))
 949			return 0;
 950	}
 951
 952	if (fattr->cf_dacls) {
 953		if (check_mul_overflow((size_t)fattr->cf_dacls->a_count,
 954					sizeof(struct smb_ace), &tmp) ||
 955		    check_add_overflow(len, tmp, &len))
 956			return 0;
 957	}
 958
 959	return len;
 960}
 961
 962/* Convert permission bits from mode to equivalent CIFS ACL */
 963int build_sec_desc(struct mnt_idmap *idmap,
 964		   struct smb_ntsd *pntsd, struct smb_ntsd *ppntsd,
 965		   int ppntsd_size, int addition_info, __u32 *secdesclen,
 966		   struct smb_fattr *fattr)
 967{
 968	int rc = 0;
 969	__u32 offset;
 970	struct smb_sid *owner_sid_ptr, *group_sid_ptr;
 971	struct smb_sid *nowner_sid_ptr, *ngroup_sid_ptr;
 972	struct smb_acl *dacl_ptr = NULL; /* no need for SACL ptr */
 973	uid_t uid;
 974	gid_t gid;
 975	unsigned int sid_type = SIDOWNER;
 976
 977	nowner_sid_ptr = kmalloc(sizeof(struct smb_sid), KSMBD_DEFAULT_GFP);
 978	if (!nowner_sid_ptr)
 979		return -ENOMEM;
 980
 981	uid = from_kuid(&init_user_ns, fattr->cf_uid);
 982	if (!uid)
 983		sid_type = SIDUNIX_USER;
 984	id_to_sid(uid, sid_type, nowner_sid_ptr);
 985
 986	ngroup_sid_ptr = kmalloc(sizeof(struct smb_sid), KSMBD_DEFAULT_GFP);
 987	if (!ngroup_sid_ptr) {
 988		kfree(nowner_sid_ptr);
 989		return -ENOMEM;
 990	}
 991
 992	gid = from_kgid(&init_user_ns, fattr->cf_gid);
 993	id_to_sid(gid, SIDUNIX_GROUP, ngroup_sid_ptr);
 994
 995	offset = sizeof(struct smb_ntsd);
 996	pntsd->sacloffset = 0;
 997	pntsd->revision = cpu_to_le16(1);
 998	pntsd->type = cpu_to_le16(SELF_RELATIVE);
 999	if (ppntsd)
1000		pntsd->type |= ppntsd->type;
1001
1002	if (addition_info & OWNER_SECINFO) {
1003		pntsd->osidoffset = cpu_to_le32(offset);
1004		owner_sid_ptr = (struct smb_sid *)((char *)pntsd + offset);
1005		smb_copy_sid(owner_sid_ptr, nowner_sid_ptr);
1006		offset += 1 + 1 + 6 + (nowner_sid_ptr->num_subauth * 4);
1007	}
1008
1009	if (addition_info & GROUP_SECINFO) {
1010		pntsd->gsidoffset = cpu_to_le32(offset);
1011		group_sid_ptr = (struct smb_sid *)((char *)pntsd + offset);
1012		smb_copy_sid(group_sid_ptr, ngroup_sid_ptr);
1013		offset += 1 + 1 + 6 + (ngroup_sid_ptr->num_subauth * 4);
1014	}
1015
1016	if (addition_info & DACL_SECINFO) {
1017		pntsd->type |= cpu_to_le16(DACL_PRESENT);
1018		dacl_ptr = (struct smb_acl *)((char *)pntsd + offset);
1019		dacl_ptr->revision = cpu_to_le16(2);
1020		dacl_ptr->size = cpu_to_le16(sizeof(struct smb_acl));
1021		dacl_ptr->num_aces = 0;
1022
1023		if (!ppntsd) {
1024			set_mode_dacl(idmap, dacl_ptr, fattr);
1025		} else {
1026			struct smb_acl *ppdacl_ptr;
1027			unsigned int dacl_offset = le32_to_cpu(ppntsd->dacloffset);
1028			int ppdacl_size, ntacl_size = ppntsd_size - dacl_offset;
1029
1030			if (!dacl_offset ||
1031			    (dacl_offset + sizeof(struct smb_acl) > ppntsd_size))
1032				goto out;
1033
1034			ppdacl_ptr = (struct smb_acl *)((char *)ppntsd + dacl_offset);
1035			ppdacl_size = le16_to_cpu(ppdacl_ptr->size);
1036			if (ppdacl_size > ntacl_size ||
1037			    ppdacl_size < sizeof(struct smb_acl))
1038				goto out;
1039
1040			set_ntacl_dacl(idmap, dacl_ptr, ppdacl_ptr,
1041				       ntacl_size - sizeof(struct smb_acl),
1042				       nowner_sid_ptr, ngroup_sid_ptr,
1043				       fattr);
1044		}
1045		pntsd->dacloffset = cpu_to_le32(offset);
1046		offset += le16_to_cpu(dacl_ptr->size);
1047	}
1048
1049out:
1050	kfree(nowner_sid_ptr);
1051	kfree(ngroup_sid_ptr);
1052	*secdesclen = offset;
1053	return rc;
1054}
1055
1056static void smb_set_ace(struct smb_ace *ace, const struct smb_sid *sid, u8 type,
1057			u8 flags, __le32 access_req)
1058{
1059	ace->type = type;
1060	ace->flags = flags;
1061	ace->access_req = access_req;
1062	smb_copy_sid(&ace->sid, sid);
1063	ace->size = cpu_to_le16(1 + 1 + 2 + 4 + 1 + 1 + 6 + (sid->num_subauth * 4));
1064}
1065
1066int smb_inherit_dacl(struct ksmbd_conn *conn,
1067		     const struct path *path,
1068		     unsigned int uid, unsigned int gid)
1069{
1070	const struct smb_sid *psid, *creator = NULL;
1071	struct smb_ace *parent_aces, *aces;
1072	struct smb_acl *parent_pdacl;
1073	struct smb_ntsd *parent_pntsd = NULL;
1074	struct smb_sid owner_sid, group_sid;
1075	struct dentry *parent = path->dentry->d_parent;
1076	struct mnt_idmap *idmap = mnt_idmap(path->mnt);
1077	int inherited_flags = 0, flags = 0, i, nt_size = 0, pdacl_size;
1078	int rc = 0, pntsd_type, pntsd_size, acl_len, aces_size;
1079	unsigned int dacloffset;
1080	size_t dacl_struct_end;
1081	u16 num_aces, ace_cnt = 0;
1082	char *aces_base;
1083	bool is_dir = S_ISDIR(d_inode(path->dentry)->i_mode);
1084
1085	pntsd_size = ksmbd_vfs_get_sd_xattr(conn, idmap,
1086					    parent, &parent_pntsd);
1087	if (pntsd_size <= 0)
1088		return -ENOENT;
1089
1090	dacloffset = le32_to_cpu(parent_pntsd->dacloffset);
1091	if (!dacloffset ||
1092	    check_add_overflow(dacloffset, sizeof(struct smb_acl), &dacl_struct_end) ||
1093	    dacl_struct_end > (size_t)pntsd_size) {
1094		rc = -EINVAL;
1095		goto free_parent_pntsd;
1096	}
1097
1098	parent_pdacl = (struct smb_acl *)((char *)parent_pntsd + dacloffset);
1099	acl_len = pntsd_size - dacloffset;
1100	num_aces = le16_to_cpu(parent_pdacl->num_aces);
1101	pntsd_type = le16_to_cpu(parent_pntsd->type);
1102	pdacl_size = le16_to_cpu(parent_pdacl->size);
1103
1104	if (pdacl_size > acl_len || pdacl_size < sizeof(struct smb_acl)) {
1105		rc = -EINVAL;
1106		goto free_parent_pntsd;
1107	}
1108
1109	aces_base = kmalloc(sizeof(struct smb_ace) * num_aces * 2,
1110			    KSMBD_DEFAULT_GFP);
1111	if (!aces_base) {
1112		rc = -ENOMEM;
1113		goto free_parent_pntsd;
1114	}
1115
1116	aces = (struct smb_ace *)aces_base;
1117	parent_aces = (struct smb_ace *)((char *)parent_pdacl +
1118			sizeof(struct smb_acl));
1119	aces_size = acl_len - sizeof(struct smb_acl);
1120
1121	if (pntsd_type & DACL_AUTO_INHERITED)
1122		inherited_flags = INHERITED_ACE;
1123
1124	for (i = 0; i < num_aces; i++) {
1125		int pace_size;
1126
1127		if (offsetof(struct smb_ace, access_req) > aces_size)
1128			break;
1129
1130		pace_size = le16_to_cpu(parent_aces->size);
1131		if (pace_size > aces_size)
1132			break;
1133
1134		aces_size -= pace_size;
1135
1136		flags = parent_aces->flags;
1137		if (!smb_inherit_flags(flags, is_dir))
1138			goto pass;
1139		if (is_dir) {
1140			flags &= ~(INHERIT_ONLY_ACE | INHERITED_ACE);
1141			if (!(flags & CONTAINER_INHERIT_ACE))
1142				flags |= INHERIT_ONLY_ACE;
1143			if (flags & NO_PROPAGATE_INHERIT_ACE)
1144				flags = 0;
1145		} else {
1146			flags = 0;
1147		}
1148
1149		if (!compare_sids(&creator_owner, &parent_aces->sid)) {
1150			creator = &creator_owner;
1151			id_to_sid(uid, SIDOWNER, &owner_sid);
1152			psid = &owner_sid;
1153		} else if (!compare_sids(&creator_group, &parent_aces->sid)) {
1154			creator = &creator_group;
1155			id_to_sid(gid, SIDUNIX_GROUP, &group_sid);
1156			psid = &group_sid;
1157		} else {
1158			creator = NULL;
1159			psid = &parent_aces->sid;
1160		}
1161
1162		if (is_dir && creator && flags & CONTAINER_INHERIT_ACE) {
1163			smb_set_ace(aces, psid, parent_aces->type, inherited_flags,
1164				    parent_aces->access_req);
1165			nt_size += le16_to_cpu(aces->size);
1166			ace_cnt++;
1167			aces = (struct smb_ace *)((char *)aces + le16_to_cpu(aces->size));
1168			flags |= INHERIT_ONLY_ACE;
1169			psid = creator;
1170		} else if (is_dir && !(parent_aces->flags & NO_PROPAGATE_INHERIT_ACE)) {
1171			psid = &parent_aces->sid;
1172		}
1173
1174		smb_set_ace(aces, psid, parent_aces->type, flags | inherited_flags,
1175			    parent_aces->access_req);
1176		nt_size += le16_to_cpu(aces->size);
1177		aces = (struct smb_ace *)((char *)aces + le16_to_cpu(aces->size));
1178		ace_cnt++;
1179pass:
1180		parent_aces = (struct smb_ace *)((char *)parent_aces + pace_size);
1181	}
1182
1183	if (nt_size > 0) {
1184		struct smb_ntsd *pntsd;
1185		struct smb_acl *pdacl;
1186		struct smb_sid *powner_sid = NULL, *pgroup_sid = NULL;
1187		int powner_sid_size = 0, pgroup_sid_size = 0, pntsd_size;
1188		int pntsd_alloc_size;
1189
1190		if (parent_pntsd->osidoffset) {
1191			powner_sid = (struct smb_sid *)((char *)parent_pntsd +
1192					le32_to_cpu(parent_pntsd->osidoffset));
1193			powner_sid_size = 1 + 1 + 6 + (powner_sid->num_subauth * 4);
1194		}
1195		if (parent_pntsd->gsidoffset) {
1196			pgroup_sid = (struct smb_sid *)((char *)parent_pntsd +
1197					le32_to_cpu(parent_pntsd->gsidoffset));
1198			pgroup_sid_size = 1 + 1 + 6 + (pgroup_sid->num_subauth * 4);
1199		}
1200
1201		pntsd_alloc_size = sizeof(struct smb_ntsd) + powner_sid_size +
1202			pgroup_sid_size + sizeof(struct smb_acl) + nt_size;
1203
1204		pntsd = kzalloc(pntsd_alloc_size, KSMBD_DEFAULT_GFP);
1205		if (!pntsd) {
1206			rc = -ENOMEM;
1207			goto free_aces_base;
1208		}
1209
1210		pntsd->revision = cpu_to_le16(1);
1211		pntsd->type = cpu_to_le16(SELF_RELATIVE | DACL_PRESENT);
1212		if (le16_to_cpu(parent_pntsd->type) & DACL_AUTO_INHERITED)
1213			pntsd->type |= cpu_to_le16(DACL_AUTO_INHERITED);
1214		pntsd_size = sizeof(struct smb_ntsd);
1215		pntsd->osidoffset = parent_pntsd->osidoffset;
1216		pntsd->gsidoffset = parent_pntsd->gsidoffset;
1217		pntsd->dacloffset = parent_pntsd->dacloffset;
1218
1219		if ((u64)le32_to_cpu(pntsd->osidoffset) + powner_sid_size >
1220		    pntsd_alloc_size) {
1221			rc = -EINVAL;
1222			kfree(pntsd);
1223			goto free_aces_base;
1224		}
1225
1226		if ((u64)le32_to_cpu(pntsd->gsidoffset) + pgroup_sid_size >
1227		    pntsd_alloc_size) {
1228			rc = -EINVAL;
1229			kfree(pntsd);
1230			goto free_aces_base;
1231		}
1232
1233		if ((u64)le32_to_cpu(pntsd->dacloffset) + sizeof(struct smb_acl) + nt_size >
1234		    pntsd_alloc_size) {
1235			rc = -EINVAL;
1236			kfree(pntsd);
1237			goto free_aces_base;
1238		}
1239
1240		if (pntsd->osidoffset) {
1241			struct smb_sid *owner_sid = (struct smb_sid *)((char *)pntsd +
1242					le32_to_cpu(pntsd->osidoffset));
1243			memcpy(owner_sid, powner_sid, powner_sid_size);
1244			pntsd_size += powner_sid_size;
1245		}
1246
1247		if (pntsd->gsidoffset) {
1248			struct smb_sid *group_sid = (struct smb_sid *)((char *)pntsd +
1249					le32_to_cpu(pntsd->gsidoffset));
1250			memcpy(group_sid, pgroup_sid, pgroup_sid_size);
1251			pntsd_size += pgroup_sid_size;
1252		}
1253
1254		if (pntsd->dacloffset) {
1255			struct smb_ace *pace;
1256
1257			pdacl = (struct smb_acl *)((char *)pntsd + le32_to_cpu(pntsd->dacloffset));
1258			pdacl->revision = cpu_to_le16(2);
1259			pdacl->size = cpu_to_le16(sizeof(struct smb_acl) + nt_size);
1260			pdacl->num_aces = cpu_to_le16(ace_cnt);
1261			pace = (struct smb_ace *)((char *)pdacl + sizeof(struct smb_acl));
1262			memcpy(pace, aces_base, nt_size);
1263			pntsd_size += sizeof(struct smb_acl) + nt_size;
1264		}
1265
1266		ksmbd_vfs_set_sd_xattr(conn, idmap, path, pntsd, pntsd_size, false);
1267		kfree(pntsd);
1268	}
1269
1270free_aces_base:
1271	kfree(aces_base);
1272free_parent_pntsd:
1273	kfree(parent_pntsd);
1274	return rc;
1275}
1276
1277bool smb_inherit_flags(int flags, bool is_dir)
1278{
1279	if (!is_dir)
1280		return (flags & OBJECT_INHERIT_ACE) != 0;
1281
1282	if (flags & OBJECT_INHERIT_ACE && !(flags & NO_PROPAGATE_INHERIT_ACE))
1283		return true;
1284
1285	if (flags & CONTAINER_INHERIT_ACE)
1286		return true;
1287	return false;
1288}
1289
1290int smb_check_perm_dacl(struct ksmbd_conn *conn, const struct path *path,
1291			__le32 *pdaccess, int uid)
1292{
1293	struct mnt_idmap *idmap = mnt_idmap(path->mnt);
1294	struct smb_ntsd *pntsd = NULL;
1295	struct smb_acl *pdacl;
1296	struct posix_acl *posix_acls;
1297	int rc = 0, pntsd_size, acl_size, aces_size, pdacl_size;
1298	unsigned int dacl_offset;
1299	size_t dacl_struct_end;
1300	struct smb_sid sid;
1301	int granted = le32_to_cpu(*pdaccess & ~FILE_MAXIMAL_ACCESS_LE);
1302	struct smb_ace *ace;
1303	int i, found = 0;
1304	unsigned int access_bits = 0;
1305	struct smb_ace *others_ace = NULL;
1306	struct posix_acl_entry *pa_entry;
1307	unsigned int sid_type = SIDOWNER;
1308	unsigned short ace_size;
1309
1310	ksmbd_debug(SMB, "check permission using windows acl\n");
1311	pntsd_size = ksmbd_vfs_get_sd_xattr(conn, idmap,
1312					    path->dentry, &pntsd);
1313	if (pntsd_size <= 0 || !pntsd)
1314		goto err_out;
1315
1316	dacl_offset = le32_to_cpu(pntsd->dacloffset);
1317	if (!dacl_offset ||
1318	    check_add_overflow(dacl_offset, sizeof(struct smb_acl), &dacl_struct_end) ||
1319	    dacl_struct_end > (size_t)pntsd_size)
1320		goto err_out;
1321
1322	pdacl = (struct smb_acl *)((char *)pntsd + le32_to_cpu(pntsd->dacloffset));
1323	acl_size = pntsd_size - dacl_offset;
1324	pdacl_size = le16_to_cpu(pdacl->size);
1325
1326	if (pdacl_size > acl_size || pdacl_size < sizeof(struct smb_acl))
1327		goto err_out;
1328
1329	if (!pdacl->num_aces) {
1330		if (!(pdacl_size - sizeof(struct smb_acl)) &&
1331		    *pdaccess & ~(FILE_READ_CONTROL_LE | FILE_WRITE_DAC_LE)) {
1332			rc = -EACCES;
1333			goto err_out;
1334		}
1335		goto err_out;
1336	}
1337
1338	if (*pdaccess & FILE_MAXIMAL_ACCESS_LE) {
1339		granted = READ_CONTROL | WRITE_DAC | FILE_READ_ATTRIBUTES |
1340			DELETE;
1341
1342		ace = (struct smb_ace *)((char *)pdacl + sizeof(struct smb_acl));
1343		aces_size = acl_size - sizeof(struct smb_acl);
1344		for (i = 0; i < le16_to_cpu(pdacl->num_aces); i++) {
1345			if (offsetof(struct smb_ace, access_req) > aces_size)
1346				break;
1347			ace_size = le16_to_cpu(ace->size);
1348			if (ace_size > aces_size)
1349				break;
1350			aces_size -= ace_size;
1351			granted |= le32_to_cpu(ace->access_req);
1352			ace = (struct smb_ace *)((char *)ace + le16_to_cpu(ace->size));
1353		}
1354	}
1355
1356	if (!uid)
1357		sid_type = SIDUNIX_USER;
1358	id_to_sid(uid, sid_type, &sid);
1359
1360	ace = (struct smb_ace *)((char *)pdacl + sizeof(struct smb_acl));
1361	aces_size = acl_size - sizeof(struct smb_acl);
1362	for (i = 0; i < le16_to_cpu(pdacl->num_aces); i++) {
1363		if (offsetof(struct smb_ace, access_req) > aces_size)
1364			break;
1365		ace_size = le16_to_cpu(ace->size);
1366		if (ace_size > aces_size)
1367			break;
1368		aces_size -= ace_size;
1369
1370		if (!compare_sids(&sid, &ace->sid) ||
1371		    !compare_sids(&sid_unix_NFS_mode, &ace->sid)) {
1372			found = 1;
1373			break;
1374		}
1375		if (!compare_sids(&sid_everyone, &ace->sid))
1376			others_ace = ace;
1377
1378		ace = (struct smb_ace *)((char *)ace + le16_to_cpu(ace->size));
1379	}
1380
1381	if (*pdaccess & FILE_MAXIMAL_ACCESS_LE && found) {
1382		granted = READ_CONTROL | WRITE_DAC | FILE_READ_ATTRIBUTES |
1383			DELETE;
1384
1385		granted |= le32_to_cpu(ace->access_req);
1386
1387		if (!pdacl->num_aces)
1388			granted = GENERIC_ALL_FLAGS;
1389	}
1390
1391	if (IS_ENABLED(CONFIG_FS_POSIX_ACL)) {
1392		posix_acls = get_inode_acl(d_inode(path->dentry), ACL_TYPE_ACCESS);
1393		if (!IS_ERR_OR_NULL(posix_acls) && !found) {
1394			unsigned int id = -1;
1395
1396			pa_entry = posix_acls->a_entries;
1397			for (i = 0; i < posix_acls->a_count; i++, pa_entry++) {
1398				if (pa_entry->e_tag == ACL_USER)
1399					id = posix_acl_uid_translate(idmap, pa_entry);
1400				else if (pa_entry->e_tag == ACL_GROUP)
1401					id = posix_acl_gid_translate(idmap, pa_entry);
1402				else
1403					continue;
1404
1405				if (id == uid) {
1406					mode_to_access_flags(pa_entry->e_perm,
1407							     0777,
1408							     &access_bits);
1409					if (!access_bits)
1410						access_bits =
1411							SET_MINIMUM_RIGHTS;
1412					posix_acl_release(posix_acls);
1413					goto check_access_bits;
1414				}
1415			}
1416		}
1417		if (!IS_ERR_OR_NULL(posix_acls))
1418			posix_acl_release(posix_acls);
1419	}
1420
1421	if (!found) {
1422		if (others_ace) {
1423			ace = others_ace;
1424		} else {
1425			ksmbd_debug(SMB, "Can't find corresponding sid\n");
1426			rc = -EACCES;
1427			goto err_out;
1428		}
1429	}
1430
1431	switch (ace->type) {
1432	case ACCESS_ALLOWED_ACE_TYPE:
1433		access_bits = le32_to_cpu(ace->access_req);
1434		break;
1435	case ACCESS_DENIED_ACE_TYPE:
1436	case ACCESS_DENIED_CALLBACK_ACE_TYPE:
1437		access_bits = le32_to_cpu(~ace->access_req);
1438		break;
1439	}
1440
1441check_access_bits:
1442	if (granted &
1443	    ~(access_bits | FILE_READ_ATTRIBUTES | READ_CONTROL | WRITE_DAC | DELETE)) {
1444		ksmbd_debug(SMB, "Access denied with winACL, granted : %x, access_req : %x\n",
1445			    granted, le32_to_cpu(ace->access_req));
1446		rc = -EACCES;
1447		goto err_out;
1448	}
1449
1450	*pdaccess = cpu_to_le32(granted);
1451err_out:
1452	kfree(pntsd);
1453	return rc;
1454}
1455
1456int set_info_sec(struct ksmbd_conn *conn, struct ksmbd_tree_connect *tcon,
1457		 const struct path *path, struct smb_ntsd *pntsd, int ntsd_len,
1458		 bool type_check, bool get_write)
1459{
1460	int rc;
1461	struct smb_fattr fattr = {{0}};
1462	struct inode *inode = d_inode(path->dentry);
1463	struct mnt_idmap *idmap = mnt_idmap(path->mnt);
1464	struct iattr newattrs;
1465
1466	fattr.cf_uid = INVALID_UID;
1467	fattr.cf_gid = INVALID_GID;
1468	fattr.cf_mode = inode->i_mode;
1469
1470	rc = parse_sec_desc(idmap, pntsd, ntsd_len, &fattr);
1471	if (rc)
1472		goto out;
1473
1474	newattrs.ia_valid = ATTR_CTIME;
1475	if (!uid_eq(fattr.cf_uid, INVALID_UID)) {
1476		newattrs.ia_valid |= ATTR_UID;
1477		newattrs.ia_uid = fattr.cf_uid;
1478	}
1479	if (!gid_eq(fattr.cf_gid, INVALID_GID)) {
1480		newattrs.ia_valid |= ATTR_GID;
1481		newattrs.ia_gid = fattr.cf_gid;
1482	}
1483	newattrs.ia_valid |= ATTR_MODE;
1484	newattrs.ia_mode = (inode->i_mode & ~0777) | (fattr.cf_mode & 0777);
1485
1486	ksmbd_vfs_remove_acl_xattrs(idmap, path);
1487	/* Update posix acls */
1488	if (IS_ENABLED(CONFIG_FS_POSIX_ACL) && fattr.cf_dacls) {
1489		rc = set_posix_acl(idmap, path->dentry,
1490				   ACL_TYPE_ACCESS, fattr.cf_acls);
1491		if (rc < 0)
1492			ksmbd_debug(SMB,
1493				    "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n",
1494				    rc);
1495		if (S_ISDIR(inode->i_mode) && fattr.cf_dacls) {
1496			rc = set_posix_acl(idmap, path->dentry,
1497					   ACL_TYPE_DEFAULT, fattr.cf_dacls);
1498			if (rc)
1499				ksmbd_debug(SMB,
1500					    "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n",
1501					    rc);
1502		}
1503	}
1504
1505	inode_lock(inode);
1506	rc = notify_change(idmap, path->dentry, &newattrs, NULL);
1507	inode_unlock(inode);
1508	if (rc)
1509		goto out;
1510
1511	/* Check it only calling from SD BUFFER context */
1512	if (type_check && !(le16_to_cpu(pntsd->type) & DACL_PRESENT))
1513		goto out;
1514
1515	if (test_share_config_flag(tcon->share_conf, KSMBD_SHARE_FLAG_ACL_XATTR)) {
1516		/* Update WinACL in xattr */
1517		ksmbd_vfs_remove_sd_xattrs(idmap, path);
1518		ksmbd_vfs_set_sd_xattr(conn, idmap, path, pntsd, ntsd_len,
1519				get_write);
1520	}
1521
1522out:
1523	posix_acl_release(fattr.cf_acls);
1524	posix_acl_release(fattr.cf_dacls);
1525	return rc;
1526}
1527
1528void ksmbd_init_domain(u32 *sub_auth)
1529{
1530	int i;
1531
1532	memcpy(&server_conf.domain_sid, &domain, sizeof(struct smb_sid));
1533	for (i = 0; i < 3; ++i)
1534		server_conf.domain_sid.sub_auth[i + 1] = cpu_to_le32(sub_auth[i]);
1535}