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