KEYS/DNS: Fix ____call_usermodehelper() to not lose the session keyring
[linux-3.10.git] / security / keys / keyctl.c
1 /* Userspace key control operations
2  *
3  * Copyright (C) 2004-5 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  */
11
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/sched.h>
15 #include <linux/slab.h>
16 #include <linux/syscalls.h>
17 #include <linux/keyctl.h>
18 #include <linux/fs.h>
19 #include <linux/capability.h>
20 #include <linux/string.h>
21 #include <linux/err.h>
22 #include <linux/vmalloc.h>
23 #include <linux/security.h>
24 #include <asm/uaccess.h>
25 #include "internal.h"
26
27 static int key_get_type_from_user(char *type,
28                                   const char __user *_type,
29                                   unsigned len)
30 {
31         int ret;
32
33         ret = strncpy_from_user(type, _type, len);
34         if (ret < 0)
35                 return ret;
36         if (ret == 0 || ret >= len)
37                 return -EINVAL;
38         if (type[0] == '.')
39                 return -EPERM;
40         type[len - 1] = '\0';
41         return 0;
42 }
43
44 /*
45  * Extract the description of a new key from userspace and either add it as a
46  * new key to the specified keyring or update a matching key in that keyring.
47  *
48  * The keyring must be writable so that we can attach the key to it.
49  *
50  * If successful, the new key's serial number is returned, otherwise an error
51  * code is returned.
52  */
53 SYSCALL_DEFINE5(add_key, const char __user *, _type,
54                 const char __user *, _description,
55                 const void __user *, _payload,
56                 size_t, plen,
57                 key_serial_t, ringid)
58 {
59         key_ref_t keyring_ref, key_ref;
60         char type[32], *description;
61         void *payload;
62         long ret;
63         bool vm;
64
65         ret = -EINVAL;
66         if (plen > 1024 * 1024 - 1)
67                 goto error;
68
69         /* draw all the data into kernel space */
70         ret = key_get_type_from_user(type, _type, sizeof(type));
71         if (ret < 0)
72                 goto error;
73
74         description = strndup_user(_description, PAGE_SIZE);
75         if (IS_ERR(description)) {
76                 ret = PTR_ERR(description);
77                 goto error;
78         }
79
80         /* pull the payload in if one was supplied */
81         payload = NULL;
82
83         vm = false;
84         if (_payload) {
85                 ret = -ENOMEM;
86                 payload = kmalloc(plen, GFP_KERNEL);
87                 if (!payload) {
88                         if (plen <= PAGE_SIZE)
89                                 goto error2;
90                         vm = true;
91                         payload = vmalloc(plen);
92                         if (!payload)
93                                 goto error2;
94                 }
95
96                 ret = -EFAULT;
97                 if (copy_from_user(payload, _payload, plen) != 0)
98                         goto error3;
99         }
100
101         /* find the target keyring (which must be writable) */
102         keyring_ref = lookup_user_key(ringid, KEY_LOOKUP_CREATE, KEY_WRITE);
103         if (IS_ERR(keyring_ref)) {
104                 ret = PTR_ERR(keyring_ref);
105                 goto error3;
106         }
107
108         /* create or update the requested key and add it to the target
109          * keyring */
110         key_ref = key_create_or_update(keyring_ref, type, description,
111                                        payload, plen, KEY_PERM_UNDEF,
112                                        KEY_ALLOC_IN_QUOTA);
113         if (!IS_ERR(key_ref)) {
114                 ret = key_ref_to_ptr(key_ref)->serial;
115                 key_ref_put(key_ref);
116         }
117         else {
118                 ret = PTR_ERR(key_ref);
119         }
120
121         key_ref_put(keyring_ref);
122  error3:
123         if (!vm)
124                 kfree(payload);
125         else
126                 vfree(payload);
127  error2:
128         kfree(description);
129  error:
130         return ret;
131 }
132
133 /*
134  * Search the process keyrings and keyring trees linked from those for a
135  * matching key.  Keyrings must have appropriate Search permission to be
136  * searched.
137  *
138  * If a key is found, it will be attached to the destination keyring if there's
139  * one specified and the serial number of the key will be returned.
140  *
141  * If no key is found, /sbin/request-key will be invoked if _callout_info is
142  * non-NULL in an attempt to create a key.  The _callout_info string will be
143  * passed to /sbin/request-key to aid with completing the request.  If the
144  * _callout_info string is "" then it will be changed to "-".
145  */
146 SYSCALL_DEFINE4(request_key, const char __user *, _type,
147                 const char __user *, _description,
148                 const char __user *, _callout_info,
149                 key_serial_t, destringid)
150 {
151         struct key_type *ktype;
152         struct key *key;
153         key_ref_t dest_ref;
154         size_t callout_len;
155         char type[32], *description, *callout_info;
156         long ret;
157
158         /* pull the type into kernel space */
159         ret = key_get_type_from_user(type, _type, sizeof(type));
160         if (ret < 0)
161                 goto error;
162
163         /* pull the description into kernel space */
164         description = strndup_user(_description, PAGE_SIZE);
165         if (IS_ERR(description)) {
166                 ret = PTR_ERR(description);
167                 goto error;
168         }
169
170         /* pull the callout info into kernel space */
171         callout_info = NULL;
172         callout_len = 0;
173         if (_callout_info) {
174                 callout_info = strndup_user(_callout_info, PAGE_SIZE);
175                 if (IS_ERR(callout_info)) {
176                         ret = PTR_ERR(callout_info);
177                         goto error2;
178                 }
179                 callout_len = strlen(callout_info);
180         }
181
182         /* get the destination keyring if specified */
183         dest_ref = NULL;
184         if (destringid) {
185                 dest_ref = lookup_user_key(destringid, KEY_LOOKUP_CREATE,
186                                            KEY_WRITE);
187                 if (IS_ERR(dest_ref)) {
188                         ret = PTR_ERR(dest_ref);
189                         goto error3;
190                 }
191         }
192
193         /* find the key type */
194         ktype = key_type_lookup(type);
195         if (IS_ERR(ktype)) {
196                 ret = PTR_ERR(ktype);
197                 goto error4;
198         }
199
200         /* do the search */
201         key = request_key_and_link(ktype, description, callout_info,
202                                    callout_len, NULL, key_ref_to_ptr(dest_ref),
203                                    KEY_ALLOC_IN_QUOTA);
204         if (IS_ERR(key)) {
205                 ret = PTR_ERR(key);
206                 goto error5;
207         }
208
209         /* wait for the key to finish being constructed */
210         ret = wait_for_key_construction(key, 1);
211         if (ret < 0)
212                 goto error6;
213
214         ret = key->serial;
215
216 error6:
217         key_put(key);
218 error5:
219         key_type_put(ktype);
220 error4:
221         key_ref_put(dest_ref);
222 error3:
223         kfree(callout_info);
224 error2:
225         kfree(description);
226 error:
227         return ret;
228 }
229
230 /*
231  * Get the ID of the specified process keyring.
232  *
233  * The requested keyring must have search permission to be found.
234  *
235  * If successful, the ID of the requested keyring will be returned.
236  */
237 long keyctl_get_keyring_ID(key_serial_t id, int create)
238 {
239         key_ref_t key_ref;
240         unsigned long lflags;
241         long ret;
242
243         lflags = create ? KEY_LOOKUP_CREATE : 0;
244         key_ref = lookup_user_key(id, lflags, KEY_SEARCH);
245         if (IS_ERR(key_ref)) {
246                 ret = PTR_ERR(key_ref);
247                 goto error;
248         }
249
250         ret = key_ref_to_ptr(key_ref)->serial;
251         key_ref_put(key_ref);
252 error:
253         return ret;
254 }
255
256 /*
257  * Join a (named) session keyring.
258  *
259  * Create and join an anonymous session keyring or join a named session
260  * keyring, creating it if necessary.  A named session keyring must have Search
261  * permission for it to be joined.  Session keyrings without this permit will
262  * be skipped over.
263  *
264  * If successful, the ID of the joined session keyring will be returned.
265  */
266 long keyctl_join_session_keyring(const char __user *_name)
267 {
268         char *name;
269         long ret;
270
271         /* fetch the name from userspace */
272         name = NULL;
273         if (_name) {
274                 name = strndup_user(_name, PAGE_SIZE);
275                 if (IS_ERR(name)) {
276                         ret = PTR_ERR(name);
277                         goto error;
278                 }
279         }
280
281         /* join the session */
282         ret = join_session_keyring(name);
283         kfree(name);
284
285 error:
286         return ret;
287 }
288
289 /*
290  * Update a key's data payload from the given data.
291  *
292  * The key must grant the caller Write permission and the key type must support
293  * updating for this to work.  A negative key can be positively instantiated
294  * with this call.
295  *
296  * If successful, 0 will be returned.  If the key type does not support
297  * updating, then -EOPNOTSUPP will be returned.
298  */
299 long keyctl_update_key(key_serial_t id,
300                        const void __user *_payload,
301                        size_t plen)
302 {
303         key_ref_t key_ref;
304         void *payload;
305         long ret;
306
307         ret = -EINVAL;
308         if (plen > PAGE_SIZE)
309                 goto error;
310
311         /* pull the payload in if one was supplied */
312         payload = NULL;
313         if (_payload) {
314                 ret = -ENOMEM;
315                 payload = kmalloc(plen, GFP_KERNEL);
316                 if (!payload)
317                         goto error;
318
319                 ret = -EFAULT;
320                 if (copy_from_user(payload, _payload, plen) != 0)
321                         goto error2;
322         }
323
324         /* find the target key (which must be writable) */
325         key_ref = lookup_user_key(id, 0, KEY_WRITE);
326         if (IS_ERR(key_ref)) {
327                 ret = PTR_ERR(key_ref);
328                 goto error2;
329         }
330
331         /* update the key */
332         ret = key_update(key_ref, payload, plen);
333
334         key_ref_put(key_ref);
335 error2:
336         kfree(payload);
337 error:
338         return ret;
339 }
340
341 /*
342  * Revoke a key.
343  *
344  * The key must be grant the caller Write or Setattr permission for this to
345  * work.  The key type should give up its quota claim when revoked.  The key
346  * and any links to the key will be automatically garbage collected after a
347  * certain amount of time (/proc/sys/kernel/keys/gc_delay).
348  *
349  * If successful, 0 is returned.
350  */
351 long keyctl_revoke_key(key_serial_t id)
352 {
353         key_ref_t key_ref;
354         long ret;
355
356         key_ref = lookup_user_key(id, 0, KEY_WRITE);
357         if (IS_ERR(key_ref)) {
358                 ret = PTR_ERR(key_ref);
359                 if (ret != -EACCES)
360                         goto error;
361                 key_ref = lookup_user_key(id, 0, KEY_SETATTR);
362                 if (IS_ERR(key_ref)) {
363                         ret = PTR_ERR(key_ref);
364                         goto error;
365                 }
366         }
367
368         key_revoke(key_ref_to_ptr(key_ref));
369         ret = 0;
370
371         key_ref_put(key_ref);
372 error:
373         return ret;
374 }
375
376 /*
377  * Clear the specified keyring, creating an empty process keyring if one of the
378  * special keyring IDs is used.
379  *
380  * The keyring must grant the caller Write permission for this to work.  If
381  * successful, 0 will be returned.
382  */
383 long keyctl_keyring_clear(key_serial_t ringid)
384 {
385         key_ref_t keyring_ref;
386         long ret;
387
388         keyring_ref = lookup_user_key(ringid, KEY_LOOKUP_CREATE, KEY_WRITE);
389         if (IS_ERR(keyring_ref)) {
390                 ret = PTR_ERR(keyring_ref);
391                 goto error;
392         }
393
394         ret = keyring_clear(key_ref_to_ptr(keyring_ref));
395
396         key_ref_put(keyring_ref);
397 error:
398         return ret;
399 }
400
401 /*
402  * Create a link from a keyring to a key if there's no matching key in the
403  * keyring, otherwise replace the link to the matching key with a link to the
404  * new key.
405  *
406  * The key must grant the caller Link permission and the the keyring must grant
407  * the caller Write permission.  Furthermore, if an additional link is created,
408  * the keyring's quota will be extended.
409  *
410  * If successful, 0 will be returned.
411  */
412 long keyctl_keyring_link(key_serial_t id, key_serial_t ringid)
413 {
414         key_ref_t keyring_ref, key_ref;
415         long ret;
416
417         keyring_ref = lookup_user_key(ringid, KEY_LOOKUP_CREATE, KEY_WRITE);
418         if (IS_ERR(keyring_ref)) {
419                 ret = PTR_ERR(keyring_ref);
420                 goto error;
421         }
422
423         key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE, KEY_LINK);
424         if (IS_ERR(key_ref)) {
425                 ret = PTR_ERR(key_ref);
426                 goto error2;
427         }
428
429         ret = key_link(key_ref_to_ptr(keyring_ref), key_ref_to_ptr(key_ref));
430
431         key_ref_put(key_ref);
432 error2:
433         key_ref_put(keyring_ref);
434 error:
435         return ret;
436 }
437
438 /*
439  * Unlink a key from a keyring.
440  *
441  * The keyring must grant the caller Write permission for this to work; the key
442  * itself need not grant the caller anything.  If the last link to a key is
443  * removed then that key will be scheduled for destruction.
444  *
445  * If successful, 0 will be returned.
446  */
447 long keyctl_keyring_unlink(key_serial_t id, key_serial_t ringid)
448 {
449         key_ref_t keyring_ref, key_ref;
450         long ret;
451
452         keyring_ref = lookup_user_key(ringid, 0, KEY_WRITE);
453         if (IS_ERR(keyring_ref)) {
454                 ret = PTR_ERR(keyring_ref);
455                 goto error;
456         }
457
458         key_ref = lookup_user_key(id, KEY_LOOKUP_FOR_UNLINK, 0);
459         if (IS_ERR(key_ref)) {
460                 ret = PTR_ERR(key_ref);
461                 goto error2;
462         }
463
464         ret = key_unlink(key_ref_to_ptr(keyring_ref), key_ref_to_ptr(key_ref));
465
466         key_ref_put(key_ref);
467 error2:
468         key_ref_put(keyring_ref);
469 error:
470         return ret;
471 }
472
473 /*
474  * Return a description of a key to userspace.
475  *
476  * The key must grant the caller View permission for this to work.
477  *
478  * If there's a buffer, we place up to buflen bytes of data into it formatted
479  * in the following way:
480  *
481  *      type;uid;gid;perm;description<NUL>
482  *
483  * If successful, we return the amount of description available, irrespective
484  * of how much we may have copied into the buffer.
485  */
486 long keyctl_describe_key(key_serial_t keyid,
487                          char __user *buffer,
488                          size_t buflen)
489 {
490         struct key *key, *instkey;
491         key_ref_t key_ref;
492         char *tmpbuf;
493         long ret;
494
495         key_ref = lookup_user_key(keyid, KEY_LOOKUP_PARTIAL, KEY_VIEW);
496         if (IS_ERR(key_ref)) {
497                 /* viewing a key under construction is permitted if we have the
498                  * authorisation token handy */
499                 if (PTR_ERR(key_ref) == -EACCES) {
500                         instkey = key_get_instantiation_authkey(keyid);
501                         if (!IS_ERR(instkey)) {
502                                 key_put(instkey);
503                                 key_ref = lookup_user_key(keyid,
504                                                           KEY_LOOKUP_PARTIAL,
505                                                           0);
506                                 if (!IS_ERR(key_ref))
507                                         goto okay;
508                         }
509                 }
510
511                 ret = PTR_ERR(key_ref);
512                 goto error;
513         }
514
515 okay:
516         /* calculate how much description we're going to return */
517         ret = -ENOMEM;
518         tmpbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
519         if (!tmpbuf)
520                 goto error2;
521
522         key = key_ref_to_ptr(key_ref);
523
524         ret = snprintf(tmpbuf, PAGE_SIZE - 1,
525                        "%s;%d;%d;%08x;%s",
526                        key->type->name,
527                        key->uid,
528                        key->gid,
529                        key->perm,
530                        key->description ?: "");
531
532         /* include a NUL char at the end of the data */
533         if (ret > PAGE_SIZE - 1)
534                 ret = PAGE_SIZE - 1;
535         tmpbuf[ret] = 0;
536         ret++;
537
538         /* consider returning the data */
539         if (buffer && buflen > 0) {
540                 if (buflen > ret)
541                         buflen = ret;
542
543                 if (copy_to_user(buffer, tmpbuf, buflen) != 0)
544                         ret = -EFAULT;
545         }
546
547         kfree(tmpbuf);
548 error2:
549         key_ref_put(key_ref);
550 error:
551         return ret;
552 }
553
554 /*
555  * Search the specified keyring and any keyrings it links to for a matching
556  * key.  Only keyrings that grant the caller Search permission will be searched
557  * (this includes the starting keyring).  Only keys with Search permission can
558  * be found.
559  *
560  * If successful, the found key will be linked to the destination keyring if
561  * supplied and the key has Link permission, and the found key ID will be
562  * returned.
563  */
564 long keyctl_keyring_search(key_serial_t ringid,
565                            const char __user *_type,
566                            const char __user *_description,
567                            key_serial_t destringid)
568 {
569         struct key_type *ktype;
570         key_ref_t keyring_ref, key_ref, dest_ref;
571         char type[32], *description;
572         long ret;
573
574         /* pull the type and description into kernel space */
575         ret = key_get_type_from_user(type, _type, sizeof(type));
576         if (ret < 0)
577                 goto error;
578
579         description = strndup_user(_description, PAGE_SIZE);
580         if (IS_ERR(description)) {
581                 ret = PTR_ERR(description);
582                 goto error;
583         }
584
585         /* get the keyring at which to begin the search */
586         keyring_ref = lookup_user_key(ringid, 0, KEY_SEARCH);
587         if (IS_ERR(keyring_ref)) {
588                 ret = PTR_ERR(keyring_ref);
589                 goto error2;
590         }
591
592         /* get the destination keyring if specified */
593         dest_ref = NULL;
594         if (destringid) {
595                 dest_ref = lookup_user_key(destringid, KEY_LOOKUP_CREATE,
596                                            KEY_WRITE);
597                 if (IS_ERR(dest_ref)) {
598                         ret = PTR_ERR(dest_ref);
599                         goto error3;
600                 }
601         }
602
603         /* find the key type */
604         ktype = key_type_lookup(type);
605         if (IS_ERR(ktype)) {
606                 ret = PTR_ERR(ktype);
607                 goto error4;
608         }
609
610         /* do the search */
611         key_ref = keyring_search(keyring_ref, ktype, description);
612         if (IS_ERR(key_ref)) {
613                 ret = PTR_ERR(key_ref);
614
615                 /* treat lack or presence of a negative key the same */
616                 if (ret == -EAGAIN)
617                         ret = -ENOKEY;
618                 goto error5;
619         }
620
621         /* link the resulting key to the destination keyring if we can */
622         if (dest_ref) {
623                 ret = key_permission(key_ref, KEY_LINK);
624                 if (ret < 0)
625                         goto error6;
626
627                 ret = key_link(key_ref_to_ptr(dest_ref), key_ref_to_ptr(key_ref));
628                 if (ret < 0)
629                         goto error6;
630         }
631
632         ret = key_ref_to_ptr(key_ref)->serial;
633
634 error6:
635         key_ref_put(key_ref);
636 error5:
637         key_type_put(ktype);
638 error4:
639         key_ref_put(dest_ref);
640 error3:
641         key_ref_put(keyring_ref);
642 error2:
643         kfree(description);
644 error:
645         return ret;
646 }
647
648 /*
649  * Read a key's payload.
650  *
651  * The key must either grant the caller Read permission, or it must grant the
652  * caller Search permission when searched for from the process keyrings.
653  *
654  * If successful, we place up to buflen bytes of data into the buffer, if one
655  * is provided, and return the amount of data that is available in the key,
656  * irrespective of how much we copied into the buffer.
657  */
658 long keyctl_read_key(key_serial_t keyid, char __user *buffer, size_t buflen)
659 {
660         struct key *key;
661         key_ref_t key_ref;
662         long ret;
663
664         /* find the key first */
665         key_ref = lookup_user_key(keyid, 0, 0);
666         if (IS_ERR(key_ref)) {
667                 ret = -ENOKEY;
668                 goto error;
669         }
670
671         key = key_ref_to_ptr(key_ref);
672
673         /* see if we can read it directly */
674         ret = key_permission(key_ref, KEY_READ);
675         if (ret == 0)
676                 goto can_read_key;
677         if (ret != -EACCES)
678                 goto error;
679
680         /* we can't; see if it's searchable from this process's keyrings
681          * - we automatically take account of the fact that it may be
682          *   dangling off an instantiation key
683          */
684         if (!is_key_possessed(key_ref)) {
685                 ret = -EACCES;
686                 goto error2;
687         }
688
689         /* the key is probably readable - now try to read it */
690 can_read_key:
691         ret = key_validate(key);
692         if (ret == 0) {
693                 ret = -EOPNOTSUPP;
694                 if (key->type->read) {
695                         /* read the data with the semaphore held (since we
696                          * might sleep) */
697                         down_read(&key->sem);
698                         ret = key->type->read(key, buffer, buflen);
699                         up_read(&key->sem);
700                 }
701         }
702
703 error2:
704         key_put(key);
705 error:
706         return ret;
707 }
708
709 /*
710  * Change the ownership of a key
711  *
712  * The key must grant the caller Setattr permission for this to work, though
713  * the key need not be fully instantiated yet.  For the UID to be changed, or
714  * for the GID to be changed to a group the caller is not a member of, the
715  * caller must have sysadmin capability.  If either uid or gid is -1 then that
716  * attribute is not changed.
717  *
718  * If the UID is to be changed, the new user must have sufficient quota to
719  * accept the key.  The quota deduction will be removed from the old user to
720  * the new user should the attribute be changed.
721  *
722  * If successful, 0 will be returned.
723  */
724 long keyctl_chown_key(key_serial_t id, uid_t uid, gid_t gid)
725 {
726         struct key_user *newowner, *zapowner = NULL;
727         struct key *key;
728         key_ref_t key_ref;
729         long ret;
730
731         ret = 0;
732         if (uid == (uid_t) -1 && gid == (gid_t) -1)
733                 goto error;
734
735         key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE | KEY_LOOKUP_PARTIAL,
736                                   KEY_SETATTR);
737         if (IS_ERR(key_ref)) {
738                 ret = PTR_ERR(key_ref);
739                 goto error;
740         }
741
742         key = key_ref_to_ptr(key_ref);
743
744         /* make the changes with the locks held to prevent chown/chown races */
745         ret = -EACCES;
746         down_write(&key->sem);
747
748         if (!capable(CAP_SYS_ADMIN)) {
749                 /* only the sysadmin can chown a key to some other UID */
750                 if (uid != (uid_t) -1 && key->uid != uid)
751                         goto error_put;
752
753                 /* only the sysadmin can set the key's GID to a group other
754                  * than one of those that the current process subscribes to */
755                 if (gid != (gid_t) -1 && gid != key->gid && !in_group_p(gid))
756                         goto error_put;
757         }
758
759         /* change the UID */
760         if (uid != (uid_t) -1 && uid != key->uid) {
761                 ret = -ENOMEM;
762                 newowner = key_user_lookup(uid, current_user_ns());
763                 if (!newowner)
764                         goto error_put;
765
766                 /* transfer the quota burden to the new user */
767                 if (test_bit(KEY_FLAG_IN_QUOTA, &key->flags)) {
768                         unsigned maxkeys = (uid == 0) ?
769                                 key_quota_root_maxkeys : key_quota_maxkeys;
770                         unsigned maxbytes = (uid == 0) ?
771                                 key_quota_root_maxbytes : key_quota_maxbytes;
772
773                         spin_lock(&newowner->lock);
774                         if (newowner->qnkeys + 1 >= maxkeys ||
775                             newowner->qnbytes + key->quotalen >= maxbytes ||
776                             newowner->qnbytes + key->quotalen <
777                             newowner->qnbytes)
778                                 goto quota_overrun;
779
780                         newowner->qnkeys++;
781                         newowner->qnbytes += key->quotalen;
782                         spin_unlock(&newowner->lock);
783
784                         spin_lock(&key->user->lock);
785                         key->user->qnkeys--;
786                         key->user->qnbytes -= key->quotalen;
787                         spin_unlock(&key->user->lock);
788                 }
789
790                 atomic_dec(&key->user->nkeys);
791                 atomic_inc(&newowner->nkeys);
792
793                 if (test_bit(KEY_FLAG_INSTANTIATED, &key->flags)) {
794                         atomic_dec(&key->user->nikeys);
795                         atomic_inc(&newowner->nikeys);
796                 }
797
798                 zapowner = key->user;
799                 key->user = newowner;
800                 key->uid = uid;
801         }
802
803         /* change the GID */
804         if (gid != (gid_t) -1)
805                 key->gid = gid;
806
807         ret = 0;
808
809 error_put:
810         up_write(&key->sem);
811         key_put(key);
812         if (zapowner)
813                 key_user_put(zapowner);
814 error:
815         return ret;
816
817 quota_overrun:
818         spin_unlock(&newowner->lock);
819         zapowner = newowner;
820         ret = -EDQUOT;
821         goto error_put;
822 }
823
824 /*
825  * Change the permission mask on a key.
826  *
827  * The key must grant the caller Setattr permission for this to work, though
828  * the key need not be fully instantiated yet.  If the caller does not have
829  * sysadmin capability, it may only change the permission on keys that it owns.
830  */
831 long keyctl_setperm_key(key_serial_t id, key_perm_t perm)
832 {
833         struct key *key;
834         key_ref_t key_ref;
835         long ret;
836
837         ret = -EINVAL;
838         if (perm & ~(KEY_POS_ALL | KEY_USR_ALL | KEY_GRP_ALL | KEY_OTH_ALL))
839                 goto error;
840
841         key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE | KEY_LOOKUP_PARTIAL,
842                                   KEY_SETATTR);
843         if (IS_ERR(key_ref)) {
844                 ret = PTR_ERR(key_ref);
845                 goto error;
846         }
847
848         key = key_ref_to_ptr(key_ref);
849
850         /* make the changes with the locks held to prevent chown/chmod races */
851         ret = -EACCES;
852         down_write(&key->sem);
853
854         /* if we're not the sysadmin, we can only change a key that we own */
855         if (capable(CAP_SYS_ADMIN) || key->uid == current_fsuid()) {
856                 key->perm = perm;
857                 ret = 0;
858         }
859
860         up_write(&key->sem);
861         key_put(key);
862 error:
863         return ret;
864 }
865
866 /*
867  * Get the destination keyring for instantiation and check that the caller has
868  * Write permission on it.
869  */
870 static long get_instantiation_keyring(key_serial_t ringid,
871                                       struct request_key_auth *rka,
872                                       struct key **_dest_keyring)
873 {
874         key_ref_t dkref;
875
876         *_dest_keyring = NULL;
877
878         /* just return a NULL pointer if we weren't asked to make a link */
879         if (ringid == 0)
880                 return 0;
881
882         /* if a specific keyring is nominated by ID, then use that */
883         if (ringid > 0) {
884                 dkref = lookup_user_key(ringid, KEY_LOOKUP_CREATE, KEY_WRITE);
885                 if (IS_ERR(dkref))
886                         return PTR_ERR(dkref);
887                 *_dest_keyring = key_ref_to_ptr(dkref);
888                 return 0;
889         }
890
891         if (ringid == KEY_SPEC_REQKEY_AUTH_KEY)
892                 return -EINVAL;
893
894         /* otherwise specify the destination keyring recorded in the
895          * authorisation key (any KEY_SPEC_*_KEYRING) */
896         if (ringid >= KEY_SPEC_REQUESTOR_KEYRING) {
897                 *_dest_keyring = key_get(rka->dest_keyring);
898                 return 0;
899         }
900
901         return -ENOKEY;
902 }
903
904 /*
905  * Change the request_key authorisation key on the current process.
906  */
907 static int keyctl_change_reqkey_auth(struct key *key)
908 {
909         struct cred *new;
910
911         new = prepare_creds();
912         if (!new)
913                 return -ENOMEM;
914
915         key_put(new->request_key_auth);
916         new->request_key_auth = key_get(key);
917
918         return commit_creds(new);
919 }
920
921 /*
922  * Copy the iovec data from userspace
923  */
924 static long copy_from_user_iovec(void *buffer, const struct iovec *iov,
925                                  unsigned ioc)
926 {
927         for (; ioc > 0; ioc--) {
928                 if (copy_from_user(buffer, iov->iov_base, iov->iov_len) != 0)
929                         return -EFAULT;
930                 buffer += iov->iov_len;
931                 iov++;
932         }
933         return 0;
934 }
935
936 /*
937  * Instantiate a key with the specified payload and link the key into the
938  * destination keyring if one is given.
939  *
940  * The caller must have the appropriate instantiation permit set for this to
941  * work (see keyctl_assume_authority).  No other permissions are required.
942  *
943  * If successful, 0 will be returned.
944  */
945 long keyctl_instantiate_key_common(key_serial_t id,
946                                    const struct iovec *payload_iov,
947                                    unsigned ioc,
948                                    size_t plen,
949                                    key_serial_t ringid)
950 {
951         const struct cred *cred = current_cred();
952         struct request_key_auth *rka;
953         struct key *instkey, *dest_keyring;
954         void *payload;
955         long ret;
956         bool vm = false;
957
958         kenter("%d,,%zu,%d", id, plen, ringid);
959
960         ret = -EINVAL;
961         if (plen > 1024 * 1024 - 1)
962                 goto error;
963
964         /* the appropriate instantiation authorisation key must have been
965          * assumed before calling this */
966         ret = -EPERM;
967         instkey = cred->request_key_auth;
968         if (!instkey)
969                 goto error;
970
971         rka = instkey->payload.data;
972         if (rka->target_key->serial != id)
973                 goto error;
974
975         /* pull the payload in if one was supplied */
976         payload = NULL;
977
978         if (payload_iov) {
979                 ret = -ENOMEM;
980                 payload = kmalloc(plen, GFP_KERNEL);
981                 if (!payload) {
982                         if (plen <= PAGE_SIZE)
983                                 goto error;
984                         vm = true;
985                         payload = vmalloc(plen);
986                         if (!payload)
987                                 goto error;
988                 }
989
990                 ret = copy_from_user_iovec(payload, payload_iov, ioc);
991                 if (ret < 0)
992                         goto error2;
993         }
994
995         /* find the destination keyring amongst those belonging to the
996          * requesting task */
997         ret = get_instantiation_keyring(ringid, rka, &dest_keyring);
998         if (ret < 0)
999                 goto error2;
1000
1001         /* instantiate the key and link it into a keyring */
1002         ret = key_instantiate_and_link(rka->target_key, payload, plen,
1003                                        dest_keyring, instkey);
1004
1005         key_put(dest_keyring);
1006
1007         /* discard the assumed authority if it's just been disabled by
1008          * instantiation of the key */
1009         if (ret == 0)
1010                 keyctl_change_reqkey_auth(NULL);
1011
1012 error2:
1013         if (!vm)
1014                 kfree(payload);
1015         else
1016                 vfree(payload);
1017 error:
1018         return ret;
1019 }
1020
1021 /*
1022  * Instantiate a key with the specified payload and link the key into the
1023  * destination keyring if one is given.
1024  *
1025  * The caller must have the appropriate instantiation permit set for this to
1026  * work (see keyctl_assume_authority).  No other permissions are required.
1027  *
1028  * If successful, 0 will be returned.
1029  */
1030 long keyctl_instantiate_key(key_serial_t id,
1031                             const void __user *_payload,
1032                             size_t plen,
1033                             key_serial_t ringid)
1034 {
1035         if (_payload && plen) {
1036                 struct iovec iov[1] = {
1037                         [0].iov_base = (void __user *)_payload,
1038                         [0].iov_len  = plen
1039                 };
1040
1041                 return keyctl_instantiate_key_common(id, iov, 1, plen, ringid);
1042         }
1043
1044         return keyctl_instantiate_key_common(id, NULL, 0, 0, ringid);
1045 }
1046
1047 /*
1048  * Instantiate a key with the specified multipart payload and link the key into
1049  * the destination keyring if one is given.
1050  *
1051  * The caller must have the appropriate instantiation permit set for this to
1052  * work (see keyctl_assume_authority).  No other permissions are required.
1053  *
1054  * If successful, 0 will be returned.
1055  */
1056 long keyctl_instantiate_key_iov(key_serial_t id,
1057                                 const struct iovec __user *_payload_iov,
1058                                 unsigned ioc,
1059                                 key_serial_t ringid)
1060 {
1061         struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
1062         long ret;
1063
1064         if (_payload_iov == 0 || ioc == 0)
1065                 goto no_payload;
1066
1067         ret = rw_copy_check_uvector(WRITE, _payload_iov, ioc,
1068                                     ARRAY_SIZE(iovstack), iovstack, &iov);
1069         if (ret < 0)
1070                 return ret;
1071         if (ret == 0)
1072                 goto no_payload_free;
1073
1074         ret = keyctl_instantiate_key_common(id, iov, ioc, ret, ringid);
1075
1076         if (iov != iovstack)
1077                 kfree(iov);
1078         return ret;
1079
1080 no_payload_free:
1081         if (iov != iovstack)
1082                 kfree(iov);
1083 no_payload:
1084         return keyctl_instantiate_key_common(id, NULL, 0, 0, ringid);
1085 }
1086
1087 /*
1088  * Negatively instantiate the key with the given timeout (in seconds) and link
1089  * the key into the destination keyring if one is given.
1090  *
1091  * The caller must have the appropriate instantiation permit set for this to
1092  * work (see keyctl_assume_authority).  No other permissions are required.
1093  *
1094  * The key and any links to the key will be automatically garbage collected
1095  * after the timeout expires.
1096  *
1097  * Negative keys are used to rate limit repeated request_key() calls by causing
1098  * them to return -ENOKEY until the negative key expires.
1099  *
1100  * If successful, 0 will be returned.
1101  */
1102 long keyctl_negate_key(key_serial_t id, unsigned timeout, key_serial_t ringid)
1103 {
1104         return keyctl_reject_key(id, timeout, ENOKEY, ringid);
1105 }
1106
1107 /*
1108  * Negatively instantiate the key with the given timeout (in seconds) and error
1109  * code and link the key into the destination keyring if one is given.
1110  *
1111  * The caller must have the appropriate instantiation permit set for this to
1112  * work (see keyctl_assume_authority).  No other permissions are required.
1113  *
1114  * The key and any links to the key will be automatically garbage collected
1115  * after the timeout expires.
1116  *
1117  * Negative keys are used to rate limit repeated request_key() calls by causing
1118  * them to return the specified error code until the negative key expires.
1119  *
1120  * If successful, 0 will be returned.
1121  */
1122 long keyctl_reject_key(key_serial_t id, unsigned timeout, unsigned error,
1123                        key_serial_t ringid)
1124 {
1125         const struct cred *cred = current_cred();
1126         struct request_key_auth *rka;
1127         struct key *instkey, *dest_keyring;
1128         long ret;
1129
1130         kenter("%d,%u,%u,%d", id, timeout, error, ringid);
1131
1132         /* must be a valid error code and mustn't be a kernel special */
1133         if (error <= 0 ||
1134             error >= MAX_ERRNO ||
1135             error == ERESTARTSYS ||
1136             error == ERESTARTNOINTR ||
1137             error == ERESTARTNOHAND ||
1138             error == ERESTART_RESTARTBLOCK)
1139                 return -EINVAL;
1140
1141         /* the appropriate instantiation authorisation key must have been
1142          * assumed before calling this */
1143         ret = -EPERM;
1144         instkey = cred->request_key_auth;
1145         if (!instkey)
1146                 goto error;
1147
1148         rka = instkey->payload.data;
1149         if (rka->target_key->serial != id)
1150                 goto error;
1151
1152         /* find the destination keyring if present (which must also be
1153          * writable) */
1154         ret = get_instantiation_keyring(ringid, rka, &dest_keyring);
1155         if (ret < 0)
1156                 goto error;
1157
1158         /* instantiate the key and link it into a keyring */
1159         ret = key_reject_and_link(rka->target_key, timeout, error,
1160                                   dest_keyring, instkey);
1161
1162         key_put(dest_keyring);
1163
1164         /* discard the assumed authority if it's just been disabled by
1165          * instantiation of the key */
1166         if (ret == 0)
1167                 keyctl_change_reqkey_auth(NULL);
1168
1169 error:
1170         return ret;
1171 }
1172
1173 /*
1174  * Read or set the default keyring in which request_key() will cache keys and
1175  * return the old setting.
1176  *
1177  * If a process keyring is specified then this will be created if it doesn't
1178  * yet exist.  The old setting will be returned if successful.
1179  */
1180 long keyctl_set_reqkey_keyring(int reqkey_defl)
1181 {
1182         struct cred *new;
1183         int ret, old_setting;
1184
1185         old_setting = current_cred_xxx(jit_keyring);
1186
1187         if (reqkey_defl == KEY_REQKEY_DEFL_NO_CHANGE)
1188                 return old_setting;
1189
1190         new = prepare_creds();
1191         if (!new)
1192                 return -ENOMEM;
1193
1194         switch (reqkey_defl) {
1195         case KEY_REQKEY_DEFL_THREAD_KEYRING:
1196                 ret = install_thread_keyring_to_cred(new);
1197                 if (ret < 0)
1198                         goto error;
1199                 goto set;
1200
1201         case KEY_REQKEY_DEFL_PROCESS_KEYRING:
1202                 ret = install_process_keyring_to_cred(new);
1203                 if (ret < 0) {
1204                         if (ret != -EEXIST)
1205                                 goto error;
1206                         ret = 0;
1207                 }
1208                 goto set;
1209
1210         case KEY_REQKEY_DEFL_DEFAULT:
1211         case KEY_REQKEY_DEFL_SESSION_KEYRING:
1212         case KEY_REQKEY_DEFL_USER_KEYRING:
1213         case KEY_REQKEY_DEFL_USER_SESSION_KEYRING:
1214         case KEY_REQKEY_DEFL_REQUESTOR_KEYRING:
1215                 goto set;
1216
1217         case KEY_REQKEY_DEFL_NO_CHANGE:
1218         case KEY_REQKEY_DEFL_GROUP_KEYRING:
1219         default:
1220                 ret = -EINVAL;
1221                 goto error;
1222         }
1223
1224 set:
1225         new->jit_keyring = reqkey_defl;
1226         commit_creds(new);
1227         return old_setting;
1228 error:
1229         abort_creds(new);
1230         return ret;
1231 }
1232
1233 /*
1234  * Set or clear the timeout on a key.
1235  *
1236  * Either the key must grant the caller Setattr permission or else the caller
1237  * must hold an instantiation authorisation token for the key.
1238  *
1239  * The timeout is either 0 to clear the timeout, or a number of seconds from
1240  * the current time.  The key and any links to the key will be automatically
1241  * garbage collected after the timeout expires.
1242  *
1243  * If successful, 0 is returned.
1244  */
1245 long keyctl_set_timeout(key_serial_t id, unsigned timeout)
1246 {
1247         struct timespec now;
1248         struct key *key, *instkey;
1249         key_ref_t key_ref;
1250         time_t expiry;
1251         long ret;
1252
1253         key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE | KEY_LOOKUP_PARTIAL,
1254                                   KEY_SETATTR);
1255         if (IS_ERR(key_ref)) {
1256                 /* setting the timeout on a key under construction is permitted
1257                  * if we have the authorisation token handy */
1258                 if (PTR_ERR(key_ref) == -EACCES) {
1259                         instkey = key_get_instantiation_authkey(id);
1260                         if (!IS_ERR(instkey)) {
1261                                 key_put(instkey);
1262                                 key_ref = lookup_user_key(id,
1263                                                           KEY_LOOKUP_PARTIAL,
1264                                                           0);
1265                                 if (!IS_ERR(key_ref))
1266                                         goto okay;
1267                         }
1268                 }
1269
1270                 ret = PTR_ERR(key_ref);
1271                 goto error;
1272         }
1273
1274 okay:
1275         key = key_ref_to_ptr(key_ref);
1276
1277         /* make the changes with the locks held to prevent races */
1278         down_write(&key->sem);
1279
1280         expiry = 0;
1281         if (timeout > 0) {
1282                 now = current_kernel_time();
1283                 expiry = now.tv_sec + timeout;
1284         }
1285
1286         key->expiry = expiry;
1287         key_schedule_gc(key->expiry + key_gc_delay);
1288
1289         up_write(&key->sem);
1290         key_put(key);
1291
1292         ret = 0;
1293 error:
1294         return ret;
1295 }
1296
1297 /*
1298  * Assume (or clear) the authority to instantiate the specified key.
1299  *
1300  * This sets the authoritative token currently in force for key instantiation.
1301  * This must be done for a key to be instantiated.  It has the effect of making
1302  * available all the keys from the caller of the request_key() that created a
1303  * key to request_key() calls made by the caller of this function.
1304  *
1305  * The caller must have the instantiation key in their process keyrings with a
1306  * Search permission grant available to the caller.
1307  *
1308  * If the ID given is 0, then the setting will be cleared and 0 returned.
1309  *
1310  * If the ID given has a matching an authorisation key, then that key will be
1311  * set and its ID will be returned.  The authorisation key can be read to get
1312  * the callout information passed to request_key().
1313  */
1314 long keyctl_assume_authority(key_serial_t id)
1315 {
1316         struct key *authkey;
1317         long ret;
1318
1319         /* special key IDs aren't permitted */
1320         ret = -EINVAL;
1321         if (id < 0)
1322                 goto error;
1323
1324         /* we divest ourselves of authority if given an ID of 0 */
1325         if (id == 0) {
1326                 ret = keyctl_change_reqkey_auth(NULL);
1327                 goto error;
1328         }
1329
1330         /* attempt to assume the authority temporarily granted to us whilst we
1331          * instantiate the specified key
1332          * - the authorisation key must be in the current task's keyrings
1333          *   somewhere
1334          */
1335         authkey = key_get_instantiation_authkey(id);
1336         if (IS_ERR(authkey)) {
1337                 ret = PTR_ERR(authkey);
1338                 goto error;
1339         }
1340
1341         ret = keyctl_change_reqkey_auth(authkey);
1342         if (ret < 0)
1343                 goto error;
1344         key_put(authkey);
1345
1346         ret = authkey->serial;
1347 error:
1348         return ret;
1349 }
1350
1351 /*
1352  * Get a key's the LSM security label.
1353  *
1354  * The key must grant the caller View permission for this to work.
1355  *
1356  * If there's a buffer, then up to buflen bytes of data will be placed into it.
1357  *
1358  * If successful, the amount of information available will be returned,
1359  * irrespective of how much was copied (including the terminal NUL).
1360  */
1361 long keyctl_get_security(key_serial_t keyid,
1362                          char __user *buffer,
1363                          size_t buflen)
1364 {
1365         struct key *key, *instkey;
1366         key_ref_t key_ref;
1367         char *context;
1368         long ret;
1369
1370         key_ref = lookup_user_key(keyid, KEY_LOOKUP_PARTIAL, KEY_VIEW);
1371         if (IS_ERR(key_ref)) {
1372                 if (PTR_ERR(key_ref) != -EACCES)
1373                         return PTR_ERR(key_ref);
1374
1375                 /* viewing a key under construction is also permitted if we
1376                  * have the authorisation token handy */
1377                 instkey = key_get_instantiation_authkey(keyid);
1378                 if (IS_ERR(instkey))
1379                         return PTR_ERR(instkey);
1380                 key_put(instkey);
1381
1382                 key_ref = lookup_user_key(keyid, KEY_LOOKUP_PARTIAL, 0);
1383                 if (IS_ERR(key_ref))
1384                         return PTR_ERR(key_ref);
1385         }
1386
1387         key = key_ref_to_ptr(key_ref);
1388         ret = security_key_getsecurity(key, &context);
1389         if (ret == 0) {
1390                 /* if no information was returned, give userspace an empty
1391                  * string */
1392                 ret = 1;
1393                 if (buffer && buflen > 0 &&
1394                     copy_to_user(buffer, "", 1) != 0)
1395                         ret = -EFAULT;
1396         } else if (ret > 0) {
1397                 /* return as much data as there's room for */
1398                 if (buffer && buflen > 0) {
1399                         if (buflen > ret)
1400                                 buflen = ret;
1401
1402                         if (copy_to_user(buffer, context, buflen) != 0)
1403                                 ret = -EFAULT;
1404                 }
1405
1406                 kfree(context);
1407         }
1408
1409         key_ref_put(key_ref);
1410         return ret;
1411 }
1412
1413 /*
1414  * Attempt to install the calling process's session keyring on the process's
1415  * parent process.
1416  *
1417  * The keyring must exist and must grant the caller LINK permission, and the
1418  * parent process must be single-threaded and must have the same effective
1419  * ownership as this process and mustn't be SUID/SGID.
1420  *
1421  * The keyring will be emplaced on the parent when it next resumes userspace.
1422  *
1423  * If successful, 0 will be returned.
1424  */
1425 long keyctl_session_to_parent(void)
1426 {
1427 #ifdef TIF_NOTIFY_RESUME
1428         struct task_struct *me, *parent;
1429         const struct cred *mycred, *pcred;
1430         struct cred *cred, *oldcred;
1431         key_ref_t keyring_r;
1432         int ret;
1433
1434         keyring_r = lookup_user_key(KEY_SPEC_SESSION_KEYRING, 0, KEY_LINK);
1435         if (IS_ERR(keyring_r))
1436                 return PTR_ERR(keyring_r);
1437
1438         /* our parent is going to need a new cred struct, a new tgcred struct
1439          * and new security data, so we allocate them here to prevent ENOMEM in
1440          * our parent */
1441         ret = -ENOMEM;
1442         cred = cred_alloc_blank();
1443         if (!cred)
1444                 goto error_keyring;
1445
1446         cred->tgcred->session_keyring = key_ref_to_ptr(keyring_r);
1447         keyring_r = NULL;
1448
1449         me = current;
1450         rcu_read_lock();
1451         write_lock_irq(&tasklist_lock);
1452
1453         parent = me->real_parent;
1454         ret = -EPERM;
1455
1456         /* the parent mustn't be init and mustn't be a kernel thread */
1457         if (parent->pid <= 1 || !parent->mm)
1458                 goto not_permitted;
1459
1460         /* the parent must be single threaded */
1461         if (!thread_group_empty(parent))
1462                 goto not_permitted;
1463
1464         /* the parent and the child must have different session keyrings or
1465          * there's no point */
1466         mycred = current_cred();
1467         pcred = __task_cred(parent);
1468         if (mycred == pcred ||
1469             mycred->tgcred->session_keyring == pcred->tgcred->session_keyring)
1470                 goto already_same;
1471
1472         /* the parent must have the same effective ownership and mustn't be
1473          * SUID/SGID */
1474         if (pcred->uid  != mycred->euid ||
1475             pcred->euid != mycred->euid ||
1476             pcred->suid != mycred->euid ||
1477             pcred->gid  != mycred->egid ||
1478             pcred->egid != mycred->egid ||
1479             pcred->sgid != mycred->egid)
1480                 goto not_permitted;
1481
1482         /* the keyrings must have the same UID */
1483         if ((pcred->tgcred->session_keyring &&
1484              pcred->tgcred->session_keyring->uid != mycred->euid) ||
1485             mycred->tgcred->session_keyring->uid != mycred->euid)
1486                 goto not_permitted;
1487
1488         /* if there's an already pending keyring replacement, then we replace
1489          * that */
1490         oldcred = parent->replacement_session_keyring;
1491
1492         /* the replacement session keyring is applied just prior to userspace
1493          * restarting */
1494         parent->replacement_session_keyring = cred;
1495         cred = NULL;
1496         set_ti_thread_flag(task_thread_info(parent), TIF_NOTIFY_RESUME);
1497
1498         write_unlock_irq(&tasklist_lock);
1499         rcu_read_unlock();
1500         if (oldcred)
1501                 put_cred(oldcred);
1502         return 0;
1503
1504 already_same:
1505         ret = 0;
1506 not_permitted:
1507         write_unlock_irq(&tasklist_lock);
1508         rcu_read_unlock();
1509         put_cred(cred);
1510         return ret;
1511
1512 error_keyring:
1513         key_ref_put(keyring_r);
1514         return ret;
1515
1516 #else /* !TIF_NOTIFY_RESUME */
1517         /*
1518          * To be removed when TIF_NOTIFY_RESUME has been implemented on
1519          * m68k/xtensa
1520          */
1521 #warning TIF_NOTIFY_RESUME not implemented
1522         return -EOPNOTSUPP;
1523 #endif /* !TIF_NOTIFY_RESUME */
1524 }
1525
1526 /*
1527  * The key control system call
1528  */
1529 SYSCALL_DEFINE5(keyctl, int, option, unsigned long, arg2, unsigned long, arg3,
1530                 unsigned long, arg4, unsigned long, arg5)
1531 {
1532         switch (option) {
1533         case KEYCTL_GET_KEYRING_ID:
1534                 return keyctl_get_keyring_ID((key_serial_t) arg2,
1535                                              (int) arg3);
1536
1537         case KEYCTL_JOIN_SESSION_KEYRING:
1538                 return keyctl_join_session_keyring((const char __user *) arg2);
1539
1540         case KEYCTL_UPDATE:
1541                 return keyctl_update_key((key_serial_t) arg2,
1542                                          (const void __user *) arg3,
1543                                          (size_t) arg4);
1544
1545         case KEYCTL_REVOKE:
1546                 return keyctl_revoke_key((key_serial_t) arg2);
1547
1548         case KEYCTL_DESCRIBE:
1549                 return keyctl_describe_key((key_serial_t) arg2,
1550                                            (char __user *) arg3,
1551                                            (unsigned) arg4);
1552
1553         case KEYCTL_CLEAR:
1554                 return keyctl_keyring_clear((key_serial_t) arg2);
1555
1556         case KEYCTL_LINK:
1557                 return keyctl_keyring_link((key_serial_t) arg2,
1558                                            (key_serial_t) arg3);
1559
1560         case KEYCTL_UNLINK:
1561                 return keyctl_keyring_unlink((key_serial_t) arg2,
1562                                              (key_serial_t) arg3);
1563
1564         case KEYCTL_SEARCH:
1565                 return keyctl_keyring_search((key_serial_t) arg2,
1566                                              (const char __user *) arg3,
1567                                              (const char __user *) arg4,
1568                                              (key_serial_t) arg5);
1569
1570         case KEYCTL_READ:
1571                 return keyctl_read_key((key_serial_t) arg2,
1572                                        (char __user *) arg3,
1573                                        (size_t) arg4);
1574
1575         case KEYCTL_CHOWN:
1576                 return keyctl_chown_key((key_serial_t) arg2,
1577                                         (uid_t) arg3,
1578                                         (gid_t) arg4);
1579
1580         case KEYCTL_SETPERM:
1581                 return keyctl_setperm_key((key_serial_t) arg2,
1582                                           (key_perm_t) arg3);
1583
1584         case KEYCTL_INSTANTIATE:
1585                 return keyctl_instantiate_key((key_serial_t) arg2,
1586                                               (const void __user *) arg3,
1587                                               (size_t) arg4,
1588                                               (key_serial_t) arg5);
1589
1590         case KEYCTL_NEGATE:
1591                 return keyctl_negate_key((key_serial_t) arg2,
1592                                          (unsigned) arg3,
1593                                          (key_serial_t) arg4);
1594
1595         case KEYCTL_SET_REQKEY_KEYRING:
1596                 return keyctl_set_reqkey_keyring(arg2);
1597
1598         case KEYCTL_SET_TIMEOUT:
1599                 return keyctl_set_timeout((key_serial_t) arg2,
1600                                           (unsigned) arg3);
1601
1602         case KEYCTL_ASSUME_AUTHORITY:
1603                 return keyctl_assume_authority((key_serial_t) arg2);
1604
1605         case KEYCTL_GET_SECURITY:
1606                 return keyctl_get_security((key_serial_t) arg2,
1607                                            (char __user *) arg3,
1608                                            (size_t) arg4);
1609
1610         case KEYCTL_SESSION_TO_PARENT:
1611                 return keyctl_session_to_parent();
1612
1613         case KEYCTL_REJECT:
1614                 return keyctl_reject_key((key_serial_t) arg2,
1615                                          (unsigned) arg3,
1616                                          (unsigned) arg4,
1617                                          (key_serial_t) arg5);
1618
1619         case KEYCTL_INSTANTIATE_IOV:
1620                 return keyctl_instantiate_key_iov(
1621                         (key_serial_t) arg2,
1622                         (const struct iovec __user *) arg3,
1623                         (unsigned) arg4,
1624                         (key_serial_t) arg5);
1625
1626         default:
1627                 return -EOPNOTSUPP;
1628         }
1629 }