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