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