1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * fs/nfs_common/nfsacl.c
4  *
5  *  Copyright (C) 2002-2003 Andreas Gruenbacher <agruen@suse.de>
6  */
7 
8 /*
9  * The Solaris nfsacl protocol represents some ACLs slightly differently
10  * than POSIX 1003.1e draft 17 does (and we do):
11  *
12  *  - Minimal ACLs always have an ACL_MASK entry, so they have
13  *    four instead of three entries.
14  *  - The ACL_MASK entry in such minimal ACLs always has the same
15  *    permissions as the ACL_GROUP_OBJ entry. (In extended ACLs
16  *    the ACL_MASK and ACL_GROUP_OBJ entries may differ.)
17  *  - The identifier fields of the ACL_USER_OBJ and ACL_GROUP_OBJ
18  *    entries contain the identifiers of the owner and owning group.
19  *    (In POSIX ACLs we always set them to ACL_UNDEFINED_ID).
20  *  - ACL entries in the kernel are kept sorted in ascending order
21  *    of (e_tag, e_id). Solaris ACLs are unsorted.
22  */
23 
24 #include <linux/module.h>
25 #include <linux/fs.h>
26 #include <linux/gfp.h>
27 #include <linux/sunrpc/xdr.h>
28 #include <linux/nfsacl.h>
29 #include <linux/nfs3.h>
30 #include <linux/sort.h>
31 
32 MODULE_LICENSE("GPL");
33 
34 struct nfsacl_encode_desc {
35 	struct xdr_array2_desc desc;
36 	unsigned int count;
37 	struct posix_acl *acl;
38 	int typeflag;
39 	kuid_t uid;
40 	kgid_t gid;
41 };
42 
43 struct nfsacl_simple_acl {
44 	struct posix_acl acl;
45 	struct posix_acl_entry ace[4];
46 };
47 
48 static int
xdr_nfsace_encode(struct xdr_array2_desc * desc,void * elem)49 xdr_nfsace_encode(struct xdr_array2_desc *desc, void *elem)
50 {
51 	struct nfsacl_encode_desc *nfsacl_desc =
52 		(struct nfsacl_encode_desc *) desc;
53 	__be32 *p = elem;
54 
55 	struct posix_acl_entry *entry =
56 		&nfsacl_desc->acl->a_entries[nfsacl_desc->count++];
57 
58 	*p++ = htonl(entry->e_tag | nfsacl_desc->typeflag);
59 	switch(entry->e_tag) {
60 		case ACL_USER_OBJ:
61 			*p++ = htonl(from_kuid(&init_user_ns, nfsacl_desc->uid));
62 			break;
63 		case ACL_GROUP_OBJ:
64 			*p++ = htonl(from_kgid(&init_user_ns, nfsacl_desc->gid));
65 			break;
66 		case ACL_USER:
67 			*p++ = htonl(from_kuid(&init_user_ns, entry->e_uid));
68 			break;
69 		case ACL_GROUP:
70 			*p++ = htonl(from_kgid(&init_user_ns, entry->e_gid));
71 			break;
72 		default:  /* Solaris depends on that! */
73 			*p++ = 0;
74 			break;
75 	}
76 	*p++ = htonl(entry->e_perm & S_IRWXO);
77 	return 0;
78 }
79 
80 /**
81  * nfsacl_encode - Encode an NFSv3 ACL
82  *
83  * @buf: destination xdr_buf to contain XDR encoded ACL
84  * @base: byte offset in xdr_buf where XDR'd ACL begins
85  * @inode: inode of file whose ACL this is
86  * @acl: posix_acl to encode
87  * @encode_entries: whether to encode ACEs as well
88  * @typeflag: ACL type: NFS_ACL_DEFAULT or zero
89  *
90  * Returns size of encoded ACL in bytes or a negative errno value.
91  */
nfsacl_encode(struct xdr_buf * buf,unsigned int base,struct inode * inode,struct posix_acl * acl,int encode_entries,int typeflag)92 int nfsacl_encode(struct xdr_buf *buf, unsigned int base, struct inode *inode,
93 		  struct posix_acl *acl, int encode_entries, int typeflag)
94 {
95 	int entries = (acl && acl->a_count) ? max_t(int, acl->a_count, 4) : 0;
96 	struct nfsacl_encode_desc nfsacl_desc = {
97 		.desc = {
98 			.elem_size = 12,
99 			.array_len = encode_entries ? entries : 0,
100 			.xcode = xdr_nfsace_encode,
101 		},
102 		.acl = acl,
103 		.typeflag = typeflag,
104 		.uid = inode->i_uid,
105 		.gid = inode->i_gid,
106 	};
107 	struct nfsacl_simple_acl aclbuf;
108 	int err;
109 
110 	if (entries > NFS_ACL_MAX_ENTRIES ||
111 	    xdr_encode_word(buf, base, entries))
112 		return -EINVAL;
113 	if (encode_entries && acl && acl->a_count == 3) {
114 		struct posix_acl *acl2 = &aclbuf.acl;
115 
116 		/* Avoid the use of posix_acl_alloc().  nfsacl_encode() is
117 		 * invoked in contexts where a memory allocation failure is
118 		 * fatal.  Fortunately this fake ACL is small enough to
119 		 * construct on the stack. */
120 		posix_acl_init(acl2, 4);
121 
122 		/* Insert entries in canonical order: other orders seem
123 		 to confuse Solaris VxFS. */
124 		acl2->a_entries[0] = acl->a_entries[0];  /* ACL_USER_OBJ */
125 		acl2->a_entries[1] = acl->a_entries[1];  /* ACL_GROUP_OBJ */
126 		acl2->a_entries[2] = acl->a_entries[1];  /* ACL_MASK */
127 		acl2->a_entries[2].e_tag = ACL_MASK;
128 		acl2->a_entries[3] = acl->a_entries[2];  /* ACL_OTHER */
129 		nfsacl_desc.acl = acl2;
130 	}
131 	err = xdr_encode_array2(buf, base + 4, &nfsacl_desc.desc);
132 	if (!err)
133 		err = 8 + nfsacl_desc.desc.elem_size *
134 			  nfsacl_desc.desc.array_len;
135 	return err;
136 }
137 EXPORT_SYMBOL_GPL(nfsacl_encode);
138 
139 /**
140  * nfs_stream_encode_acl - Encode an NFSv3 ACL
141  *
142  * @xdr: an xdr_stream positioned to receive an encoded ACL
143  * @inode: inode of file whose ACL this is
144  * @acl: posix_acl to encode
145  * @encode_entries: whether to encode ACEs as well
146  * @typeflag: ACL type: NFS_ACL_DEFAULT or zero
147  *
148  * Return values:
149  *   %false: The ACL could not be encoded
150  *   %true: @xdr is advanced to the next available position
151  */
nfs_stream_encode_acl(struct xdr_stream * xdr,struct inode * inode,struct posix_acl * acl,int encode_entries,int typeflag)152 bool nfs_stream_encode_acl(struct xdr_stream *xdr, struct inode *inode,
153 			   struct posix_acl *acl, int encode_entries,
154 			   int typeflag)
155 {
156 	const size_t elem_size = XDR_UNIT * 3;
157 	u32 entries = (acl && acl->a_count) ? max_t(int, acl->a_count, 4) : 0;
158 	struct nfsacl_encode_desc nfsacl_desc = {
159 		.desc = {
160 			.elem_size = elem_size,
161 			.array_len = encode_entries ? entries : 0,
162 			.xcode = xdr_nfsace_encode,
163 		},
164 		.acl = acl,
165 		.typeflag = typeflag,
166 		.uid = inode->i_uid,
167 		.gid = inode->i_gid,
168 	};
169 	struct nfsacl_simple_acl aclbuf;
170 	unsigned int base;
171 	int err;
172 
173 	if (entries > NFS_ACL_MAX_ENTRIES)
174 		return false;
175 	if (xdr_stream_encode_u32(xdr, entries) < 0)
176 		return false;
177 
178 	if (encode_entries && acl && acl->a_count == 3) {
179 		struct posix_acl *acl2 = &aclbuf.acl;
180 
181 		/* Avoid the use of posix_acl_alloc().  nfsacl_encode() is
182 		 * invoked in contexts where a memory allocation failure is
183 		 * fatal.  Fortunately this fake ACL is small enough to
184 		 * construct on the stack. */
185 		posix_acl_init(acl2, 4);
186 
187 		/* Insert entries in canonical order: other orders seem
188 		 to confuse Solaris VxFS. */
189 		acl2->a_entries[0] = acl->a_entries[0];  /* ACL_USER_OBJ */
190 		acl2->a_entries[1] = acl->a_entries[1];  /* ACL_GROUP_OBJ */
191 		acl2->a_entries[2] = acl->a_entries[1];  /* ACL_MASK */
192 		acl2->a_entries[2].e_tag = ACL_MASK;
193 		acl2->a_entries[3] = acl->a_entries[2];  /* ACL_OTHER */
194 		nfsacl_desc.acl = acl2;
195 	}
196 
197 	base = xdr_stream_pos(xdr);
198 	if (!xdr_reserve_space(xdr, XDR_UNIT +
199 			       elem_size * nfsacl_desc.desc.array_len))
200 		return false;
201 	err = xdr_encode_array2(xdr->buf, base, &nfsacl_desc.desc);
202 	if (err)
203 		return false;
204 
205 	return true;
206 }
207 EXPORT_SYMBOL_GPL(nfs_stream_encode_acl);
208 
209 
210 struct nfsacl_decode_desc {
211 	struct xdr_array2_desc desc;
212 	unsigned int count;
213 	struct posix_acl *acl;
214 };
215 
216 static int
xdr_nfsace_decode(struct xdr_array2_desc * desc,void * elem)217 xdr_nfsace_decode(struct xdr_array2_desc *desc, void *elem)
218 {
219 	struct nfsacl_decode_desc *nfsacl_desc =
220 		(struct nfsacl_decode_desc *) desc;
221 	__be32 *p = elem;
222 	struct posix_acl_entry *entry;
223 	unsigned int id;
224 
225 	if (!nfsacl_desc->acl) {
226 		if (desc->array_len > NFS_ACL_MAX_ENTRIES)
227 			return -EINVAL;
228 		nfsacl_desc->acl = posix_acl_alloc(desc->array_len, GFP_KERNEL);
229 		if (!nfsacl_desc->acl)
230 			return -ENOMEM;
231 		nfsacl_desc->count = 0;
232 	}
233 
234 	entry = &nfsacl_desc->acl->a_entries[nfsacl_desc->count++];
235 	entry->e_tag = ntohl(*p++) & ~NFS_ACL_DEFAULT;
236 	id = ntohl(*p++);
237 	entry->e_perm = ntohl(*p++);
238 
239 	switch(entry->e_tag) {
240 		case ACL_USER:
241 			entry->e_uid = make_kuid(&init_user_ns, id);
242 			if (!uid_valid(entry->e_uid))
243 				return -EINVAL;
244 			break;
245 		case ACL_GROUP:
246 			entry->e_gid = make_kgid(&init_user_ns, id);
247 			if (!gid_valid(entry->e_gid))
248 				return -EINVAL;
249 			break;
250 		case ACL_USER_OBJ:
251 		case ACL_GROUP_OBJ:
252 		case ACL_OTHER:
253 			if (entry->e_perm & ~S_IRWXO)
254 				return -EINVAL;
255 			break;
256 		case ACL_MASK:
257 			/* Solaris sometimes sets additional bits in the mask */
258 			entry->e_perm &= S_IRWXO;
259 			break;
260 		default:
261 			return -EINVAL;
262 	}
263 
264 	return 0;
265 }
266 
267 static int
cmp_acl_entry(const void * x,const void * y)268 cmp_acl_entry(const void *x, const void *y)
269 {
270 	const struct posix_acl_entry *a = x, *b = y;
271 
272 	if (a->e_tag != b->e_tag)
273 		return a->e_tag - b->e_tag;
274 	else if ((a->e_tag == ACL_USER) && uid_gt(a->e_uid, b->e_uid))
275 		return 1;
276 	else if ((a->e_tag == ACL_USER) && uid_lt(a->e_uid, b->e_uid))
277 		return -1;
278 	else if ((a->e_tag == ACL_GROUP) && gid_gt(a->e_gid, b->e_gid))
279 		return 1;
280 	else if ((a->e_tag == ACL_GROUP) && gid_lt(a->e_gid, b->e_gid))
281 		return -1;
282 	else
283 		return 0;
284 }
285 
286 /*
287  * Convert from a Solaris ACL to a POSIX 1003.1e draft 17 ACL.
288  */
289 static int
posix_acl_from_nfsacl(struct posix_acl * acl)290 posix_acl_from_nfsacl(struct posix_acl *acl)
291 {
292 	struct posix_acl_entry *pa, *pe,
293 	       *group_obj = NULL, *mask = NULL;
294 
295 	if (!acl)
296 		return 0;
297 
298 	sort(acl->a_entries, acl->a_count, sizeof(struct posix_acl_entry),
299 	     cmp_acl_entry, NULL);
300 
301 	/* Find the ACL_GROUP_OBJ and ACL_MASK entries. */
302 	FOREACH_ACL_ENTRY(pa, acl, pe) {
303 		switch(pa->e_tag) {
304 			case ACL_USER_OBJ:
305 				break;
306 			case ACL_GROUP_OBJ:
307 				group_obj = pa;
308 				break;
309 			case ACL_MASK:
310 				mask = pa;
311 				fallthrough;
312 			case ACL_OTHER:
313 				break;
314 		}
315 	}
316 	if (acl->a_count == 4 && group_obj && mask &&
317 	    mask->e_perm == group_obj->e_perm) {
318 		/* remove bogus ACL_MASK entry */
319 		memmove(mask, mask+1, (3 - (mask - acl->a_entries)) *
320 				      sizeof(struct posix_acl_entry));
321 		acl->a_count = 3;
322 	}
323 	return 0;
324 }
325 
326 /**
327  * nfsacl_decode - Decode an NFSv3 ACL
328  *
329  * @buf: xdr_buf containing XDR'd ACL data to decode
330  * @base: byte offset in xdr_buf where XDR'd ACL begins
331  * @aclcnt: count of ACEs in decoded posix_acl
332  * @pacl: buffer in which to place decoded posix_acl
333  *
334  * Returns the length of the decoded ACL in bytes, or a negative errno value.
335  */
nfsacl_decode(struct xdr_buf * buf,unsigned int base,unsigned int * aclcnt,struct posix_acl ** pacl)336 int nfsacl_decode(struct xdr_buf *buf, unsigned int base, unsigned int *aclcnt,
337 		  struct posix_acl **pacl)
338 {
339 	struct nfsacl_decode_desc nfsacl_desc = {
340 		.desc = {
341 			.elem_size = 12,
342 			.xcode = pacl ? xdr_nfsace_decode : NULL,
343 		},
344 	};
345 	u32 entries;
346 	int err;
347 
348 	if (xdr_decode_word(buf, base, &entries) ||
349 	    entries > NFS_ACL_MAX_ENTRIES)
350 		return -EINVAL;
351 	nfsacl_desc.desc.array_maxlen = entries;
352 	err = xdr_decode_array2(buf, base + 4, &nfsacl_desc.desc);
353 	if (err)
354 		return err;
355 	if (pacl) {
356 		if (entries != nfsacl_desc.desc.array_len ||
357 		    posix_acl_from_nfsacl(nfsacl_desc.acl) != 0) {
358 			posix_acl_release(nfsacl_desc.acl);
359 			return -EINVAL;
360 		}
361 		*pacl = nfsacl_desc.acl;
362 	}
363 	if (aclcnt)
364 		*aclcnt = entries;
365 	return 8 + nfsacl_desc.desc.elem_size *
366 		   nfsacl_desc.desc.array_len;
367 }
368 EXPORT_SYMBOL_GPL(nfsacl_decode);
369 
370 /**
371  * nfs_stream_decode_acl - Decode an NFSv3 ACL
372  *
373  * @xdr: an xdr_stream positioned at an encoded ACL
374  * @aclcnt: OUT: count of ACEs in decoded posix_acl
375  * @pacl: OUT: a dynamically-allocated buffer containing the decoded posix_acl
376  *
377  * Return values:
378  *   %false: The encoded ACL is not valid
379  *   %true: @pacl contains a decoded ACL, and @xdr is advanced
380  *
381  * On a successful return, caller must release *pacl using posix_acl_release().
382  */
nfs_stream_decode_acl(struct xdr_stream * xdr,unsigned int * aclcnt,struct posix_acl ** pacl)383 bool nfs_stream_decode_acl(struct xdr_stream *xdr, unsigned int *aclcnt,
384 			   struct posix_acl **pacl)
385 {
386 	const size_t elem_size = XDR_UNIT * 3;
387 	struct nfsacl_decode_desc nfsacl_desc = {
388 		.desc = {
389 			.elem_size = elem_size,
390 			.xcode = pacl ? xdr_nfsace_decode : NULL,
391 		},
392 	};
393 	unsigned int base;
394 	u32 entries;
395 
396 	if (xdr_stream_decode_u32(xdr, &entries) < 0)
397 		return false;
398 	if (entries > NFS_ACL_MAX_ENTRIES)
399 		return false;
400 
401 	base = xdr_stream_pos(xdr);
402 	if (!xdr_inline_decode(xdr, XDR_UNIT + elem_size * entries))
403 		return false;
404 	nfsacl_desc.desc.array_maxlen = entries;
405 	if (xdr_decode_array2(xdr->buf, base, &nfsacl_desc.desc))
406 		return false;
407 
408 	if (pacl) {
409 		if (entries != nfsacl_desc.desc.array_len ||
410 		    posix_acl_from_nfsacl(nfsacl_desc.acl) != 0) {
411 			posix_acl_release(nfsacl_desc.acl);
412 			return false;
413 		}
414 		*pacl = nfsacl_desc.acl;
415 	}
416 	if (aclcnt)
417 		*aclcnt = entries;
418 	return true;
419 }
420 EXPORT_SYMBOL_GPL(nfs_stream_decode_acl);
421