keys: allow the callout data to be passed as a blob rather than a string
[linux-2.6] / security / keys / keyctl.c
1 /* keyctl.c: userspace keyctl 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 <asm/uaccess.h>
24 #include "internal.h"
25
26 static int key_get_type_from_user(char *type,
27                                   const char __user *_type,
28                                   unsigned len)
29 {
30         int ret;
31
32         ret = strncpy_from_user(type, _type, len);
33
34         if (ret < 0)
35                 return -EFAULT;
36
37         if (ret == 0 || ret >= len)
38                 return -EINVAL;
39
40         if (type[0] == '.')
41                 return -EPERM;
42
43         type[len - 1] = '\0';
44
45         return 0;
46 }
47
48 /*****************************************************************************/
49 /*
50  * extract the description of a new key from userspace and either add it as a
51  * new key to the specified keyring or update a matching key in that keyring
52  * - the keyring must be writable
53  * - returns the new key's serial number
54  * - implements add_key()
55  */
56 asmlinkage long sys_add_key(const char __user *_type,
57                             const char __user *_description,
58                             const void __user *_payload,
59                             size_t plen,
60                             key_serial_t ringid)
61 {
62         key_ref_t keyring_ref, key_ref;
63         char type[32], *description;
64         void *payload;
65         long ret;
66         bool vm;
67
68         ret = -EINVAL;
69         if (plen > 1024 * 1024 - 1)
70                 goto error;
71
72         /* draw all the data into kernel space */
73         ret = key_get_type_from_user(type, _type, sizeof(type));
74         if (ret < 0)
75                 goto error;
76
77         description = strndup_user(_description, PAGE_SIZE);
78         if (IS_ERR(description)) {
79                 ret = PTR_ERR(description);
80                 goto error;
81         }
82
83         /* pull the payload in if one was supplied */
84         payload = NULL;
85
86         vm = false;
87         if (_payload) {
88                 ret = -ENOMEM;
89                 payload = kmalloc(plen, GFP_KERNEL);
90                 if (!payload) {
91                         if (plen <= PAGE_SIZE)
92                                 goto error2;
93                         vm = true;
94                         payload = vmalloc(plen);
95                         if (!payload)
96                                 goto error2;
97                 }
98
99                 ret = -EFAULT;
100                 if (copy_from_user(payload, _payload, plen) != 0)
101                         goto error3;
102         }
103
104         /* find the target keyring (which must be writable) */
105         keyring_ref = lookup_user_key(NULL, ringid, 1, 0, KEY_WRITE);
106         if (IS_ERR(keyring_ref)) {
107                 ret = PTR_ERR(keyring_ref);
108                 goto error3;
109         }
110
111         /* create or update the requested key and add it to the target
112          * keyring */
113         key_ref = key_create_or_update(keyring_ref, type, description,
114                                        payload, plen, KEY_ALLOC_IN_QUOTA);
115         if (!IS_ERR(key_ref)) {
116                 ret = key_ref_to_ptr(key_ref)->serial;
117                 key_ref_put(key_ref);
118         }
119         else {
120                 ret = PTR_ERR(key_ref);
121         }
122
123         key_ref_put(keyring_ref);
124  error3:
125         if (!vm)
126                 kfree(payload);
127         else
128                 vfree(payload);
129  error2:
130         kfree(description);
131  error:
132         return ret;
133
134 } /* end sys_add_key() */
135
136 /*****************************************************************************/
137 /*
138  * search the process keyrings for a matching key
139  * - nested keyrings may also be searched if they have Search permission
140  * - if a key is found, it will be attached to the destination keyring if
141  *   there's one specified
142  * - /sbin/request-key will be invoked if _callout_info is non-NULL
143  *   - the _callout_info string will be passed to /sbin/request-key
144  *   - if the _callout_info string is empty, it will be rendered as "-"
145  * - implements request_key()
146  */
147 asmlinkage long sys_request_key(const char __user *_type,
148                                 const char __user *_description,
149                                 const char __user *_callout_info,
150                                 key_serial_t destringid)
151 {
152         struct key_type *ktype;
153         struct key *key;
154         key_ref_t dest_ref;
155         size_t callout_len;
156         char type[32], *description, *callout_info;
157         long ret;
158
159         /* pull the type into kernel space */
160         ret = key_get_type_from_user(type, _type, sizeof(type));
161         if (ret < 0)
162                 goto error;
163
164         /* pull the description into kernel space */
165         description = strndup_user(_description, PAGE_SIZE);
166         if (IS_ERR(description)) {
167                 ret = PTR_ERR(description);
168                 goto error;
169         }
170
171         /* pull the callout info into kernel space */
172         callout_info = NULL;
173         callout_len = 0;
174         if (_callout_info) {
175                 callout_info = strndup_user(_callout_info, PAGE_SIZE);
176                 if (IS_ERR(callout_info)) {
177                         ret = PTR_ERR(callout_info);
178                         goto error2;
179                 }
180                 callout_len = strlen(callout_info);
181         }
182
183         /* get the destination keyring if specified */
184         dest_ref = NULL;
185         if (destringid) {
186                 dest_ref = lookup_user_key(NULL, destringid, 1, 0, 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         ret = key->serial;
210
211         key_put(key);
212  error5:
213         key_type_put(ktype);
214  error4:
215         key_ref_put(dest_ref);
216  error3:
217         kfree(callout_info);
218  error2:
219         kfree(description);
220  error:
221         return ret;
222
223 } /* end sys_request_key() */
224
225 /*****************************************************************************/
226 /*
227  * get the ID of the specified process keyring
228  * - the keyring must have search permission to be found
229  * - implements keyctl(KEYCTL_GET_KEYRING_ID)
230  */
231 long keyctl_get_keyring_ID(key_serial_t id, int create)
232 {
233         key_ref_t key_ref;
234         long ret;
235
236         key_ref = lookup_user_key(NULL, id, create, 0, KEY_SEARCH);
237         if (IS_ERR(key_ref)) {
238                 ret = PTR_ERR(key_ref);
239                 goto error;
240         }
241
242         ret = key_ref_to_ptr(key_ref)->serial;
243         key_ref_put(key_ref);
244  error:
245         return ret;
246
247 } /* end keyctl_get_keyring_ID() */
248
249 /*****************************************************************************/
250 /*
251  * join the session keyring
252  * - implements keyctl(KEYCTL_JOIN_SESSION_KEYRING)
253  */
254 long keyctl_join_session_keyring(const char __user *_name)
255 {
256         char *name;
257         long ret;
258
259         /* fetch the name from userspace */
260         name = NULL;
261         if (_name) {
262                 name = strndup_user(_name, PAGE_SIZE);
263                 if (IS_ERR(name)) {
264                         ret = PTR_ERR(name);
265                         goto error;
266                 }
267         }
268
269         /* join the session */
270         ret = join_session_keyring(name);
271
272  error:
273         return ret;
274
275 } /* end keyctl_join_session_keyring() */
276
277 /*****************************************************************************/
278 /*
279  * update a key's data payload
280  * - the key must be writable
281  * - implements keyctl(KEYCTL_UPDATE)
282  */
283 long keyctl_update_key(key_serial_t id,
284                        const void __user *_payload,
285                        size_t plen)
286 {
287         key_ref_t key_ref;
288         void *payload;
289         long ret;
290
291         ret = -EINVAL;
292         if (plen > PAGE_SIZE)
293                 goto error;
294
295         /* pull the payload in if one was supplied */
296         payload = NULL;
297         if (_payload) {
298                 ret = -ENOMEM;
299                 payload = kmalloc(plen, GFP_KERNEL);
300                 if (!payload)
301                         goto error;
302
303                 ret = -EFAULT;
304                 if (copy_from_user(payload, _payload, plen) != 0)
305                         goto error2;
306         }
307
308         /* find the target key (which must be writable) */
309         key_ref = lookup_user_key(NULL, id, 0, 0, KEY_WRITE);
310         if (IS_ERR(key_ref)) {
311                 ret = PTR_ERR(key_ref);
312                 goto error2;
313         }
314
315         /* update the key */
316         ret = key_update(key_ref, payload, plen);
317
318         key_ref_put(key_ref);
319  error2:
320         kfree(payload);
321  error:
322         return ret;
323
324 } /* end keyctl_update_key() */
325
326 /*****************************************************************************/
327 /*
328  * revoke a key
329  * - the key must be writable
330  * - implements keyctl(KEYCTL_REVOKE)
331  */
332 long keyctl_revoke_key(key_serial_t id)
333 {
334         key_ref_t key_ref;
335         long ret;
336
337         key_ref = lookup_user_key(NULL, id, 0, 0, KEY_WRITE);
338         if (IS_ERR(key_ref)) {
339                 ret = PTR_ERR(key_ref);
340                 goto error;
341         }
342
343         key_revoke(key_ref_to_ptr(key_ref));
344         ret = 0;
345
346         key_ref_put(key_ref);
347  error:
348         return ret;
349
350 } /* end keyctl_revoke_key() */
351
352 /*****************************************************************************/
353 /*
354  * clear the specified process keyring
355  * - the keyring must be writable
356  * - implements keyctl(KEYCTL_CLEAR)
357  */
358 long keyctl_keyring_clear(key_serial_t ringid)
359 {
360         key_ref_t keyring_ref;
361         long ret;
362
363         keyring_ref = lookup_user_key(NULL, ringid, 1, 0, KEY_WRITE);
364         if (IS_ERR(keyring_ref)) {
365                 ret = PTR_ERR(keyring_ref);
366                 goto error;
367         }
368
369         ret = keyring_clear(key_ref_to_ptr(keyring_ref));
370
371         key_ref_put(keyring_ref);
372  error:
373         return ret;
374
375 } /* end keyctl_keyring_clear() */
376
377 /*****************************************************************************/
378 /*
379  * link a key into a keyring
380  * - the keyring must be writable
381  * - the key must be linkable
382  * - implements keyctl(KEYCTL_LINK)
383  */
384 long keyctl_keyring_link(key_serial_t id, key_serial_t ringid)
385 {
386         key_ref_t keyring_ref, key_ref;
387         long ret;
388
389         keyring_ref = lookup_user_key(NULL, ringid, 1, 0, KEY_WRITE);
390         if (IS_ERR(keyring_ref)) {
391                 ret = PTR_ERR(keyring_ref);
392                 goto error;
393         }
394
395         key_ref = lookup_user_key(NULL, id, 1, 0, KEY_LINK);
396         if (IS_ERR(key_ref)) {
397                 ret = PTR_ERR(key_ref);
398                 goto error2;
399         }
400
401         ret = key_link(key_ref_to_ptr(keyring_ref), key_ref_to_ptr(key_ref));
402
403         key_ref_put(key_ref);
404  error2:
405         key_ref_put(keyring_ref);
406  error:
407         return ret;
408
409 } /* end keyctl_keyring_link() */
410
411 /*****************************************************************************/
412 /*
413  * unlink the first attachment of a key from a keyring
414  * - the keyring must be writable
415  * - we don't need any permissions on the key
416  * - implements keyctl(KEYCTL_UNLINK)
417  */
418 long keyctl_keyring_unlink(key_serial_t id, key_serial_t ringid)
419 {
420         key_ref_t keyring_ref, key_ref;
421         long ret;
422
423         keyring_ref = lookup_user_key(NULL, ringid, 0, 0, KEY_WRITE);
424         if (IS_ERR(keyring_ref)) {
425                 ret = PTR_ERR(keyring_ref);
426                 goto error;
427         }
428
429         key_ref = lookup_user_key(NULL, id, 0, 0, 0);
430         if (IS_ERR(key_ref)) {
431                 ret = PTR_ERR(key_ref);
432                 goto error2;
433         }
434
435         ret = key_unlink(key_ref_to_ptr(keyring_ref), key_ref_to_ptr(key_ref));
436
437         key_ref_put(key_ref);
438  error2:
439         key_ref_put(keyring_ref);
440  error:
441         return ret;
442
443 } /* end keyctl_keyring_unlink() */
444
445 /*****************************************************************************/
446 /*
447  * describe a user key
448  * - the key must have view permission
449  * - if there's a buffer, we place up to buflen bytes of data into it
450  * - unless there's an error, we return the amount of description available,
451  *   irrespective of how much we may have copied
452  * - the description is formatted thus:
453  *      type;uid;gid;perm;description<NUL>
454  * - implements keyctl(KEYCTL_DESCRIBE)
455  */
456 long keyctl_describe_key(key_serial_t keyid,
457                          char __user *buffer,
458                          size_t buflen)
459 {
460         struct key *key, *instkey;
461         key_ref_t key_ref;
462         char *tmpbuf;
463         long ret;
464
465         key_ref = lookup_user_key(NULL, keyid, 0, 1, KEY_VIEW);
466         if (IS_ERR(key_ref)) {
467                 /* viewing a key under construction is permitted if we have the
468                  * authorisation token handy */
469                 if (PTR_ERR(key_ref) == -EACCES) {
470                         instkey = key_get_instantiation_authkey(keyid);
471                         if (!IS_ERR(instkey)) {
472                                 key_put(instkey);
473                                 key_ref = lookup_user_key(NULL, keyid,
474                                                           0, 1, 0);
475                                 if (!IS_ERR(key_ref))
476                                         goto okay;
477                         }
478                 }
479
480                 ret = PTR_ERR(key_ref);
481                 goto error;
482         }
483
484 okay:
485         /* calculate how much description we're going to return */
486         ret = -ENOMEM;
487         tmpbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
488         if (!tmpbuf)
489                 goto error2;
490
491         key = key_ref_to_ptr(key_ref);
492
493         ret = snprintf(tmpbuf, PAGE_SIZE - 1,
494                        "%s;%d;%d;%08x;%s",
495                        key_ref_to_ptr(key_ref)->type->name,
496                        key_ref_to_ptr(key_ref)->uid,
497                        key_ref_to_ptr(key_ref)->gid,
498                        key_ref_to_ptr(key_ref)->perm,
499                        key_ref_to_ptr(key_ref)->description ?
500                        key_ref_to_ptr(key_ref)->description : ""
501                        );
502
503         /* include a NUL char at the end of the data */
504         if (ret > PAGE_SIZE - 1)
505                 ret = PAGE_SIZE - 1;
506         tmpbuf[ret] = 0;
507         ret++;
508
509         /* consider returning the data */
510         if (buffer && buflen > 0) {
511                 if (buflen > ret)
512                         buflen = ret;
513
514                 if (copy_to_user(buffer, tmpbuf, buflen) != 0)
515                         ret = -EFAULT;
516         }
517
518         kfree(tmpbuf);
519  error2:
520         key_ref_put(key_ref);
521  error:
522         return ret;
523
524 } /* end keyctl_describe_key() */
525
526 /*****************************************************************************/
527 /*
528  * search the specified keyring for a matching key
529  * - the start keyring must be searchable
530  * - nested keyrings may also be searched if they are searchable
531  * - only keys with search permission may be found
532  * - if a key is found, it will be attached to the destination keyring if
533  *   there's one specified
534  * - implements keyctl(KEYCTL_SEARCH)
535  */
536 long keyctl_keyring_search(key_serial_t ringid,
537                            const char __user *_type,
538                            const char __user *_description,
539                            key_serial_t destringid)
540 {
541         struct key_type *ktype;
542         key_ref_t keyring_ref, key_ref, dest_ref;
543         char type[32], *description;
544         long ret;
545
546         /* pull the type and description into kernel space */
547         ret = key_get_type_from_user(type, _type, sizeof(type));
548         if (ret < 0)
549                 goto error;
550
551         description = strndup_user(_description, PAGE_SIZE);
552         if (IS_ERR(description)) {
553                 ret = PTR_ERR(description);
554                 goto error;
555         }
556
557         /* get the keyring at which to begin the search */
558         keyring_ref = lookup_user_key(NULL, ringid, 0, 0, KEY_SEARCH);
559         if (IS_ERR(keyring_ref)) {
560                 ret = PTR_ERR(keyring_ref);
561                 goto error2;
562         }
563
564         /* get the destination keyring if specified */
565         dest_ref = NULL;
566         if (destringid) {
567                 dest_ref = lookup_user_key(NULL, destringid, 1, 0, KEY_WRITE);
568                 if (IS_ERR(dest_ref)) {
569                         ret = PTR_ERR(dest_ref);
570                         goto error3;
571                 }
572         }
573
574         /* find the key type */
575         ktype = key_type_lookup(type);
576         if (IS_ERR(ktype)) {
577                 ret = PTR_ERR(ktype);
578                 goto error4;
579         }
580
581         /* do the search */
582         key_ref = keyring_search(keyring_ref, ktype, description);
583         if (IS_ERR(key_ref)) {
584                 ret = PTR_ERR(key_ref);
585
586                 /* treat lack or presence of a negative key the same */
587                 if (ret == -EAGAIN)
588                         ret = -ENOKEY;
589                 goto error5;
590         }
591
592         /* link the resulting key to the destination keyring if we can */
593         if (dest_ref) {
594                 ret = key_permission(key_ref, KEY_LINK);
595                 if (ret < 0)
596                         goto error6;
597
598                 ret = key_link(key_ref_to_ptr(dest_ref), key_ref_to_ptr(key_ref));
599                 if (ret < 0)
600                         goto error6;
601         }
602
603         ret = key_ref_to_ptr(key_ref)->serial;
604
605  error6:
606         key_ref_put(key_ref);
607  error5:
608         key_type_put(ktype);
609  error4:
610         key_ref_put(dest_ref);
611  error3:
612         key_ref_put(keyring_ref);
613  error2:
614         kfree(description);
615  error:
616         return ret;
617
618 } /* end keyctl_keyring_search() */
619
620 /*****************************************************************************/
621 /*
622  * read a user key's payload
623  * - the keyring must be readable or the key must be searchable from the
624  *   process's keyrings
625  * - if there's a buffer, we place up to buflen bytes of data into it
626  * - unless there's an error, we return the amount of data in the key,
627  *   irrespective of how much we may have copied
628  * - implements keyctl(KEYCTL_READ)
629  */
630 long keyctl_read_key(key_serial_t keyid, char __user *buffer, size_t buflen)
631 {
632         struct key *key;
633         key_ref_t key_ref;
634         long ret;
635
636         /* find the key first */
637         key_ref = lookup_user_key(NULL, keyid, 0, 0, 0);
638         if (IS_ERR(key_ref)) {
639                 ret = -ENOKEY;
640                 goto error;
641         }
642
643         key = key_ref_to_ptr(key_ref);
644
645         /* see if we can read it directly */
646         ret = key_permission(key_ref, KEY_READ);
647         if (ret == 0)
648                 goto can_read_key;
649         if (ret != -EACCES)
650                 goto error;
651
652         /* we can't; see if it's searchable from this process's keyrings
653          * - we automatically take account of the fact that it may be
654          *   dangling off an instantiation key
655          */
656         if (!is_key_possessed(key_ref)) {
657                 ret = -EACCES;
658                 goto error2;
659         }
660
661         /* the key is probably readable - now try to read it */
662  can_read_key:
663         ret = key_validate(key);
664         if (ret == 0) {
665                 ret = -EOPNOTSUPP;
666                 if (key->type->read) {
667                         /* read the data with the semaphore held (since we
668                          * might sleep) */
669                         down_read(&key->sem);
670                         ret = key->type->read(key, buffer, buflen);
671                         up_read(&key->sem);
672                 }
673         }
674
675  error2:
676         key_put(key);
677  error:
678         return ret;
679
680 } /* end keyctl_read_key() */
681
682 /*****************************************************************************/
683 /*
684  * change the ownership of a key
685  * - the keyring owned by the changer
686  * - if the uid or gid is -1, then that parameter is not changed
687  * - implements keyctl(KEYCTL_CHOWN)
688  */
689 long keyctl_chown_key(key_serial_t id, uid_t uid, gid_t gid)
690 {
691         struct key_user *newowner, *zapowner = NULL;
692         struct key *key;
693         key_ref_t key_ref;
694         long ret;
695
696         ret = 0;
697         if (uid == (uid_t) -1 && gid == (gid_t) -1)
698                 goto error;
699
700         key_ref = lookup_user_key(NULL, id, 1, 1, KEY_SETATTR);
701         if (IS_ERR(key_ref)) {
702                 ret = PTR_ERR(key_ref);
703                 goto error;
704         }
705
706         key = key_ref_to_ptr(key_ref);
707
708         /* make the changes with the locks held to prevent chown/chown races */
709         ret = -EACCES;
710         down_write(&key->sem);
711
712         if (!capable(CAP_SYS_ADMIN)) {
713                 /* only the sysadmin can chown a key to some other UID */
714                 if (uid != (uid_t) -1 && key->uid != uid)
715                         goto error_put;
716
717                 /* only the sysadmin can set the key's GID to a group other
718                  * than one of those that the current process subscribes to */
719                 if (gid != (gid_t) -1 && gid != key->gid && !in_group_p(gid))
720                         goto error_put;
721         }
722
723         /* change the UID */
724         if (uid != (uid_t) -1 && uid != key->uid) {
725                 ret = -ENOMEM;
726                 newowner = key_user_lookup(uid);
727                 if (!newowner)
728                         goto error_put;
729
730                 /* transfer the quota burden to the new user */
731                 if (test_bit(KEY_FLAG_IN_QUOTA, &key->flags)) {
732                         spin_lock(&newowner->lock);
733                         if (newowner->qnkeys + 1 >= KEYQUOTA_MAX_KEYS ||
734                             newowner->qnbytes + key->quotalen >=
735                             KEYQUOTA_MAX_BYTES)
736                                 goto quota_overrun;
737
738                         newowner->qnkeys++;
739                         newowner->qnbytes += key->quotalen;
740                         spin_unlock(&newowner->lock);
741
742                         spin_lock(&key->user->lock);
743                         key->user->qnkeys--;
744                         key->user->qnbytes -= key->quotalen;
745                         spin_unlock(&key->user->lock);
746                 }
747
748                 atomic_dec(&key->user->nkeys);
749                 atomic_inc(&newowner->nkeys);
750
751                 if (test_bit(KEY_FLAG_INSTANTIATED, &key->flags)) {
752                         atomic_dec(&key->user->nikeys);
753                         atomic_inc(&newowner->nikeys);
754                 }
755
756                 zapowner = key->user;
757                 key->user = newowner;
758                 key->uid = uid;
759         }
760
761         /* change the GID */
762         if (gid != (gid_t) -1)
763                 key->gid = gid;
764
765         ret = 0;
766
767 error_put:
768         up_write(&key->sem);
769         key_put(key);
770         if (zapowner)
771                 key_user_put(zapowner);
772 error:
773         return ret;
774
775 quota_overrun:
776         spin_unlock(&newowner->lock);
777         zapowner = newowner;
778         ret = -EDQUOT;
779         goto error_put;
780
781 } /* end keyctl_chown_key() */
782
783 /*****************************************************************************/
784 /*
785  * change the permission mask on a key
786  * - the keyring owned by the changer
787  * - implements keyctl(KEYCTL_SETPERM)
788  */
789 long keyctl_setperm_key(key_serial_t id, key_perm_t perm)
790 {
791         struct key *key;
792         key_ref_t key_ref;
793         long ret;
794
795         ret = -EINVAL;
796         if (perm & ~(KEY_POS_ALL | KEY_USR_ALL | KEY_GRP_ALL | KEY_OTH_ALL))
797                 goto error;
798
799         key_ref = lookup_user_key(NULL, id, 1, 1, KEY_SETATTR);
800         if (IS_ERR(key_ref)) {
801                 ret = PTR_ERR(key_ref);
802                 goto error;
803         }
804
805         key = key_ref_to_ptr(key_ref);
806
807         /* make the changes with the locks held to prevent chown/chmod races */
808         ret = -EACCES;
809         down_write(&key->sem);
810
811         /* if we're not the sysadmin, we can only change a key that we own */
812         if (capable(CAP_SYS_ADMIN) || key->uid == current->fsuid) {
813                 key->perm = perm;
814                 ret = 0;
815         }
816
817         up_write(&key->sem);
818         key_put(key);
819 error:
820         return ret;
821
822 } /* end keyctl_setperm_key() */
823
824 /*****************************************************************************/
825 /*
826  * instantiate the key with the specified payload, and, if one is given, link
827  * the key into the keyring
828  */
829 long keyctl_instantiate_key(key_serial_t id,
830                             const void __user *_payload,
831                             size_t plen,
832                             key_serial_t ringid)
833 {
834         struct request_key_auth *rka;
835         struct key *instkey;
836         key_ref_t keyring_ref;
837         void *payload;
838         long ret;
839         bool vm = false;
840
841         ret = -EINVAL;
842         if (plen > 1024 * 1024 - 1)
843                 goto error;
844
845         /* the appropriate instantiation authorisation key must have been
846          * assumed before calling this */
847         ret = -EPERM;
848         instkey = current->request_key_auth;
849         if (!instkey)
850                 goto error;
851
852         rka = instkey->payload.data;
853         if (rka->target_key->serial != id)
854                 goto error;
855
856         /* pull the payload in if one was supplied */
857         payload = NULL;
858
859         if (_payload) {
860                 ret = -ENOMEM;
861                 payload = kmalloc(plen, GFP_KERNEL);
862                 if (!payload) {
863                         if (plen <= PAGE_SIZE)
864                                 goto error;
865                         vm = true;
866                         payload = vmalloc(plen);
867                         if (!payload)
868                                 goto error;
869                 }
870
871                 ret = -EFAULT;
872                 if (copy_from_user(payload, _payload, plen) != 0)
873                         goto error2;
874         }
875
876         /* find the destination keyring amongst those belonging to the
877          * requesting task */
878         keyring_ref = NULL;
879         if (ringid) {
880                 keyring_ref = lookup_user_key(rka->context, ringid, 1, 0,
881                                               KEY_WRITE);
882                 if (IS_ERR(keyring_ref)) {
883                         ret = PTR_ERR(keyring_ref);
884                         goto error2;
885                 }
886         }
887
888         /* instantiate the key and link it into a keyring */
889         ret = key_instantiate_and_link(rka->target_key, payload, plen,
890                                        key_ref_to_ptr(keyring_ref), instkey);
891
892         key_ref_put(keyring_ref);
893
894         /* discard the assumed authority if it's just been disabled by
895          * instantiation of the key */
896         if (ret == 0) {
897                 key_put(current->request_key_auth);
898                 current->request_key_auth = NULL;
899         }
900
901 error2:
902         if (!vm)
903                 kfree(payload);
904         else
905                 vfree(payload);
906 error:
907         return ret;
908
909 } /* end keyctl_instantiate_key() */
910
911 /*****************************************************************************/
912 /*
913  * negatively instantiate the key with the given timeout (in seconds), and, if
914  * one is given, link the key into the keyring
915  */
916 long keyctl_negate_key(key_serial_t id, unsigned timeout, key_serial_t ringid)
917 {
918         struct request_key_auth *rka;
919         struct key *instkey;
920         key_ref_t keyring_ref;
921         long ret;
922
923         /* the appropriate instantiation authorisation key must have been
924          * assumed before calling this */
925         ret = -EPERM;
926         instkey = current->request_key_auth;
927         if (!instkey)
928                 goto error;
929
930         rka = instkey->payload.data;
931         if (rka->target_key->serial != id)
932                 goto error;
933
934         /* find the destination keyring if present (which must also be
935          * writable) */
936         keyring_ref = NULL;
937         if (ringid) {
938                 keyring_ref = lookup_user_key(NULL, ringid, 1, 0, KEY_WRITE);
939                 if (IS_ERR(keyring_ref)) {
940                         ret = PTR_ERR(keyring_ref);
941                         goto error;
942                 }
943         }
944
945         /* instantiate the key and link it into a keyring */
946         ret = key_negate_and_link(rka->target_key, timeout,
947                                   key_ref_to_ptr(keyring_ref), instkey);
948
949         key_ref_put(keyring_ref);
950
951         /* discard the assumed authority if it's just been disabled by
952          * instantiation of the key */
953         if (ret == 0) {
954                 key_put(current->request_key_auth);
955                 current->request_key_auth = NULL;
956         }
957
958 error:
959         return ret;
960
961 } /* end keyctl_negate_key() */
962
963 /*****************************************************************************/
964 /*
965  * set the default keyring in which request_key() will cache keys
966  * - return the old setting
967  */
968 long keyctl_set_reqkey_keyring(int reqkey_defl)
969 {
970         int ret;
971
972         switch (reqkey_defl) {
973         case KEY_REQKEY_DEFL_THREAD_KEYRING:
974                 ret = install_thread_keyring(current);
975                 if (ret < 0)
976                         return ret;
977                 goto set;
978
979         case KEY_REQKEY_DEFL_PROCESS_KEYRING:
980                 ret = install_process_keyring(current);
981                 if (ret < 0)
982                         return ret;
983
984         case KEY_REQKEY_DEFL_DEFAULT:
985         case KEY_REQKEY_DEFL_SESSION_KEYRING:
986         case KEY_REQKEY_DEFL_USER_KEYRING:
987         case KEY_REQKEY_DEFL_USER_SESSION_KEYRING:
988         set:
989                 current->jit_keyring = reqkey_defl;
990
991         case KEY_REQKEY_DEFL_NO_CHANGE:
992                 return current->jit_keyring;
993
994         case KEY_REQKEY_DEFL_GROUP_KEYRING:
995         default:
996                 return -EINVAL;
997         }
998
999 } /* end keyctl_set_reqkey_keyring() */
1000
1001 /*****************************************************************************/
1002 /*
1003  * set or clear the timeout for a key
1004  */
1005 long keyctl_set_timeout(key_serial_t id, unsigned timeout)
1006 {
1007         struct timespec now;
1008         struct key *key;
1009         key_ref_t key_ref;
1010         time_t expiry;
1011         long ret;
1012
1013         key_ref = lookup_user_key(NULL, id, 1, 1, KEY_SETATTR);
1014         if (IS_ERR(key_ref)) {
1015                 ret = PTR_ERR(key_ref);
1016                 goto error;
1017         }
1018
1019         key = key_ref_to_ptr(key_ref);
1020
1021         /* make the changes with the locks held to prevent races */
1022         down_write(&key->sem);
1023
1024         expiry = 0;
1025         if (timeout > 0) {
1026                 now = current_kernel_time();
1027                 expiry = now.tv_sec + timeout;
1028         }
1029
1030         key->expiry = expiry;
1031
1032         up_write(&key->sem);
1033         key_put(key);
1034
1035         ret = 0;
1036 error:
1037         return ret;
1038
1039 } /* end keyctl_set_timeout() */
1040
1041 /*****************************************************************************/
1042 /*
1043  * assume the authority to instantiate the specified key
1044  */
1045 long keyctl_assume_authority(key_serial_t id)
1046 {
1047         struct key *authkey;
1048         long ret;
1049
1050         /* special key IDs aren't permitted */
1051         ret = -EINVAL;
1052         if (id < 0)
1053                 goto error;
1054
1055         /* we divest ourselves of authority if given an ID of 0 */
1056         if (id == 0) {
1057                 key_put(current->request_key_auth);
1058                 current->request_key_auth = NULL;
1059                 ret = 0;
1060                 goto error;
1061         }
1062
1063         /* attempt to assume the authority temporarily granted to us whilst we
1064          * instantiate the specified key
1065          * - the authorisation key must be in the current task's keyrings
1066          *   somewhere
1067          */
1068         authkey = key_get_instantiation_authkey(id);
1069         if (IS_ERR(authkey)) {
1070                 ret = PTR_ERR(authkey);
1071                 goto error;
1072         }
1073
1074         key_put(current->request_key_auth);
1075         current->request_key_auth = authkey;
1076         ret = authkey->serial;
1077
1078 error:
1079         return ret;
1080
1081 } /* end keyctl_assume_authority() */
1082
1083 /*****************************************************************************/
1084 /*
1085  * the key control system call
1086  */
1087 asmlinkage long sys_keyctl(int option, unsigned long arg2, unsigned long arg3,
1088                            unsigned long arg4, unsigned long arg5)
1089 {
1090         switch (option) {
1091         case KEYCTL_GET_KEYRING_ID:
1092                 return keyctl_get_keyring_ID((key_serial_t) arg2,
1093                                              (int) arg3);
1094
1095         case KEYCTL_JOIN_SESSION_KEYRING:
1096                 return keyctl_join_session_keyring((const char __user *) arg2);
1097
1098         case KEYCTL_UPDATE:
1099                 return keyctl_update_key((key_serial_t) arg2,
1100                                          (const void __user *) arg3,
1101                                          (size_t) arg4);
1102
1103         case KEYCTL_REVOKE:
1104                 return keyctl_revoke_key((key_serial_t) arg2);
1105
1106         case KEYCTL_DESCRIBE:
1107                 return keyctl_describe_key((key_serial_t) arg2,
1108                                            (char __user *) arg3,
1109                                            (unsigned) arg4);
1110
1111         case KEYCTL_CLEAR:
1112                 return keyctl_keyring_clear((key_serial_t) arg2);
1113
1114         case KEYCTL_LINK:
1115                 return keyctl_keyring_link((key_serial_t) arg2,
1116                                            (key_serial_t) arg3);
1117
1118         case KEYCTL_UNLINK:
1119                 return keyctl_keyring_unlink((key_serial_t) arg2,
1120                                              (key_serial_t) arg3);
1121
1122         case KEYCTL_SEARCH:
1123                 return keyctl_keyring_search((key_serial_t) arg2,
1124                                              (const char __user *) arg3,
1125                                              (const char __user *) arg4,
1126                                              (key_serial_t) arg5);
1127
1128         case KEYCTL_READ:
1129                 return keyctl_read_key((key_serial_t) arg2,
1130                                        (char __user *) arg3,
1131                                        (size_t) arg4);
1132
1133         case KEYCTL_CHOWN:
1134                 return keyctl_chown_key((key_serial_t) arg2,
1135                                         (uid_t) arg3,
1136                                         (gid_t) arg4);
1137
1138         case KEYCTL_SETPERM:
1139                 return keyctl_setperm_key((key_serial_t) arg2,
1140                                           (key_perm_t) arg3);
1141
1142         case KEYCTL_INSTANTIATE:
1143                 return keyctl_instantiate_key((key_serial_t) arg2,
1144                                               (const void __user *) arg3,
1145                                               (size_t) arg4,
1146                                               (key_serial_t) arg5);
1147
1148         case KEYCTL_NEGATE:
1149                 return keyctl_negate_key((key_serial_t) arg2,
1150                                          (unsigned) arg3,
1151                                          (key_serial_t) arg4);
1152
1153         case KEYCTL_SET_REQKEY_KEYRING:
1154                 return keyctl_set_reqkey_keyring(arg2);
1155
1156         case KEYCTL_SET_TIMEOUT:
1157                 return keyctl_set_timeout((key_serial_t) arg2,
1158                                           (unsigned) arg3);
1159
1160         case KEYCTL_ASSUME_AUTHORITY:
1161                 return keyctl_assume_authority((key_serial_t) arg2);
1162
1163         default:
1164                 return -EOPNOTSUPP;
1165         }
1166
1167 } /* end sys_keyctl() */