Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : :
3 : : #include <linux/export.h>
4 : : #include <linux/nsproxy.h>
5 : : #include <linux/slab.h>
6 : : #include <linux/sched/signal.h>
7 : : #include <linux/user_namespace.h>
8 : : #include <linux/proc_ns.h>
9 : : #include <linux/highuid.h>
10 : : #include <linux/cred.h>
11 : : #include <linux/securebits.h>
12 : : #include <linux/keyctl.h>
13 : : #include <linux/key-type.h>
14 : : #include <keys/user-type.h>
15 : : #include <linux/seq_file.h>
16 : : #include <linux/fs.h>
17 : : #include <linux/uaccess.h>
18 : : #include <linux/ctype.h>
19 : : #include <linux/projid.h>
20 : : #include <linux/fs_struct.h>
21 : : #include <linux/bsearch.h>
22 : : #include <linux/sort.h>
23 : :
24 : : static struct kmem_cache *user_ns_cachep __read_mostly;
25 : : static DEFINE_MUTEX(userns_state_mutex);
26 : :
27 : : static bool new_idmap_permitted(const struct file *file,
28 : : struct user_namespace *ns, int cap_setid,
29 : : struct uid_gid_map *map);
30 : : static void free_user_ns(struct work_struct *work);
31 : :
32 : : static struct ucounts *inc_user_namespaces(struct user_namespace *ns, kuid_t uid)
33 : : {
34 : 0 : return inc_ucount(ns, uid, UCOUNT_USER_NAMESPACES);
35 : : }
36 : :
37 : : static void dec_user_namespaces(struct ucounts *ucounts)
38 : : {
39 : 0 : return dec_ucount(ucounts, UCOUNT_USER_NAMESPACES);
40 : : }
41 : :
42 : 0 : static void set_cred_user_ns(struct cred *cred, struct user_namespace *user_ns)
43 : : {
44 : : /* Start with the same capabilities as init but useless for doing
45 : : * anything as the capabilities are bound to the new user namespace.
46 : : */
47 : 0 : cred->securebits = SECUREBITS_DEFAULT;
48 : 0 : cred->cap_inheritable = CAP_EMPTY_SET;
49 : 0 : cred->cap_permitted = CAP_FULL_SET;
50 : 0 : cred->cap_effective = CAP_FULL_SET;
51 : 0 : cred->cap_ambient = CAP_EMPTY_SET;
52 : 0 : cred->cap_bset = CAP_FULL_SET;
53 : : #ifdef CONFIG_KEYS
54 : 0 : key_put(cred->request_key_auth);
55 : 0 : cred->request_key_auth = NULL;
56 : : #endif
57 : : /* tgcred will be cleared in our caller bc CLONE_THREAD won't be set */
58 : 0 : cred->user_ns = user_ns;
59 : 0 : }
60 : :
61 : : /*
62 : : * Create a new user namespace, deriving the creator from the user in the
63 : : * passed credentials, and replacing that user with the new root user for the
64 : : * new namespace.
65 : : *
66 : : * This is called by copy_creds(), which will finish setting the target task's
67 : : * credentials.
68 : : */
69 : 0 : int create_user_ns(struct cred *new)
70 : : {
71 : 0 : struct user_namespace *ns, *parent_ns = new->user_ns;
72 : 0 : kuid_t owner = new->euid;
73 : 0 : kgid_t group = new->egid;
74 : : struct ucounts *ucounts;
75 : : int ret, i;
76 : :
77 : : ret = -ENOSPC;
78 : 0 : if (parent_ns->level > 32)
79 : : goto fail;
80 : :
81 : : ucounts = inc_user_namespaces(parent_ns, owner);
82 : 0 : if (!ucounts)
83 : : goto fail;
84 : :
85 : : /*
86 : : * Verify that we can not violate the policy of which files
87 : : * may be accessed that is specified by the root directory,
88 : : * by verifing that the root directory is at the root of the
89 : : * mount namespace which allows all files to be accessed.
90 : : */
91 : : ret = -EPERM;
92 : 0 : if (current_chrooted())
93 : : goto fail_dec;
94 : :
95 : : /* The creator needs a mapping in the parent user namespace
96 : : * or else we won't be able to reasonably tell userspace who
97 : : * created a user_namespace.
98 : : */
99 : : ret = -EPERM;
100 : 0 : if (!kuid_has_mapping(parent_ns, owner) ||
101 : : !kgid_has_mapping(parent_ns, group))
102 : : goto fail_dec;
103 : :
104 : : ret = -ENOMEM;
105 : 0 : ns = kmem_cache_zalloc(user_ns_cachep, GFP_KERNEL);
106 : 0 : if (!ns)
107 : : goto fail_dec;
108 : :
109 : : ret = ns_alloc_inum(&ns->ns);
110 : 0 : if (ret)
111 : : goto fail_free;
112 : 0 : ns->ns.ops = &userns_operations;
113 : :
114 : : atomic_set(&ns->count, 1);
115 : : /* Leave the new->user_ns reference with the new user namespace. */
116 : 0 : ns->parent = parent_ns;
117 : 0 : ns->level = parent_ns->level + 1;
118 : 0 : ns->owner = owner;
119 : 0 : ns->group = group;
120 : 0 : INIT_WORK(&ns->work, free_user_ns);
121 : 0 : for (i = 0; i < UCOUNT_COUNTS; i++) {
122 : 0 : ns->ucount_max[i] = INT_MAX;
123 : : }
124 : 0 : ns->ucounts = ucounts;
125 : :
126 : : /* Inherit USERNS_SETGROUPS_ALLOWED from our parent */
127 : 0 : mutex_lock(&userns_state_mutex);
128 : 0 : ns->flags = parent_ns->flags;
129 : 0 : mutex_unlock(&userns_state_mutex);
130 : :
131 : : #ifdef CONFIG_KEYS
132 : 0 : INIT_LIST_HEAD(&ns->keyring_name_list);
133 : 0 : init_rwsem(&ns->keyring_sem);
134 : : #endif
135 : : ret = -ENOMEM;
136 : 0 : if (!setup_userns_sysctls(ns))
137 : : goto fail_keyring;
138 : :
139 : 0 : set_cred_user_ns(new, ns);
140 : 0 : return 0;
141 : : fail_keyring:
142 : : #ifdef CONFIG_PERSISTENT_KEYRINGS
143 : : key_put(ns->persistent_keyring_register);
144 : : #endif
145 : 0 : ns_free_inum(&ns->ns);
146 : : fail_free:
147 : 0 : kmem_cache_free(user_ns_cachep, ns);
148 : : fail_dec:
149 : : dec_user_namespaces(ucounts);
150 : : fail:
151 : 0 : return ret;
152 : : }
153 : :
154 : 3 : int unshare_userns(unsigned long unshare_flags, struct cred **new_cred)
155 : : {
156 : : struct cred *cred;
157 : : int err = -ENOMEM;
158 : :
159 : 3 : if (!(unshare_flags & CLONE_NEWUSER))
160 : : return 0;
161 : :
162 : 0 : cred = prepare_creds();
163 : 0 : if (cred) {
164 : 0 : err = create_user_ns(cred);
165 : 0 : if (err)
166 : 0 : put_cred(cred);
167 : : else
168 : 0 : *new_cred = cred;
169 : : }
170 : :
171 : 0 : return err;
172 : : }
173 : :
174 : 0 : static void free_user_ns(struct work_struct *work)
175 : : {
176 : : struct user_namespace *parent, *ns =
177 : 0 : container_of(work, struct user_namespace, work);
178 : :
179 : : do {
180 : 0 : struct ucounts *ucounts = ns->ucounts;
181 : 0 : parent = ns->parent;
182 : 0 : if (ns->gid_map.nr_extents > UID_GID_MAP_MAX_BASE_EXTENTS) {
183 : 0 : kfree(ns->gid_map.forward);
184 : 0 : kfree(ns->gid_map.reverse);
185 : : }
186 : 0 : if (ns->uid_map.nr_extents > UID_GID_MAP_MAX_BASE_EXTENTS) {
187 : 0 : kfree(ns->uid_map.forward);
188 : 0 : kfree(ns->uid_map.reverse);
189 : : }
190 : 0 : if (ns->projid_map.nr_extents > UID_GID_MAP_MAX_BASE_EXTENTS) {
191 : 0 : kfree(ns->projid_map.forward);
192 : 0 : kfree(ns->projid_map.reverse);
193 : : }
194 : 0 : retire_userns_sysctls(ns);
195 : 0 : key_free_user_ns(ns);
196 : 0 : ns_free_inum(&ns->ns);
197 : 0 : kmem_cache_free(user_ns_cachep, ns);
198 : : dec_user_namespaces(ucounts);
199 : : ns = parent;
200 : 0 : } while (atomic_dec_and_test(&parent->count));
201 : 0 : }
202 : :
203 : 0 : void __put_user_ns(struct user_namespace *ns)
204 : : {
205 : 0 : schedule_work(&ns->work);
206 : 0 : }
207 : : EXPORT_SYMBOL(__put_user_ns);
208 : :
209 : : /**
210 : : * idmap_key struct holds the information necessary to find an idmapping in a
211 : : * sorted idmap array. It is passed to cmp_map_id() as first argument.
212 : : */
213 : : struct idmap_key {
214 : : bool map_up; /* true -> id from kid; false -> kid from id */
215 : : u32 id; /* id to find */
216 : : u32 count; /* == 0 unless used with map_id_range_down() */
217 : : };
218 : :
219 : : /**
220 : : * cmp_map_id - Function to be passed to bsearch() to find the requested
221 : : * idmapping. Expects struct idmap_key to be passed via @k.
222 : : */
223 : 0 : static int cmp_map_id(const void *k, const void *e)
224 : : {
225 : : u32 first, last, id2;
226 : : const struct idmap_key *key = k;
227 : : const struct uid_gid_extent *el = e;
228 : :
229 : 0 : id2 = key->id + key->count - 1;
230 : :
231 : : /* handle map_id_{down,up}() */
232 : 0 : if (key->map_up)
233 : 0 : first = el->lower_first;
234 : : else
235 : 0 : first = el->first;
236 : :
237 : 0 : last = first + el->count - 1;
238 : :
239 : 0 : if (key->id >= first && key->id <= last &&
240 : 0 : (id2 >= first && id2 <= last))
241 : : return 0;
242 : :
243 : 0 : if (key->id < first || id2 < first)
244 : : return -1;
245 : :
246 : 0 : return 1;
247 : : }
248 : :
249 : : /**
250 : : * map_id_range_down_max - Find idmap via binary search in ordered idmap array.
251 : : * Can only be called if number of mappings exceeds UID_GID_MAP_MAX_BASE_EXTENTS.
252 : : */
253 : : static struct uid_gid_extent *
254 : : map_id_range_down_max(unsigned extents, struct uid_gid_map *map, u32 id, u32 count)
255 : : {
256 : : struct idmap_key key;
257 : :
258 : 0 : key.map_up = false;
259 : 0 : key.count = count;
260 : 0 : key.id = id;
261 : :
262 : 0 : return bsearch(&key, map->forward, extents,
263 : : sizeof(struct uid_gid_extent), cmp_map_id);
264 : : }
265 : :
266 : : /**
267 : : * map_id_range_down_base - Find idmap via binary search in static extent array.
268 : : * Can only be called if number of mappings is equal or less than
269 : : * UID_GID_MAP_MAX_BASE_EXTENTS.
270 : : */
271 : : static struct uid_gid_extent *
272 : 3 : map_id_range_down_base(unsigned extents, struct uid_gid_map *map, u32 id, u32 count)
273 : : {
274 : : unsigned idx;
275 : : u32 first, last, id2;
276 : :
277 : 3 : id2 = id + count - 1;
278 : :
279 : : /* Find the matching extent */
280 : 3 : for (idx = 0; idx < extents; idx++) {
281 : 3 : first = map->extent[idx].first;
282 : 3 : last = first + map->extent[idx].count - 1;
283 : 3 : if (id >= first && id <= last &&
284 : 3 : (id2 >= first && id2 <= last))
285 : 3 : return &map->extent[idx];
286 : : }
287 : : return NULL;
288 : : }
289 : :
290 : 3 : static u32 map_id_range_down(struct uid_gid_map *map, u32 id, u32 count)
291 : : {
292 : : struct uid_gid_extent *extent;
293 : 3 : unsigned extents = map->nr_extents;
294 : 3 : smp_rmb();
295 : :
296 : 3 : if (extents <= UID_GID_MAP_MAX_BASE_EXTENTS)
297 : 3 : extent = map_id_range_down_base(extents, map, id, count);
298 : : else
299 : : extent = map_id_range_down_max(extents, map, id, count);
300 : :
301 : : /* Map the id or note failure */
302 : 3 : if (extent)
303 : 3 : id = (id - extent->first) + extent->lower_first;
304 : : else
305 : : id = (u32) -1;
306 : :
307 : 3 : return id;
308 : : }
309 : :
310 : : static u32 map_id_down(struct uid_gid_map *map, u32 id)
311 : : {
312 : 3 : return map_id_range_down(map, id, 1);
313 : : }
314 : :
315 : : /**
316 : : * map_id_up_base - Find idmap via binary search in static extent array.
317 : : * Can only be called if number of mappings is equal or less than
318 : : * UID_GID_MAP_MAX_BASE_EXTENTS.
319 : : */
320 : : static struct uid_gid_extent *
321 : : map_id_up_base(unsigned extents, struct uid_gid_map *map, u32 id)
322 : : {
323 : : unsigned idx;
324 : : u32 first, last;
325 : :
326 : : /* Find the matching extent */
327 : 3 : for (idx = 0; idx < extents; idx++) {
328 : 3 : first = map->extent[idx].lower_first;
329 : 3 : last = first + map->extent[idx].count - 1;
330 : 3 : if (id >= first && id <= last)
331 : 3 : return &map->extent[idx];
332 : : }
333 : : return NULL;
334 : : }
335 : :
336 : : /**
337 : : * map_id_up_max - Find idmap via binary search in ordered idmap array.
338 : : * Can only be called if number of mappings exceeds UID_GID_MAP_MAX_BASE_EXTENTS.
339 : : */
340 : : static struct uid_gid_extent *
341 : 0 : map_id_up_max(unsigned extents, struct uid_gid_map *map, u32 id)
342 : : {
343 : : struct idmap_key key;
344 : :
345 : 0 : key.map_up = true;
346 : 0 : key.count = 1;
347 : 0 : key.id = id;
348 : :
349 : 0 : return bsearch(&key, map->reverse, extents,
350 : : sizeof(struct uid_gid_extent), cmp_map_id);
351 : : }
352 : :
353 : 3 : static u32 map_id_up(struct uid_gid_map *map, u32 id)
354 : : {
355 : : struct uid_gid_extent *extent;
356 : 3 : unsigned extents = map->nr_extents;
357 : 3 : smp_rmb();
358 : :
359 : 3 : if (extents <= UID_GID_MAP_MAX_BASE_EXTENTS)
360 : : extent = map_id_up_base(extents, map, id);
361 : : else
362 : 0 : extent = map_id_up_max(extents, map, id);
363 : :
364 : : /* Map the id or note failure */
365 : 3 : if (extent)
366 : 3 : id = (id - extent->lower_first) + extent->first;
367 : : else
368 : : id = (u32) -1;
369 : :
370 : 3 : return id;
371 : : }
372 : :
373 : : /**
374 : : * make_kuid - Map a user-namespace uid pair into a kuid.
375 : : * @ns: User namespace that the uid is in
376 : : * @uid: User identifier
377 : : *
378 : : * Maps a user-namespace uid pair into a kernel internal kuid,
379 : : * and returns that kuid.
380 : : *
381 : : * When there is no mapping defined for the user-namespace uid
382 : : * pair INVALID_UID is returned. Callers are expected to test
383 : : * for and handle INVALID_UID being returned. INVALID_UID
384 : : * may be tested for using uid_valid().
385 : : */
386 : 3 : kuid_t make_kuid(struct user_namespace *ns, uid_t uid)
387 : : {
388 : : /* Map the uid to a global kernel uid */
389 : 3 : return KUIDT_INIT(map_id_down(&ns->uid_map, uid));
390 : : }
391 : : EXPORT_SYMBOL(make_kuid);
392 : :
393 : : /**
394 : : * from_kuid - Create a uid from a kuid user-namespace pair.
395 : : * @targ: The user namespace we want a uid in.
396 : : * @kuid: The kernel internal uid to start with.
397 : : *
398 : : * Map @kuid into the user-namespace specified by @targ and
399 : : * return the resulting uid.
400 : : *
401 : : * There is always a mapping into the initial user_namespace.
402 : : *
403 : : * If @kuid has no mapping in @targ (uid_t)-1 is returned.
404 : : */
405 : 3 : uid_t from_kuid(struct user_namespace *targ, kuid_t kuid)
406 : : {
407 : : /* Map the uid from a global kernel uid */
408 : 3 : return map_id_up(&targ->uid_map, __kuid_val(kuid));
409 : : }
410 : : EXPORT_SYMBOL(from_kuid);
411 : :
412 : : /**
413 : : * from_kuid_munged - Create a uid from a kuid user-namespace pair.
414 : : * @targ: The user namespace we want a uid in.
415 : : * @kuid: The kernel internal uid to start with.
416 : : *
417 : : * Map @kuid into the user-namespace specified by @targ and
418 : : * return the resulting uid.
419 : : *
420 : : * There is always a mapping into the initial user_namespace.
421 : : *
422 : : * Unlike from_kuid from_kuid_munged never fails and always
423 : : * returns a valid uid. This makes from_kuid_munged appropriate
424 : : * for use in syscalls like stat and getuid where failing the
425 : : * system call and failing to provide a valid uid are not an
426 : : * options.
427 : : *
428 : : * If @kuid has no mapping in @targ overflowuid is returned.
429 : : */
430 : 3 : uid_t from_kuid_munged(struct user_namespace *targ, kuid_t kuid)
431 : : {
432 : : uid_t uid;
433 : : uid = from_kuid(targ, kuid);
434 : :
435 : 3 : if (uid == (uid_t) -1)
436 : 0 : uid = overflowuid;
437 : 3 : return uid;
438 : : }
439 : : EXPORT_SYMBOL(from_kuid_munged);
440 : :
441 : : /**
442 : : * make_kgid - Map a user-namespace gid pair into a kgid.
443 : : * @ns: User namespace that the gid is in
444 : : * @gid: group identifier
445 : : *
446 : : * Maps a user-namespace gid pair into a kernel internal kgid,
447 : : * and returns that kgid.
448 : : *
449 : : * When there is no mapping defined for the user-namespace gid
450 : : * pair INVALID_GID is returned. Callers are expected to test
451 : : * for and handle INVALID_GID being returned. INVALID_GID may be
452 : : * tested for using gid_valid().
453 : : */
454 : 3 : kgid_t make_kgid(struct user_namespace *ns, gid_t gid)
455 : : {
456 : : /* Map the gid to a global kernel gid */
457 : 3 : return KGIDT_INIT(map_id_down(&ns->gid_map, gid));
458 : : }
459 : : EXPORT_SYMBOL(make_kgid);
460 : :
461 : : /**
462 : : * from_kgid - Create a gid from a kgid user-namespace pair.
463 : : * @targ: The user namespace we want a gid in.
464 : : * @kgid: The kernel internal gid to start with.
465 : : *
466 : : * Map @kgid into the user-namespace specified by @targ and
467 : : * return the resulting gid.
468 : : *
469 : : * There is always a mapping into the initial user_namespace.
470 : : *
471 : : * If @kgid has no mapping in @targ (gid_t)-1 is returned.
472 : : */
473 : 3 : gid_t from_kgid(struct user_namespace *targ, kgid_t kgid)
474 : : {
475 : : /* Map the gid from a global kernel gid */
476 : 3 : return map_id_up(&targ->gid_map, __kgid_val(kgid));
477 : : }
478 : : EXPORT_SYMBOL(from_kgid);
479 : :
480 : : /**
481 : : * from_kgid_munged - Create a gid from a kgid user-namespace pair.
482 : : * @targ: The user namespace we want a gid in.
483 : : * @kgid: The kernel internal gid to start with.
484 : : *
485 : : * Map @kgid into the user-namespace specified by @targ and
486 : : * return the resulting gid.
487 : : *
488 : : * There is always a mapping into the initial user_namespace.
489 : : *
490 : : * Unlike from_kgid from_kgid_munged never fails and always
491 : : * returns a valid gid. This makes from_kgid_munged appropriate
492 : : * for use in syscalls like stat and getgid where failing the
493 : : * system call and failing to provide a valid gid are not options.
494 : : *
495 : : * If @kgid has no mapping in @targ overflowgid is returned.
496 : : */
497 : 3 : gid_t from_kgid_munged(struct user_namespace *targ, kgid_t kgid)
498 : : {
499 : : gid_t gid;
500 : : gid = from_kgid(targ, kgid);
501 : :
502 : 3 : if (gid == (gid_t) -1)
503 : 0 : gid = overflowgid;
504 : 3 : return gid;
505 : : }
506 : : EXPORT_SYMBOL(from_kgid_munged);
507 : :
508 : : /**
509 : : * make_kprojid - Map a user-namespace projid pair into a kprojid.
510 : : * @ns: User namespace that the projid is in
511 : : * @projid: Project identifier
512 : : *
513 : : * Maps a user-namespace uid pair into a kernel internal kuid,
514 : : * and returns that kuid.
515 : : *
516 : : * When there is no mapping defined for the user-namespace projid
517 : : * pair INVALID_PROJID is returned. Callers are expected to test
518 : : * for and handle handle INVALID_PROJID being returned. INVALID_PROJID
519 : : * may be tested for using projid_valid().
520 : : */
521 : 3 : kprojid_t make_kprojid(struct user_namespace *ns, projid_t projid)
522 : : {
523 : : /* Map the uid to a global kernel uid */
524 : 3 : return KPROJIDT_INIT(map_id_down(&ns->projid_map, projid));
525 : : }
526 : : EXPORT_SYMBOL(make_kprojid);
527 : :
528 : : /**
529 : : * from_kprojid - Create a projid from a kprojid user-namespace pair.
530 : : * @targ: The user namespace we want a projid in.
531 : : * @kprojid: The kernel internal project identifier to start with.
532 : : *
533 : : * Map @kprojid into the user-namespace specified by @targ and
534 : : * return the resulting projid.
535 : : *
536 : : * There is always a mapping into the initial user_namespace.
537 : : *
538 : : * If @kprojid has no mapping in @targ (projid_t)-1 is returned.
539 : : */
540 : 3 : projid_t from_kprojid(struct user_namespace *targ, kprojid_t kprojid)
541 : : {
542 : : /* Map the uid from a global kernel uid */
543 : 3 : return map_id_up(&targ->projid_map, __kprojid_val(kprojid));
544 : : }
545 : : EXPORT_SYMBOL(from_kprojid);
546 : :
547 : : /**
548 : : * from_kprojid_munged - Create a projiid from a kprojid user-namespace pair.
549 : : * @targ: The user namespace we want a projid in.
550 : : * @kprojid: The kernel internal projid to start with.
551 : : *
552 : : * Map @kprojid into the user-namespace specified by @targ and
553 : : * return the resulting projid.
554 : : *
555 : : * There is always a mapping into the initial user_namespace.
556 : : *
557 : : * Unlike from_kprojid from_kprojid_munged never fails and always
558 : : * returns a valid projid. This makes from_kprojid_munged
559 : : * appropriate for use in syscalls like stat and where
560 : : * failing the system call and failing to provide a valid projid are
561 : : * not an options.
562 : : *
563 : : * If @kprojid has no mapping in @targ OVERFLOW_PROJID is returned.
564 : : */
565 : 0 : projid_t from_kprojid_munged(struct user_namespace *targ, kprojid_t kprojid)
566 : : {
567 : : projid_t projid;
568 : : projid = from_kprojid(targ, kprojid);
569 : :
570 : 0 : if (projid == (projid_t) -1)
571 : : projid = OVERFLOW_PROJID;
572 : 0 : return projid;
573 : : }
574 : : EXPORT_SYMBOL(from_kprojid_munged);
575 : :
576 : :
577 : 3 : static int uid_m_show(struct seq_file *seq, void *v)
578 : : {
579 : 3 : struct user_namespace *ns = seq->private;
580 : : struct uid_gid_extent *extent = v;
581 : : struct user_namespace *lower_ns;
582 : : uid_t lower;
583 : :
584 : : lower_ns = seq_user_ns(seq);
585 : 3 : if ((lower_ns == ns) && lower_ns->parent)
586 : : lower_ns = lower_ns->parent;
587 : :
588 : 3 : lower = from_kuid(lower_ns, KUIDT_INIT(extent->lower_first));
589 : :
590 : 3 : seq_printf(seq, "%10u %10u %10u\n",
591 : : extent->first,
592 : : lower,
593 : : extent->count);
594 : :
595 : 3 : return 0;
596 : : }
597 : :
598 : 3 : static int gid_m_show(struct seq_file *seq, void *v)
599 : : {
600 : 3 : struct user_namespace *ns = seq->private;
601 : : struct uid_gid_extent *extent = v;
602 : : struct user_namespace *lower_ns;
603 : : gid_t lower;
604 : :
605 : : lower_ns = seq_user_ns(seq);
606 : 3 : if ((lower_ns == ns) && lower_ns->parent)
607 : : lower_ns = lower_ns->parent;
608 : :
609 : 3 : lower = from_kgid(lower_ns, KGIDT_INIT(extent->lower_first));
610 : :
611 : 3 : seq_printf(seq, "%10u %10u %10u\n",
612 : : extent->first,
613 : : lower,
614 : : extent->count);
615 : :
616 : 3 : return 0;
617 : : }
618 : :
619 : 0 : static int projid_m_show(struct seq_file *seq, void *v)
620 : : {
621 : 0 : struct user_namespace *ns = seq->private;
622 : : struct uid_gid_extent *extent = v;
623 : : struct user_namespace *lower_ns;
624 : : projid_t lower;
625 : :
626 : : lower_ns = seq_user_ns(seq);
627 : 0 : if ((lower_ns == ns) && lower_ns->parent)
628 : : lower_ns = lower_ns->parent;
629 : :
630 : 0 : lower = from_kprojid(lower_ns, KPROJIDT_INIT(extent->lower_first));
631 : :
632 : 0 : seq_printf(seq, "%10u %10u %10u\n",
633 : : extent->first,
634 : : lower,
635 : : extent->count);
636 : :
637 : 0 : return 0;
638 : : }
639 : :
640 : : static void *m_start(struct seq_file *seq, loff_t *ppos,
641 : : struct uid_gid_map *map)
642 : : {
643 : 3 : loff_t pos = *ppos;
644 : 3 : unsigned extents = map->nr_extents;
645 : 3 : smp_rmb();
646 : :
647 : 3 : if (pos >= extents)
648 : : return NULL;
649 : :
650 : 3 : if (extents <= UID_GID_MAP_MAX_BASE_EXTENTS)
651 : 3 : return &map->extent[pos];
652 : :
653 : 0 : return &map->forward[pos];
654 : : }
655 : :
656 : 3 : static void *uid_m_start(struct seq_file *seq, loff_t *ppos)
657 : : {
658 : 3 : struct user_namespace *ns = seq->private;
659 : :
660 : 3 : return m_start(seq, ppos, &ns->uid_map);
661 : : }
662 : :
663 : 3 : static void *gid_m_start(struct seq_file *seq, loff_t *ppos)
664 : : {
665 : 3 : struct user_namespace *ns = seq->private;
666 : :
667 : 3 : return m_start(seq, ppos, &ns->gid_map);
668 : : }
669 : :
670 : 0 : static void *projid_m_start(struct seq_file *seq, loff_t *ppos)
671 : : {
672 : 0 : struct user_namespace *ns = seq->private;
673 : :
674 : 0 : return m_start(seq, ppos, &ns->projid_map);
675 : : }
676 : :
677 : 3 : static void *m_next(struct seq_file *seq, void *v, loff_t *pos)
678 : : {
679 : 3 : (*pos)++;
680 : 3 : return seq->op->start(seq, pos);
681 : : }
682 : :
683 : 3 : static void m_stop(struct seq_file *seq, void *v)
684 : : {
685 : 3 : return;
686 : : }
687 : :
688 : : const struct seq_operations proc_uid_seq_operations = {
689 : : .start = uid_m_start,
690 : : .stop = m_stop,
691 : : .next = m_next,
692 : : .show = uid_m_show,
693 : : };
694 : :
695 : : const struct seq_operations proc_gid_seq_operations = {
696 : : .start = gid_m_start,
697 : : .stop = m_stop,
698 : : .next = m_next,
699 : : .show = gid_m_show,
700 : : };
701 : :
702 : : const struct seq_operations proc_projid_seq_operations = {
703 : : .start = projid_m_start,
704 : : .stop = m_stop,
705 : : .next = m_next,
706 : : .show = projid_m_show,
707 : : };
708 : :
709 : 0 : static bool mappings_overlap(struct uid_gid_map *new_map,
710 : : struct uid_gid_extent *extent)
711 : : {
712 : : u32 upper_first, lower_first, upper_last, lower_last;
713 : : unsigned idx;
714 : :
715 : 0 : upper_first = extent->first;
716 : 0 : lower_first = extent->lower_first;
717 : 0 : upper_last = upper_first + extent->count - 1;
718 : 0 : lower_last = lower_first + extent->count - 1;
719 : :
720 : 0 : for (idx = 0; idx < new_map->nr_extents; idx++) {
721 : : u32 prev_upper_first, prev_lower_first;
722 : : u32 prev_upper_last, prev_lower_last;
723 : : struct uid_gid_extent *prev;
724 : :
725 : 0 : if (new_map->nr_extents <= UID_GID_MAP_MAX_BASE_EXTENTS)
726 : 0 : prev = &new_map->extent[idx];
727 : : else
728 : 0 : prev = &new_map->forward[idx];
729 : :
730 : 0 : prev_upper_first = prev->first;
731 : 0 : prev_lower_first = prev->lower_first;
732 : 0 : prev_upper_last = prev_upper_first + prev->count - 1;
733 : 0 : prev_lower_last = prev_lower_first + prev->count - 1;
734 : :
735 : : /* Does the upper range intersect a previous extent? */
736 : 0 : if ((prev_upper_first <= upper_last) &&
737 : 0 : (prev_upper_last >= upper_first))
738 : : return true;
739 : :
740 : : /* Does the lower range intersect a previous extent? */
741 : 0 : if ((prev_lower_first <= lower_last) &&
742 : 0 : (prev_lower_last >= lower_first))
743 : : return true;
744 : : }
745 : : return false;
746 : : }
747 : :
748 : : /**
749 : : * insert_extent - Safely insert a new idmap extent into struct uid_gid_map.
750 : : * Takes care to allocate a 4K block of memory if the number of mappings exceeds
751 : : * UID_GID_MAP_MAX_BASE_EXTENTS.
752 : : */
753 : 0 : static int insert_extent(struct uid_gid_map *map, struct uid_gid_extent *extent)
754 : : {
755 : : struct uid_gid_extent *dest;
756 : :
757 : 0 : if (map->nr_extents == UID_GID_MAP_MAX_BASE_EXTENTS) {
758 : : struct uid_gid_extent *forward;
759 : :
760 : : /* Allocate memory for 340 mappings. */
761 : 0 : forward = kmalloc_array(UID_GID_MAP_MAX_EXTENTS,
762 : : sizeof(struct uid_gid_extent),
763 : : GFP_KERNEL);
764 : 0 : if (!forward)
765 : : return -ENOMEM;
766 : :
767 : : /* Copy over memory. Only set up memory for the forward pointer.
768 : : * Defer the memory setup for the reverse pointer.
769 : : */
770 : 0 : memcpy(forward, map->extent,
771 : 0 : map->nr_extents * sizeof(map->extent[0]));
772 : :
773 : 0 : map->forward = forward;
774 : 0 : map->reverse = NULL;
775 : : }
776 : :
777 : 0 : if (map->nr_extents < UID_GID_MAP_MAX_BASE_EXTENTS)
778 : 0 : dest = &map->extent[map->nr_extents];
779 : : else
780 : 0 : dest = &map->forward[map->nr_extents];
781 : :
782 : 0 : *dest = *extent;
783 : 0 : map->nr_extents++;
784 : 0 : return 0;
785 : : }
786 : :
787 : : /* cmp function to sort() forward mappings */
788 : 0 : static int cmp_extents_forward(const void *a, const void *b)
789 : : {
790 : : const struct uid_gid_extent *e1 = a;
791 : : const struct uid_gid_extent *e2 = b;
792 : :
793 : 0 : if (e1->first < e2->first)
794 : : return -1;
795 : :
796 : 0 : if (e1->first > e2->first)
797 : : return 1;
798 : :
799 : 0 : return 0;
800 : : }
801 : :
802 : : /* cmp function to sort() reverse mappings */
803 : 0 : static int cmp_extents_reverse(const void *a, const void *b)
804 : : {
805 : : const struct uid_gid_extent *e1 = a;
806 : : const struct uid_gid_extent *e2 = b;
807 : :
808 : 0 : if (e1->lower_first < e2->lower_first)
809 : : return -1;
810 : :
811 : 0 : if (e1->lower_first > e2->lower_first)
812 : : return 1;
813 : :
814 : 0 : return 0;
815 : : }
816 : :
817 : : /**
818 : : * sort_idmaps - Sorts an array of idmap entries.
819 : : * Can only be called if number of mappings exceeds UID_GID_MAP_MAX_BASE_EXTENTS.
820 : : */
821 : 0 : static int sort_idmaps(struct uid_gid_map *map)
822 : : {
823 : 0 : if (map->nr_extents <= UID_GID_MAP_MAX_BASE_EXTENTS)
824 : : return 0;
825 : :
826 : : /* Sort forward array. */
827 : 0 : sort(map->forward, map->nr_extents, sizeof(struct uid_gid_extent),
828 : : cmp_extents_forward, NULL);
829 : :
830 : : /* Only copy the memory from forward we actually need. */
831 : 0 : map->reverse = kmemdup(map->forward,
832 : 0 : map->nr_extents * sizeof(struct uid_gid_extent),
833 : : GFP_KERNEL);
834 : 0 : if (!map->reverse)
835 : : return -ENOMEM;
836 : :
837 : : /* Sort reverse array. */
838 : 0 : sort(map->reverse, map->nr_extents, sizeof(struct uid_gid_extent),
839 : : cmp_extents_reverse, NULL);
840 : :
841 : 0 : return 0;
842 : : }
843 : :
844 : 0 : static ssize_t map_write(struct file *file, const char __user *buf,
845 : : size_t count, loff_t *ppos,
846 : : int cap_setid,
847 : : struct uid_gid_map *map,
848 : : struct uid_gid_map *parent_map)
849 : : {
850 : 0 : struct seq_file *seq = file->private_data;
851 : 0 : struct user_namespace *ns = seq->private;
852 : : struct uid_gid_map new_map;
853 : : unsigned idx;
854 : : struct uid_gid_extent extent;
855 : : char *kbuf = NULL, *pos, *next_line;
856 : : ssize_t ret;
857 : :
858 : : /* Only allow < page size writes at the beginning of the file */
859 : 0 : if ((*ppos != 0) || (count >= PAGE_SIZE))
860 : : return -EINVAL;
861 : :
862 : : /* Slurp in the user data */
863 : 0 : kbuf = memdup_user_nul(buf, count);
864 : 0 : if (IS_ERR(kbuf))
865 : 0 : return PTR_ERR(kbuf);
866 : :
867 : : /*
868 : : * The userns_state_mutex serializes all writes to any given map.
869 : : *
870 : : * Any map is only ever written once.
871 : : *
872 : : * An id map fits within 1 cache line on most architectures.
873 : : *
874 : : * On read nothing needs to be done unless you are on an
875 : : * architecture with a crazy cache coherency model like alpha.
876 : : *
877 : : * There is a one time data dependency between reading the
878 : : * count of the extents and the values of the extents. The
879 : : * desired behavior is to see the values of the extents that
880 : : * were written before the count of the extents.
881 : : *
882 : : * To achieve this smp_wmb() is used on guarantee the write
883 : : * order and smp_rmb() is guaranteed that we don't have crazy
884 : : * architectures returning stale data.
885 : : */
886 : 0 : mutex_lock(&userns_state_mutex);
887 : :
888 : 0 : memset(&new_map, 0, sizeof(struct uid_gid_map));
889 : :
890 : : ret = -EPERM;
891 : : /* Only allow one successful write to the map */
892 : 0 : if (map->nr_extents != 0)
893 : : goto out;
894 : :
895 : : /*
896 : : * Adjusting namespace settings requires capabilities on the target.
897 : : */
898 : 0 : if (cap_valid(cap_setid) && !file_ns_capable(file, ns, CAP_SYS_ADMIN))
899 : : goto out;
900 : :
901 : : /* Parse the user data */
902 : : ret = -EINVAL;
903 : 0 : pos = kbuf;
904 : 0 : for (; pos; pos = next_line) {
905 : :
906 : : /* Find the end of line and ensure I don't look past it */
907 : 0 : next_line = strchr(pos, '\n');
908 : 0 : if (next_line) {
909 : 0 : *next_line = '\0';
910 : 0 : next_line++;
911 : 0 : if (*next_line == '\0')
912 : : next_line = NULL;
913 : : }
914 : :
915 : 0 : pos = skip_spaces(pos);
916 : 0 : extent.first = simple_strtoul(pos, &pos, 10);
917 : 0 : if (!isspace(*pos))
918 : : goto out;
919 : :
920 : 0 : pos = skip_spaces(pos);
921 : 0 : extent.lower_first = simple_strtoul(pos, &pos, 10);
922 : 0 : if (!isspace(*pos))
923 : : goto out;
924 : :
925 : 0 : pos = skip_spaces(pos);
926 : 0 : extent.count = simple_strtoul(pos, &pos, 10);
927 : 0 : if (*pos && !isspace(*pos))
928 : : goto out;
929 : :
930 : : /* Verify there is not trailing junk on the line */
931 : 0 : pos = skip_spaces(pos);
932 : 0 : if (*pos != '\0')
933 : : goto out;
934 : :
935 : : /* Verify we have been given valid starting values */
936 : 0 : if ((extent.first == (u32) -1) ||
937 : 0 : (extent.lower_first == (u32) -1))
938 : : goto out;
939 : :
940 : : /* Verify count is not zero and does not cause the
941 : : * extent to wrap
942 : : */
943 : 0 : if ((extent.first + extent.count) <= extent.first)
944 : : goto out;
945 : 0 : if ((extent.lower_first + extent.count) <=
946 : : extent.lower_first)
947 : : goto out;
948 : :
949 : : /* Do the ranges in extent overlap any previous extents? */
950 : 0 : if (mappings_overlap(&new_map, &extent))
951 : : goto out;
952 : :
953 : 0 : if ((new_map.nr_extents + 1) == UID_GID_MAP_MAX_EXTENTS &&
954 : : (next_line != NULL))
955 : : goto out;
956 : :
957 : 0 : ret = insert_extent(&new_map, &extent);
958 : 0 : if (ret < 0)
959 : : goto out;
960 : : ret = -EINVAL;
961 : : }
962 : : /* Be very certaint the new map actually exists */
963 : 0 : if (new_map.nr_extents == 0)
964 : : goto out;
965 : :
966 : : ret = -EPERM;
967 : : /* Validate the user is allowed to use user id's mapped to. */
968 : 0 : if (!new_idmap_permitted(file, ns, cap_setid, &new_map))
969 : : goto out;
970 : :
971 : : ret = -EPERM;
972 : : /* Map the lower ids from the parent user namespace to the
973 : : * kernel global id space.
974 : : */
975 : 0 : for (idx = 0; idx < new_map.nr_extents; idx++) {
976 : : struct uid_gid_extent *e;
977 : : u32 lower_first;
978 : :
979 : 0 : if (new_map.nr_extents <= UID_GID_MAP_MAX_BASE_EXTENTS)
980 : 0 : e = &new_map.extent[idx];
981 : : else
982 : 0 : e = &new_map.forward[idx];
983 : :
984 : 0 : lower_first = map_id_range_down(parent_map,
985 : : e->lower_first,
986 : : e->count);
987 : :
988 : : /* Fail if we can not map the specified extent to
989 : : * the kernel global id space.
990 : : */
991 : 0 : if (lower_first == (u32) -1)
992 : : goto out;
993 : :
994 : 0 : e->lower_first = lower_first;
995 : : }
996 : :
997 : : /*
998 : : * If we want to use binary search for lookup, this clones the extent
999 : : * array and sorts both copies.
1000 : : */
1001 : 0 : ret = sort_idmaps(&new_map);
1002 : 0 : if (ret < 0)
1003 : : goto out;
1004 : :
1005 : : /* Install the map */
1006 : 0 : if (new_map.nr_extents <= UID_GID_MAP_MAX_BASE_EXTENTS) {
1007 : 0 : memcpy(map->extent, new_map.extent,
1008 : : new_map.nr_extents * sizeof(new_map.extent[0]));
1009 : : } else {
1010 : 0 : map->forward = new_map.forward;
1011 : 0 : map->reverse = new_map.reverse;
1012 : : }
1013 : 0 : smp_wmb();
1014 : 0 : map->nr_extents = new_map.nr_extents;
1015 : :
1016 : 0 : *ppos = count;
1017 : 0 : ret = count;
1018 : : out:
1019 : 0 : if (ret < 0 && new_map.nr_extents > UID_GID_MAP_MAX_BASE_EXTENTS) {
1020 : 0 : kfree(new_map.forward);
1021 : 0 : kfree(new_map.reverse);
1022 : 0 : map->forward = NULL;
1023 : 0 : map->reverse = NULL;
1024 : 0 : map->nr_extents = 0;
1025 : : }
1026 : :
1027 : 0 : mutex_unlock(&userns_state_mutex);
1028 : 0 : kfree(kbuf);
1029 : 0 : return ret;
1030 : : }
1031 : :
1032 : 0 : ssize_t proc_uid_map_write(struct file *file, const char __user *buf,
1033 : : size_t size, loff_t *ppos)
1034 : : {
1035 : 0 : struct seq_file *seq = file->private_data;
1036 : 0 : struct user_namespace *ns = seq->private;
1037 : : struct user_namespace *seq_ns = seq_user_ns(seq);
1038 : :
1039 : 0 : if (!ns->parent)
1040 : : return -EPERM;
1041 : :
1042 : 0 : if ((seq_ns != ns) && (seq_ns != ns->parent))
1043 : : return -EPERM;
1044 : :
1045 : 0 : return map_write(file, buf, size, ppos, CAP_SETUID,
1046 : : &ns->uid_map, &ns->parent->uid_map);
1047 : : }
1048 : :
1049 : 0 : ssize_t proc_gid_map_write(struct file *file, const char __user *buf,
1050 : : size_t size, loff_t *ppos)
1051 : : {
1052 : 0 : struct seq_file *seq = file->private_data;
1053 : 0 : struct user_namespace *ns = seq->private;
1054 : : struct user_namespace *seq_ns = seq_user_ns(seq);
1055 : :
1056 : 0 : if (!ns->parent)
1057 : : return -EPERM;
1058 : :
1059 : 0 : if ((seq_ns != ns) && (seq_ns != ns->parent))
1060 : : return -EPERM;
1061 : :
1062 : 0 : return map_write(file, buf, size, ppos, CAP_SETGID,
1063 : : &ns->gid_map, &ns->parent->gid_map);
1064 : : }
1065 : :
1066 : 0 : ssize_t proc_projid_map_write(struct file *file, const char __user *buf,
1067 : : size_t size, loff_t *ppos)
1068 : : {
1069 : 0 : struct seq_file *seq = file->private_data;
1070 : 0 : struct user_namespace *ns = seq->private;
1071 : : struct user_namespace *seq_ns = seq_user_ns(seq);
1072 : :
1073 : 0 : if (!ns->parent)
1074 : : return -EPERM;
1075 : :
1076 : 0 : if ((seq_ns != ns) && (seq_ns != ns->parent))
1077 : : return -EPERM;
1078 : :
1079 : : /* Anyone can set any valid project id no capability needed */
1080 : 0 : return map_write(file, buf, size, ppos, -1,
1081 : : &ns->projid_map, &ns->parent->projid_map);
1082 : : }
1083 : :
1084 : 0 : static bool new_idmap_permitted(const struct file *file,
1085 : : struct user_namespace *ns, int cap_setid,
1086 : : struct uid_gid_map *new_map)
1087 : : {
1088 : 0 : const struct cred *cred = file->f_cred;
1089 : : /* Don't allow mappings that would allow anything that wouldn't
1090 : : * be allowed without the establishment of unprivileged mappings.
1091 : : */
1092 : 0 : if ((new_map->nr_extents == 1) && (new_map->extent[0].count == 1) &&
1093 : : uid_eq(ns->owner, cred->euid)) {
1094 : 0 : u32 id = new_map->extent[0].lower_first;
1095 : 0 : if (cap_setid == CAP_SETUID) {
1096 : 0 : kuid_t uid = make_kuid(ns->parent, id);
1097 : 0 : if (uid_eq(uid, cred->euid))
1098 : : return true;
1099 : 0 : } else if (cap_setid == CAP_SETGID) {
1100 : 0 : kgid_t gid = make_kgid(ns->parent, id);
1101 : 0 : if (!(ns->flags & USERNS_SETGROUPS_ALLOWED) &&
1102 : : gid_eq(gid, cred->egid))
1103 : : return true;
1104 : : }
1105 : : }
1106 : :
1107 : : /* Allow anyone to set a mapping that doesn't require privilege */
1108 : 0 : if (!cap_valid(cap_setid))
1109 : : return true;
1110 : :
1111 : : /* Allow the specified ids if we have the appropriate capability
1112 : : * (CAP_SETUID or CAP_SETGID) over the parent user namespace.
1113 : : * And the opener of the id file also had the approprpiate capability.
1114 : : */
1115 : 0 : if (ns_capable(ns->parent, cap_setid) &&
1116 : 0 : file_ns_capable(file, ns->parent, cap_setid))
1117 : : return true;
1118 : :
1119 : : return false;
1120 : : }
1121 : :
1122 : 3 : int proc_setgroups_show(struct seq_file *seq, void *v)
1123 : : {
1124 : 3 : struct user_namespace *ns = seq->private;
1125 : : unsigned long userns_flags = READ_ONCE(ns->flags);
1126 : :
1127 : 3 : seq_printf(seq, "%s\n",
1128 : 3 : (userns_flags & USERNS_SETGROUPS_ALLOWED) ?
1129 : : "allow" : "deny");
1130 : 3 : return 0;
1131 : : }
1132 : :
1133 : 0 : ssize_t proc_setgroups_write(struct file *file, const char __user *buf,
1134 : : size_t count, loff_t *ppos)
1135 : : {
1136 : 0 : struct seq_file *seq = file->private_data;
1137 : 0 : struct user_namespace *ns = seq->private;
1138 : : char kbuf[8], *pos;
1139 : : bool setgroups_allowed;
1140 : : ssize_t ret;
1141 : :
1142 : : /* Only allow a very narrow range of strings to be written */
1143 : : ret = -EINVAL;
1144 : 0 : if ((*ppos != 0) || (count >= sizeof(kbuf)))
1145 : : goto out;
1146 : :
1147 : : /* What was written? */
1148 : : ret = -EFAULT;
1149 : 0 : if (copy_from_user(kbuf, buf, count))
1150 : : goto out;
1151 : 0 : kbuf[count] = '\0';
1152 : : pos = kbuf;
1153 : :
1154 : : /* What is being requested? */
1155 : : ret = -EINVAL;
1156 : 0 : if (strncmp(pos, "allow", 5) == 0) {
1157 : : pos += 5;
1158 : : setgroups_allowed = true;
1159 : : }
1160 : 0 : else if (strncmp(pos, "deny", 4) == 0) {
1161 : : pos += 4;
1162 : : setgroups_allowed = false;
1163 : : }
1164 : : else
1165 : : goto out;
1166 : :
1167 : : /* Verify there is not trailing junk on the line */
1168 : 0 : pos = skip_spaces(pos);
1169 : 0 : if (*pos != '\0')
1170 : : goto out;
1171 : :
1172 : : ret = -EPERM;
1173 : 0 : mutex_lock(&userns_state_mutex);
1174 : 0 : if (setgroups_allowed) {
1175 : : /* Enabling setgroups after setgroups has been disabled
1176 : : * is not allowed.
1177 : : */
1178 : 0 : if (!(ns->flags & USERNS_SETGROUPS_ALLOWED))
1179 : : goto out_unlock;
1180 : : } else {
1181 : : /* Permanently disabling setgroups after setgroups has
1182 : : * been enabled by writing the gid_map is not allowed.
1183 : : */
1184 : 0 : if (ns->gid_map.nr_extents != 0)
1185 : : goto out_unlock;
1186 : 0 : ns->flags &= ~USERNS_SETGROUPS_ALLOWED;
1187 : : }
1188 : 0 : mutex_unlock(&userns_state_mutex);
1189 : :
1190 : : /* Report a successful write */
1191 : 0 : *ppos = count;
1192 : 0 : ret = count;
1193 : : out:
1194 : 0 : return ret;
1195 : : out_unlock:
1196 : 0 : mutex_unlock(&userns_state_mutex);
1197 : 0 : goto out;
1198 : : }
1199 : :
1200 : 3 : bool userns_may_setgroups(const struct user_namespace *ns)
1201 : : {
1202 : : bool allowed;
1203 : :
1204 : 3 : mutex_lock(&userns_state_mutex);
1205 : : /* It is not safe to use setgroups until a gid mapping in
1206 : : * the user namespace has been established.
1207 : : */
1208 : 3 : allowed = ns->gid_map.nr_extents != 0;
1209 : : /* Is setgroups allowed? */
1210 : 3 : allowed = allowed && (ns->flags & USERNS_SETGROUPS_ALLOWED);
1211 : 3 : mutex_unlock(&userns_state_mutex);
1212 : :
1213 : 3 : return allowed;
1214 : : }
1215 : :
1216 : : /*
1217 : : * Returns true if @child is the same namespace or a descendant of
1218 : : * @ancestor.
1219 : : */
1220 : 0 : bool in_userns(const struct user_namespace *ancestor,
1221 : : const struct user_namespace *child)
1222 : : {
1223 : : const struct user_namespace *ns;
1224 : 0 : for (ns = child; ns->level > ancestor->level; ns = ns->parent)
1225 : : ;
1226 : 3 : return (ns == ancestor);
1227 : : }
1228 : :
1229 : 3 : bool current_in_userns(const struct user_namespace *target_ns)
1230 : : {
1231 : 3 : return in_userns(target_ns, current_user_ns());
1232 : : }
1233 : : EXPORT_SYMBOL(current_in_userns);
1234 : :
1235 : : static inline struct user_namespace *to_user_ns(struct ns_common *ns)
1236 : : {
1237 : 0 : return container_of(ns, struct user_namespace, ns);
1238 : : }
1239 : :
1240 : 0 : static struct ns_common *userns_get(struct task_struct *task)
1241 : : {
1242 : : struct user_namespace *user_ns;
1243 : :
1244 : : rcu_read_lock();
1245 : 0 : user_ns = get_user_ns(__task_cred(task)->user_ns);
1246 : : rcu_read_unlock();
1247 : :
1248 : 0 : return user_ns ? &user_ns->ns : NULL;
1249 : : }
1250 : :
1251 : 0 : static void userns_put(struct ns_common *ns)
1252 : : {
1253 : 0 : put_user_ns(to_user_ns(ns));
1254 : 0 : }
1255 : :
1256 : 0 : static int userns_install(struct nsproxy *nsproxy, struct ns_common *ns)
1257 : : {
1258 : : struct user_namespace *user_ns = to_user_ns(ns);
1259 : : struct cred *cred;
1260 : :
1261 : : /* Don't allow gaining capabilities by reentering
1262 : : * the same user namespace.
1263 : : */
1264 : 0 : if (user_ns == current_user_ns())
1265 : : return -EINVAL;
1266 : :
1267 : : /* Tasks that share a thread group must share a user namespace */
1268 : 0 : if (!thread_group_empty(current))
1269 : : return -EINVAL;
1270 : :
1271 : 0 : if (current->fs->users != 1)
1272 : : return -EINVAL;
1273 : :
1274 : 0 : if (!ns_capable(user_ns, CAP_SYS_ADMIN))
1275 : : return -EPERM;
1276 : :
1277 : 0 : cred = prepare_creds();
1278 : 0 : if (!cred)
1279 : : return -ENOMEM;
1280 : :
1281 : 0 : put_user_ns(cred->user_ns);
1282 : 0 : set_cred_user_ns(cred, get_user_ns(user_ns));
1283 : :
1284 : 0 : return commit_creds(cred);
1285 : : }
1286 : :
1287 : 0 : struct ns_common *ns_get_owner(struct ns_common *ns)
1288 : : {
1289 : 0 : struct user_namespace *my_user_ns = current_user_ns();
1290 : : struct user_namespace *owner, *p;
1291 : :
1292 : : /* See if the owner is in the current user namespace */
1293 : 0 : owner = p = ns->ops->owner(ns);
1294 : : for (;;) {
1295 : 0 : if (!p)
1296 : : return ERR_PTR(-EPERM);
1297 : 0 : if (p == my_user_ns)
1298 : : break;
1299 : 0 : p = p->parent;
1300 : 0 : }
1301 : :
1302 : 0 : return &get_user_ns(owner)->ns;
1303 : : }
1304 : :
1305 : 0 : static struct user_namespace *userns_owner(struct ns_common *ns)
1306 : : {
1307 : 0 : return to_user_ns(ns)->parent;
1308 : : }
1309 : :
1310 : : const struct proc_ns_operations userns_operations = {
1311 : : .name = "user",
1312 : : .type = CLONE_NEWUSER,
1313 : : .get = userns_get,
1314 : : .put = userns_put,
1315 : : .install = userns_install,
1316 : : .owner = userns_owner,
1317 : : .get_parent = ns_get_owner,
1318 : : };
1319 : :
1320 : 3 : static __init int user_namespaces_init(void)
1321 : : {
1322 : 3 : user_ns_cachep = KMEM_CACHE(user_namespace, SLAB_PANIC);
1323 : 3 : return 0;
1324 : : }
1325 : : subsys_initcall(user_namespaces_init);
|
