12874c5fdSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later 2973c9f4fSDavid Howells /* Userspace key control operations 31da177e4SLinus Torvalds * 43e30148cSDavid Howells * Copyright (C) 2004-5 Red Hat, Inc. All Rights Reserved. 51da177e4SLinus Torvalds * Written by David Howells (dhowells@redhat.com) 61da177e4SLinus Torvalds */ 71da177e4SLinus Torvalds 81da177e4SLinus Torvalds #include <linux/init.h> 91da177e4SLinus Torvalds #include <linux/sched.h> 1029930025SIngo Molnar #include <linux/sched/task.h> 111da177e4SLinus Torvalds #include <linux/slab.h> 121da177e4SLinus Torvalds #include <linux/syscalls.h> 1359e6b9c1SBryan Schumaker #include <linux/key.h> 141da177e4SLinus Torvalds #include <linux/keyctl.h> 151da177e4SLinus Torvalds #include <linux/fs.h> 16c59ede7bSRandy.Dunlap #include <linux/capability.h> 175b825c3aSIngo Molnar #include <linux/cred.h> 180cb409d9SDavi Arnaut #include <linux/string.h> 191da177e4SLinus Torvalds #include <linux/err.h> 2038bbca6bSDavid Howells #include <linux/vmalloc.h> 2170a5bb72SDavid Howells #include <linux/security.h> 22a27bb332SKent Overstreet #include <linux/uio.h> 237c0f6ba6SLinus Torvalds #include <linux/uaccess.h> 24822ad64dSDavid Howells #include <keys/request_key_auth-type.h> 251da177e4SLinus Torvalds #include "internal.h" 261da177e4SLinus Torvalds 27aa9d4437SDavid Howells #define KEY_MAX_DESC_SIZE 4096 28aa9d4437SDavid Howells 29b206f281SDavid Howells static const unsigned char keyrings_capabilities[2] = { 3045e0f30cSDavid Howells [0] = (KEYCTL_CAPS0_CAPABILITIES | 3145e0f30cSDavid Howells (IS_ENABLED(CONFIG_PERSISTENT_KEYRINGS) ? KEYCTL_CAPS0_PERSISTENT_KEYRINGS : 0) | 3245e0f30cSDavid Howells (IS_ENABLED(CONFIG_KEY_DH_OPERATIONS) ? KEYCTL_CAPS0_DIFFIE_HELLMAN : 0) | 3345e0f30cSDavid Howells (IS_ENABLED(CONFIG_ASYMMETRIC_KEY_TYPE) ? KEYCTL_CAPS0_PUBLIC_KEY : 0) | 3445e0f30cSDavid Howells (IS_ENABLED(CONFIG_BIG_KEYS) ? KEYCTL_CAPS0_BIG_KEY : 0) | 3545e0f30cSDavid Howells KEYCTL_CAPS0_INVALIDATE | 3645e0f30cSDavid Howells KEYCTL_CAPS0_RESTRICT_KEYRING | 3745e0f30cSDavid Howells KEYCTL_CAPS0_MOVE 3845e0f30cSDavid Howells ), 393b6e4de0SDavid Howells [1] = (KEYCTL_CAPS1_NS_KEYRING_NAME | 40f7e47677SDavid Howells KEYCTL_CAPS1_NS_KEY_TAG | 41f7e47677SDavid Howells (IS_ENABLED(CONFIG_KEY_NOTIFICATIONS) ? KEYCTL_CAPS1_NOTIFICATIONS : 0) 42f7e47677SDavid Howells ), 4345e0f30cSDavid Howells }; 4445e0f30cSDavid Howells 450cb409d9SDavi Arnaut static int key_get_type_from_user(char *type, 460cb409d9SDavi Arnaut const char __user *_type, 470cb409d9SDavi Arnaut unsigned len) 480cb409d9SDavi Arnaut { 490cb409d9SDavi Arnaut int ret; 500cb409d9SDavi Arnaut 510cb409d9SDavi Arnaut ret = strncpy_from_user(type, _type, len); 520cb409d9SDavi Arnaut if (ret < 0) 534303ef19SDan Carpenter return ret; 540cb409d9SDavi Arnaut if (ret == 0 || ret >= len) 550cb409d9SDavi Arnaut return -EINVAL; 5654e2c2c1SDavid Howells if (type[0] == '.') 5754e2c2c1SDavid Howells return -EPERM; 580cb409d9SDavi Arnaut type[len - 1] = '\0'; 590cb409d9SDavi Arnaut return 0; 600cb409d9SDavi Arnaut } 610cb409d9SDavi Arnaut 621da177e4SLinus Torvalds /* 63973c9f4fSDavid Howells * Extract the description of a new key from userspace and either add it as a 64973c9f4fSDavid Howells * new key to the specified keyring or update a matching key in that keyring. 65973c9f4fSDavid Howells * 66cf7f601cSDavid Howells * If the description is NULL or an empty string, the key type is asked to 67cf7f601cSDavid Howells * generate one from the payload. 68cf7f601cSDavid Howells * 69973c9f4fSDavid Howells * The keyring must be writable so that we can attach the key to it. 70973c9f4fSDavid Howells * 71973c9f4fSDavid Howells * If successful, the new key's serial number is returned, otherwise an error 72973c9f4fSDavid Howells * code is returned. 731da177e4SLinus Torvalds */ 741e7bfb21SHeiko Carstens SYSCALL_DEFINE5(add_key, const char __user *, _type, 751e7bfb21SHeiko Carstens const char __user *, _description, 761e7bfb21SHeiko Carstens const void __user *, _payload, 771e7bfb21SHeiko Carstens size_t, plen, 781e7bfb21SHeiko Carstens key_serial_t, ringid) 791da177e4SLinus Torvalds { 80664cceb0SDavid Howells key_ref_t keyring_ref, key_ref; 811da177e4SLinus Torvalds char type[32], *description; 821da177e4SLinus Torvalds void *payload; 830cb409d9SDavi Arnaut long ret; 841da177e4SLinus Torvalds 851da177e4SLinus Torvalds ret = -EINVAL; 8638bbca6bSDavid Howells if (plen > 1024 * 1024 - 1) 871da177e4SLinus Torvalds goto error; 881da177e4SLinus Torvalds 891da177e4SLinus Torvalds /* draw all the data into kernel space */ 900cb409d9SDavi Arnaut ret = key_get_type_from_user(type, _type, sizeof(type)); 911da177e4SLinus Torvalds if (ret < 0) 921da177e4SLinus Torvalds goto error; 931da177e4SLinus Torvalds 94cf7f601cSDavid Howells description = NULL; 95cf7f601cSDavid Howells if (_description) { 96aa9d4437SDavid Howells description = strndup_user(_description, KEY_MAX_DESC_SIZE); 970cb409d9SDavi Arnaut if (IS_ERR(description)) { 980cb409d9SDavi Arnaut ret = PTR_ERR(description); 993e30148cSDavid Howells goto error; 1000cb409d9SDavi Arnaut } 101cf7f601cSDavid Howells if (!*description) { 102cf7f601cSDavid Howells kfree(description); 103cf7f601cSDavid Howells description = NULL; 104a4e3b8d7SMimi Zohar } else if ((description[0] == '.') && 105a4e3b8d7SMimi Zohar (strncmp(type, "keyring", 7) == 0)) { 106a4e3b8d7SMimi Zohar ret = -EPERM; 107a4e3b8d7SMimi Zohar goto error2; 108cf7f601cSDavid Howells } 109cf7f601cSDavid Howells } 1101da177e4SLinus Torvalds 1111da177e4SLinus Torvalds /* pull the payload in if one was supplied */ 1121da177e4SLinus Torvalds payload = NULL; 1131da177e4SLinus Torvalds 1145649645dSEric Biggers if (plen) { 1151da177e4SLinus Torvalds ret = -ENOMEM; 116752ade68SMichal Hocko payload = kvmalloc(plen, GFP_KERNEL); 1171da177e4SLinus Torvalds if (!payload) 1181da177e4SLinus Torvalds goto error2; 1191da177e4SLinus Torvalds 1201da177e4SLinus Torvalds ret = -EFAULT; 1211da177e4SLinus Torvalds if (copy_from_user(payload, _payload, plen) != 0) 1221da177e4SLinus Torvalds goto error3; 1231da177e4SLinus Torvalds } 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds /* find the target keyring (which must be writable) */ 126f5895943SDavid Howells keyring_ref = lookup_user_key(ringid, KEY_LOOKUP_CREATE, KEY_NEED_WRITE); 127664cceb0SDavid Howells if (IS_ERR(keyring_ref)) { 128664cceb0SDavid Howells ret = PTR_ERR(keyring_ref); 1291da177e4SLinus Torvalds goto error3; 1301da177e4SLinus Torvalds } 1311da177e4SLinus Torvalds 1321da177e4SLinus Torvalds /* create or update the requested key and add it to the target 1331da177e4SLinus Torvalds * keyring */ 134664cceb0SDavid Howells key_ref = key_create_or_update(keyring_ref, type, description, 135028db3e2SLinus Torvalds payload, plen, KEY_PERM_UNDEF, 136028db3e2SLinus Torvalds KEY_ALLOC_IN_QUOTA); 137664cceb0SDavid Howells if (!IS_ERR(key_ref)) { 138664cceb0SDavid Howells ret = key_ref_to_ptr(key_ref)->serial; 139664cceb0SDavid Howells key_ref_put(key_ref); 1401da177e4SLinus Torvalds } 1411da177e4SLinus Torvalds else { 142664cceb0SDavid Howells ret = PTR_ERR(key_ref); 1431da177e4SLinus Torvalds } 1441da177e4SLinus Torvalds 145664cceb0SDavid Howells key_ref_put(keyring_ref); 1461da177e4SLinus Torvalds error3: 147d4eaa283SWaiman Long kvfree_sensitive(payload, plen); 1481da177e4SLinus Torvalds error2: 1491da177e4SLinus Torvalds kfree(description); 1501da177e4SLinus Torvalds error: 1511da177e4SLinus Torvalds return ret; 152a8b17ed0SDavid Howells } 1531da177e4SLinus Torvalds 1541da177e4SLinus Torvalds /* 155973c9f4fSDavid Howells * Search the process keyrings and keyring trees linked from those for a 156973c9f4fSDavid Howells * matching key. Keyrings must have appropriate Search permission to be 157973c9f4fSDavid Howells * searched. 158973c9f4fSDavid Howells * 159973c9f4fSDavid Howells * If a key is found, it will be attached to the destination keyring if there's 160973c9f4fSDavid Howells * one specified and the serial number of the key will be returned. 161973c9f4fSDavid Howells * 162973c9f4fSDavid Howells * If no key is found, /sbin/request-key will be invoked if _callout_info is 163973c9f4fSDavid Howells * non-NULL in an attempt to create a key. The _callout_info string will be 164973c9f4fSDavid Howells * passed to /sbin/request-key to aid with completing the request. If the 165973c9f4fSDavid Howells * _callout_info string is "" then it will be changed to "-". 1661da177e4SLinus Torvalds */ 1671e7bfb21SHeiko Carstens SYSCALL_DEFINE4(request_key, const char __user *, _type, 1681e7bfb21SHeiko Carstens const char __user *, _description, 1691e7bfb21SHeiko Carstens const char __user *, _callout_info, 1701e7bfb21SHeiko Carstens key_serial_t, destringid) 1711da177e4SLinus Torvalds { 1721da177e4SLinus Torvalds struct key_type *ktype; 173664cceb0SDavid Howells struct key *key; 174664cceb0SDavid Howells key_ref_t dest_ref; 1754a38e122SDavid Howells size_t callout_len; 1761da177e4SLinus Torvalds char type[32], *description, *callout_info; 1770cb409d9SDavi Arnaut long ret; 1781da177e4SLinus Torvalds 1791da177e4SLinus Torvalds /* pull the type into kernel space */ 1800cb409d9SDavi Arnaut ret = key_get_type_from_user(type, _type, sizeof(type)); 1811da177e4SLinus Torvalds if (ret < 0) 1821da177e4SLinus Torvalds goto error; 1831260f801SDavid Howells 1841da177e4SLinus Torvalds /* pull the description into kernel space */ 185aa9d4437SDavid Howells description = strndup_user(_description, KEY_MAX_DESC_SIZE); 1860cb409d9SDavi Arnaut if (IS_ERR(description)) { 1870cb409d9SDavi Arnaut ret = PTR_ERR(description); 1881da177e4SLinus Torvalds goto error; 1890cb409d9SDavi Arnaut } 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds /* pull the callout info into kernel space */ 1921da177e4SLinus Torvalds callout_info = NULL; 1934a38e122SDavid Howells callout_len = 0; 1941da177e4SLinus Torvalds if (_callout_info) { 1950cb409d9SDavi Arnaut callout_info = strndup_user(_callout_info, PAGE_SIZE); 1960cb409d9SDavi Arnaut if (IS_ERR(callout_info)) { 1970cb409d9SDavi Arnaut ret = PTR_ERR(callout_info); 1981da177e4SLinus Torvalds goto error2; 1990cb409d9SDavi Arnaut } 2004a38e122SDavid Howells callout_len = strlen(callout_info); 2011da177e4SLinus Torvalds } 2021da177e4SLinus Torvalds 2031da177e4SLinus Torvalds /* get the destination keyring if specified */ 204664cceb0SDavid Howells dest_ref = NULL; 2051da177e4SLinus Torvalds if (destringid) { 2065593122eSDavid Howells dest_ref = lookup_user_key(destringid, KEY_LOOKUP_CREATE, 207f5895943SDavid Howells KEY_NEED_WRITE); 208664cceb0SDavid Howells if (IS_ERR(dest_ref)) { 209664cceb0SDavid Howells ret = PTR_ERR(dest_ref); 2101da177e4SLinus Torvalds goto error3; 2111da177e4SLinus Torvalds } 2121da177e4SLinus Torvalds } 2131da177e4SLinus Torvalds 2141da177e4SLinus Torvalds /* find the key type */ 2151da177e4SLinus Torvalds ktype = key_type_lookup(type); 2161da177e4SLinus Torvalds if (IS_ERR(ktype)) { 2171da177e4SLinus Torvalds ret = PTR_ERR(ktype); 2181da177e4SLinus Torvalds goto error4; 2191da177e4SLinus Torvalds } 2201da177e4SLinus Torvalds 2211da177e4SLinus Torvalds /* do the search */ 222a58946c1SDavid Howells key = request_key_and_link(ktype, description, NULL, callout_info, 223028db3e2SLinus Torvalds callout_len, NULL, key_ref_to_ptr(dest_ref), 2247e047ef5SDavid Howells KEY_ALLOC_IN_QUOTA); 2251da177e4SLinus Torvalds if (IS_ERR(key)) { 2261da177e4SLinus Torvalds ret = PTR_ERR(key); 2271da177e4SLinus Torvalds goto error5; 2281da177e4SLinus Torvalds } 2291da177e4SLinus Torvalds 2304aab1e89SDavid Howells /* wait for the key to finish being constructed */ 2314aab1e89SDavid Howells ret = wait_for_key_construction(key, 1); 2324aab1e89SDavid Howells if (ret < 0) 2334aab1e89SDavid Howells goto error6; 2344aab1e89SDavid Howells 2351da177e4SLinus Torvalds ret = key->serial; 2361da177e4SLinus Torvalds 2374aab1e89SDavid Howells error6: 2381da177e4SLinus Torvalds key_put(key); 2391da177e4SLinus Torvalds error5: 2401da177e4SLinus Torvalds key_type_put(ktype); 2411da177e4SLinus Torvalds error4: 242664cceb0SDavid Howells key_ref_put(dest_ref); 2431da177e4SLinus Torvalds error3: 2441da177e4SLinus Torvalds kfree(callout_info); 2451da177e4SLinus Torvalds error2: 2461da177e4SLinus Torvalds kfree(description); 2471da177e4SLinus Torvalds error: 2481da177e4SLinus Torvalds return ret; 249a8b17ed0SDavid Howells } 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds /* 252973c9f4fSDavid Howells * Get the ID of the specified process keyring. 253973c9f4fSDavid Howells * 254973c9f4fSDavid Howells * The requested keyring must have search permission to be found. 255973c9f4fSDavid Howells * 256973c9f4fSDavid Howells * If successful, the ID of the requested keyring will be returned. 2571da177e4SLinus Torvalds */ 2581da177e4SLinus Torvalds long keyctl_get_keyring_ID(key_serial_t id, int create) 2591da177e4SLinus Torvalds { 260664cceb0SDavid Howells key_ref_t key_ref; 2615593122eSDavid Howells unsigned long lflags; 2621da177e4SLinus Torvalds long ret; 2631da177e4SLinus Torvalds 2645593122eSDavid Howells lflags = create ? KEY_LOOKUP_CREATE : 0; 265f5895943SDavid Howells key_ref = lookup_user_key(id, lflags, KEY_NEED_SEARCH); 266664cceb0SDavid Howells if (IS_ERR(key_ref)) { 267664cceb0SDavid Howells ret = PTR_ERR(key_ref); 2681da177e4SLinus Torvalds goto error; 2691da177e4SLinus Torvalds } 2701da177e4SLinus Torvalds 271664cceb0SDavid Howells ret = key_ref_to_ptr(key_ref)->serial; 272664cceb0SDavid Howells key_ref_put(key_ref); 2731da177e4SLinus Torvalds error: 2741da177e4SLinus Torvalds return ret; 275973c9f4fSDavid Howells } 2761da177e4SLinus Torvalds 2771da177e4SLinus Torvalds /* 278973c9f4fSDavid Howells * Join a (named) session keyring. 279973c9f4fSDavid Howells * 280973c9f4fSDavid Howells * Create and join an anonymous session keyring or join a named session 281973c9f4fSDavid Howells * keyring, creating it if necessary. A named session keyring must have Search 282973c9f4fSDavid Howells * permission for it to be joined. Session keyrings without this permit will 283ee8f844eSDavid Howells * be skipped over. It is not permitted for userspace to create or join 284ee8f844eSDavid Howells * keyrings whose name begin with a dot. 285973c9f4fSDavid Howells * 286973c9f4fSDavid Howells * If successful, the ID of the joined session keyring will be returned. 2871da177e4SLinus Torvalds */ 2881da177e4SLinus Torvalds long keyctl_join_session_keyring(const char __user *_name) 2891da177e4SLinus Torvalds { 2901da177e4SLinus Torvalds char *name; 2910cb409d9SDavi Arnaut long ret; 2921da177e4SLinus Torvalds 2931da177e4SLinus Torvalds /* fetch the name from userspace */ 2941da177e4SLinus Torvalds name = NULL; 2951da177e4SLinus Torvalds if (_name) { 296aa9d4437SDavid Howells name = strndup_user(_name, KEY_MAX_DESC_SIZE); 2970cb409d9SDavi Arnaut if (IS_ERR(name)) { 2980cb409d9SDavi Arnaut ret = PTR_ERR(name); 2991da177e4SLinus Torvalds goto error; 3000cb409d9SDavi Arnaut } 301ee8f844eSDavid Howells 302ee8f844eSDavid Howells ret = -EPERM; 303ee8f844eSDavid Howells if (name[0] == '.') 304ee8f844eSDavid Howells goto error_name; 3051da177e4SLinus Torvalds } 3061da177e4SLinus Torvalds 3071da177e4SLinus Torvalds /* join the session */ 3081da177e4SLinus Torvalds ret = join_session_keyring(name); 309ee8f844eSDavid Howells error_name: 3100d54ee1cSVegard Nossum kfree(name); 3111da177e4SLinus Torvalds error: 3121da177e4SLinus Torvalds return ret; 313a8b17ed0SDavid Howells } 3141da177e4SLinus Torvalds 3151da177e4SLinus Torvalds /* 316973c9f4fSDavid Howells * Update a key's data payload from the given data. 317973c9f4fSDavid Howells * 318973c9f4fSDavid Howells * The key must grant the caller Write permission and the key type must support 319973c9f4fSDavid Howells * updating for this to work. A negative key can be positively instantiated 320973c9f4fSDavid Howells * with this call. 321973c9f4fSDavid Howells * 322973c9f4fSDavid Howells * If successful, 0 will be returned. If the key type does not support 323973c9f4fSDavid Howells * updating, then -EOPNOTSUPP will be returned. 3241da177e4SLinus Torvalds */ 3251da177e4SLinus Torvalds long keyctl_update_key(key_serial_t id, 3261da177e4SLinus Torvalds const void __user *_payload, 3271da177e4SLinus Torvalds size_t plen) 3281da177e4SLinus Torvalds { 329664cceb0SDavid Howells key_ref_t key_ref; 3301da177e4SLinus Torvalds void *payload; 3311da177e4SLinus Torvalds long ret; 3321da177e4SLinus Torvalds 3331da177e4SLinus Torvalds ret = -EINVAL; 3341da177e4SLinus Torvalds if (plen > PAGE_SIZE) 3351da177e4SLinus Torvalds goto error; 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds /* pull the payload in if one was supplied */ 3381da177e4SLinus Torvalds payload = NULL; 3395649645dSEric Biggers if (plen) { 3401da177e4SLinus Torvalds ret = -ENOMEM; 3414f088249SWaiman Long payload = kvmalloc(plen, GFP_KERNEL); 3421da177e4SLinus Torvalds if (!payload) 3431da177e4SLinus Torvalds goto error; 3441da177e4SLinus Torvalds 3451da177e4SLinus Torvalds ret = -EFAULT; 3461da177e4SLinus Torvalds if (copy_from_user(payload, _payload, plen) != 0) 3471da177e4SLinus Torvalds goto error2; 3481da177e4SLinus Torvalds } 3491da177e4SLinus Torvalds 3501da177e4SLinus Torvalds /* find the target key (which must be writable) */ 351f5895943SDavid Howells key_ref = lookup_user_key(id, 0, KEY_NEED_WRITE); 352664cceb0SDavid Howells if (IS_ERR(key_ref)) { 353664cceb0SDavid Howells ret = PTR_ERR(key_ref); 3541da177e4SLinus Torvalds goto error2; 3551da177e4SLinus Torvalds } 3561da177e4SLinus Torvalds 3571da177e4SLinus Torvalds /* update the key */ 358664cceb0SDavid Howells ret = key_update(key_ref, payload, plen); 3591da177e4SLinus Torvalds 360664cceb0SDavid Howells key_ref_put(key_ref); 3611da177e4SLinus Torvalds error2: 362d4eaa283SWaiman Long kvfree_sensitive(payload, plen); 3631da177e4SLinus Torvalds error: 3641da177e4SLinus Torvalds return ret; 365a8b17ed0SDavid Howells } 3661da177e4SLinus Torvalds 3671da177e4SLinus Torvalds /* 368973c9f4fSDavid Howells * Revoke a key. 369973c9f4fSDavid Howells * 370973c9f4fSDavid Howells * The key must be grant the caller Write or Setattr permission for this to 371973c9f4fSDavid Howells * work. The key type should give up its quota claim when revoked. The key 372973c9f4fSDavid Howells * and any links to the key will be automatically garbage collected after a 373973c9f4fSDavid Howells * certain amount of time (/proc/sys/kernel/keys/gc_delay). 374973c9f4fSDavid Howells * 375d3600bcfSMimi Zohar * Keys with KEY_FLAG_KEEP set should not be revoked. 376d3600bcfSMimi Zohar * 377973c9f4fSDavid Howells * If successful, 0 is returned. 3781da177e4SLinus Torvalds */ 3791da177e4SLinus Torvalds long keyctl_revoke_key(key_serial_t id) 3801da177e4SLinus Torvalds { 381664cceb0SDavid Howells key_ref_t key_ref; 382d3600bcfSMimi Zohar struct key *key; 3831da177e4SLinus Torvalds long ret; 3841da177e4SLinus Torvalds 385028db3e2SLinus Torvalds key_ref = lookup_user_key(id, 0, KEY_NEED_WRITE); 386028db3e2SLinus Torvalds if (IS_ERR(key_ref)) { 387028db3e2SLinus Torvalds ret = PTR_ERR(key_ref); 388028db3e2SLinus Torvalds if (ret != -EACCES) 389028db3e2SLinus Torvalds goto error; 390028db3e2SLinus Torvalds key_ref = lookup_user_key(id, 0, KEY_NEED_SETATTR); 3910c2c9a3fSDavid Howells if (IS_ERR(key_ref)) { 3920c2c9a3fSDavid Howells ret = PTR_ERR(key_ref); 3930c2c9a3fSDavid Howells goto error; 3940c2c9a3fSDavid Howells } 395028db3e2SLinus Torvalds } 3961da177e4SLinus Torvalds 397d3600bcfSMimi Zohar key = key_ref_to_ptr(key_ref); 3981da177e4SLinus Torvalds ret = 0; 3991d6d167cSMimi Zohar if (test_bit(KEY_FLAG_KEEP, &key->flags)) 4001d6d167cSMimi Zohar ret = -EPERM; 4011d6d167cSMimi Zohar else 4021d6d167cSMimi Zohar key_revoke(key); 4031da177e4SLinus Torvalds 404664cceb0SDavid Howells key_ref_put(key_ref); 4051da177e4SLinus Torvalds error: 4061260f801SDavid Howells return ret; 407a8b17ed0SDavid Howells } 4081da177e4SLinus Torvalds 4091da177e4SLinus Torvalds /* 410fd75815fSDavid Howells * Invalidate a key. 411fd75815fSDavid Howells * 412fd75815fSDavid Howells * The key must be grant the caller Invalidate permission for this to work. 413fd75815fSDavid Howells * The key and any links to the key will be automatically garbage collected 414fd75815fSDavid Howells * immediately. 415fd75815fSDavid Howells * 416d3600bcfSMimi Zohar * Keys with KEY_FLAG_KEEP set should not be invalidated. 417d3600bcfSMimi Zohar * 418fd75815fSDavid Howells * If successful, 0 is returned. 419fd75815fSDavid Howells */ 420fd75815fSDavid Howells long keyctl_invalidate_key(key_serial_t id) 421fd75815fSDavid Howells { 422fd75815fSDavid Howells key_ref_t key_ref; 423d3600bcfSMimi Zohar struct key *key; 424fd75815fSDavid Howells long ret; 425fd75815fSDavid Howells 426fd75815fSDavid Howells kenter("%d", id); 427fd75815fSDavid Howells 428028db3e2SLinus Torvalds key_ref = lookup_user_key(id, 0, KEY_NEED_SEARCH); 429fd75815fSDavid Howells if (IS_ERR(key_ref)) { 430fd75815fSDavid Howells ret = PTR_ERR(key_ref); 4310c7774abSDavid Howells 4320c7774abSDavid Howells /* Root is permitted to invalidate certain special keys */ 4330c7774abSDavid Howells if (capable(CAP_SYS_ADMIN)) { 4348c0637e9SDavid Howells key_ref = lookup_user_key(id, 0, KEY_SYSADMIN_OVERRIDE); 4350c7774abSDavid Howells if (IS_ERR(key_ref)) 4360c7774abSDavid Howells goto error; 4370c7774abSDavid Howells if (test_bit(KEY_FLAG_ROOT_CAN_INVAL, 4380c7774abSDavid Howells &key_ref_to_ptr(key_ref)->flags)) 4390c7774abSDavid Howells goto invalidate; 4400c7774abSDavid Howells goto error_put; 4410c7774abSDavid Howells } 4420c7774abSDavid Howells 443fd75815fSDavid Howells goto error; 444fd75815fSDavid Howells } 445fd75815fSDavid Howells 4460c7774abSDavid Howells invalidate: 447d3600bcfSMimi Zohar key = key_ref_to_ptr(key_ref); 448fd75815fSDavid Howells ret = 0; 449d3600bcfSMimi Zohar if (test_bit(KEY_FLAG_KEEP, &key->flags)) 450d3600bcfSMimi Zohar ret = -EPERM; 4511d6d167cSMimi Zohar else 452d3600bcfSMimi Zohar key_invalidate(key); 4530c7774abSDavid Howells error_put: 454fd75815fSDavid Howells key_ref_put(key_ref); 455fd75815fSDavid Howells error: 456fd75815fSDavid Howells kleave(" = %ld", ret); 457fd75815fSDavid Howells return ret; 458fd75815fSDavid Howells } 459fd75815fSDavid Howells 460fd75815fSDavid Howells /* 461973c9f4fSDavid Howells * Clear the specified keyring, creating an empty process keyring if one of the 462973c9f4fSDavid Howells * special keyring IDs is used. 463973c9f4fSDavid Howells * 464d3600bcfSMimi Zohar * The keyring must grant the caller Write permission and not have 465d3600bcfSMimi Zohar * KEY_FLAG_KEEP set for this to work. If successful, 0 will be returned. 4661da177e4SLinus Torvalds */ 4671da177e4SLinus Torvalds long keyctl_keyring_clear(key_serial_t ringid) 4681da177e4SLinus Torvalds { 469664cceb0SDavid Howells key_ref_t keyring_ref; 470d3600bcfSMimi Zohar struct key *keyring; 4711da177e4SLinus Torvalds long ret; 4721da177e4SLinus Torvalds 473028db3e2SLinus Torvalds keyring_ref = lookup_user_key(ringid, KEY_LOOKUP_CREATE, KEY_NEED_WRITE); 474664cceb0SDavid Howells if (IS_ERR(keyring_ref)) { 475664cceb0SDavid Howells ret = PTR_ERR(keyring_ref); 476700920ebSDavid Howells 477700920ebSDavid Howells /* Root is permitted to invalidate certain special keyrings */ 478700920ebSDavid Howells if (capable(CAP_SYS_ADMIN)) { 4798c0637e9SDavid Howells keyring_ref = lookup_user_key(ringid, 0, 4808c0637e9SDavid Howells KEY_SYSADMIN_OVERRIDE); 481700920ebSDavid Howells if (IS_ERR(keyring_ref)) 482700920ebSDavid Howells goto error; 483700920ebSDavid Howells if (test_bit(KEY_FLAG_ROOT_CAN_CLEAR, 484700920ebSDavid Howells &key_ref_to_ptr(keyring_ref)->flags)) 485700920ebSDavid Howells goto clear; 486700920ebSDavid Howells goto error_put; 487700920ebSDavid Howells } 488700920ebSDavid Howells 4891da177e4SLinus Torvalds goto error; 4901da177e4SLinus Torvalds } 4911da177e4SLinus Torvalds 492700920ebSDavid Howells clear: 493d3600bcfSMimi Zohar keyring = key_ref_to_ptr(keyring_ref); 494d3600bcfSMimi Zohar if (test_bit(KEY_FLAG_KEEP, &keyring->flags)) 495d3600bcfSMimi Zohar ret = -EPERM; 496d3600bcfSMimi Zohar else 497d3600bcfSMimi Zohar ret = keyring_clear(keyring); 498700920ebSDavid Howells error_put: 499664cceb0SDavid Howells key_ref_put(keyring_ref); 5001da177e4SLinus Torvalds error: 5011da177e4SLinus Torvalds return ret; 502a8b17ed0SDavid Howells } 5031da177e4SLinus Torvalds 5041da177e4SLinus Torvalds /* 505973c9f4fSDavid Howells * Create a link from a keyring to a key if there's no matching key in the 506973c9f4fSDavid Howells * keyring, otherwise replace the link to the matching key with a link to the 507973c9f4fSDavid Howells * new key. 508973c9f4fSDavid Howells * 509328c95dbSRandy Dunlap * The key must grant the caller Link permission and the keyring must grant 510973c9f4fSDavid Howells * the caller Write permission. Furthermore, if an additional link is created, 511973c9f4fSDavid Howells * the keyring's quota will be extended. 512973c9f4fSDavid Howells * 513973c9f4fSDavid Howells * If successful, 0 will be returned. 5141da177e4SLinus Torvalds */ 5151da177e4SLinus Torvalds long keyctl_keyring_link(key_serial_t id, key_serial_t ringid) 5161da177e4SLinus Torvalds { 517664cceb0SDavid Howells key_ref_t keyring_ref, key_ref; 5181da177e4SLinus Torvalds long ret; 5191da177e4SLinus Torvalds 520f5895943SDavid Howells keyring_ref = lookup_user_key(ringid, KEY_LOOKUP_CREATE, KEY_NEED_WRITE); 521664cceb0SDavid Howells if (IS_ERR(keyring_ref)) { 522664cceb0SDavid Howells ret = PTR_ERR(keyring_ref); 5231da177e4SLinus Torvalds goto error; 5241da177e4SLinus Torvalds } 5251da177e4SLinus Torvalds 526f5895943SDavid Howells key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE, KEY_NEED_LINK); 527664cceb0SDavid Howells if (IS_ERR(key_ref)) { 528664cceb0SDavid Howells ret = PTR_ERR(key_ref); 5291da177e4SLinus Torvalds goto error2; 5301da177e4SLinus Torvalds } 5311da177e4SLinus Torvalds 532664cceb0SDavid Howells ret = key_link(key_ref_to_ptr(keyring_ref), key_ref_to_ptr(key_ref)); 5331da177e4SLinus Torvalds 534664cceb0SDavid Howells key_ref_put(key_ref); 5351da177e4SLinus Torvalds error2: 536664cceb0SDavid Howells key_ref_put(keyring_ref); 5371da177e4SLinus Torvalds error: 5381da177e4SLinus Torvalds return ret; 539a8b17ed0SDavid Howells } 5401da177e4SLinus Torvalds 5411da177e4SLinus Torvalds /* 542973c9f4fSDavid Howells * Unlink a key from a keyring. 543973c9f4fSDavid Howells * 544973c9f4fSDavid Howells * The keyring must grant the caller Write permission for this to work; the key 545973c9f4fSDavid Howells * itself need not grant the caller anything. If the last link to a key is 546973c9f4fSDavid Howells * removed then that key will be scheduled for destruction. 547973c9f4fSDavid Howells * 548d3600bcfSMimi Zohar * Keys or keyrings with KEY_FLAG_KEEP set should not be unlinked. 549d3600bcfSMimi Zohar * 550973c9f4fSDavid Howells * If successful, 0 will be returned. 5511da177e4SLinus Torvalds */ 5521da177e4SLinus Torvalds long keyctl_keyring_unlink(key_serial_t id, key_serial_t ringid) 5531da177e4SLinus Torvalds { 554664cceb0SDavid Howells key_ref_t keyring_ref, key_ref; 555d3600bcfSMimi Zohar struct key *keyring, *key; 5561da177e4SLinus Torvalds long ret; 5571da177e4SLinus Torvalds 558f5895943SDavid Howells keyring_ref = lookup_user_key(ringid, 0, KEY_NEED_WRITE); 559664cceb0SDavid Howells if (IS_ERR(keyring_ref)) { 560664cceb0SDavid Howells ret = PTR_ERR(keyring_ref); 5611da177e4SLinus Torvalds goto error; 5621da177e4SLinus Torvalds } 5631da177e4SLinus Torvalds 5648c0637e9SDavid Howells key_ref = lookup_user_key(id, KEY_LOOKUP_PARTIAL, KEY_NEED_UNLINK); 565664cceb0SDavid Howells if (IS_ERR(key_ref)) { 566664cceb0SDavid Howells ret = PTR_ERR(key_ref); 5671da177e4SLinus Torvalds goto error2; 5681da177e4SLinus Torvalds } 5691da177e4SLinus Torvalds 570d3600bcfSMimi Zohar keyring = key_ref_to_ptr(keyring_ref); 571d3600bcfSMimi Zohar key = key_ref_to_ptr(key_ref); 572d3600bcfSMimi Zohar if (test_bit(KEY_FLAG_KEEP, &keyring->flags) && 573d3600bcfSMimi Zohar test_bit(KEY_FLAG_KEEP, &key->flags)) 574d3600bcfSMimi Zohar ret = -EPERM; 575d3600bcfSMimi Zohar else 576d3600bcfSMimi Zohar ret = key_unlink(keyring, key); 5771da177e4SLinus Torvalds 578664cceb0SDavid Howells key_ref_put(key_ref); 5791da177e4SLinus Torvalds error2: 580664cceb0SDavid Howells key_ref_put(keyring_ref); 5811da177e4SLinus Torvalds error: 5821da177e4SLinus Torvalds return ret; 583a8b17ed0SDavid Howells } 5841da177e4SLinus Torvalds 5851da177e4SLinus Torvalds /* 586ed0ac5c7SDavid Howells * Move a link to a key from one keyring to another, displacing any matching 587ed0ac5c7SDavid Howells * key from the destination keyring. 588ed0ac5c7SDavid Howells * 589ed0ac5c7SDavid Howells * The key must grant the caller Link permission and both keyrings must grant 590ed0ac5c7SDavid Howells * the caller Write permission. There must also be a link in the from keyring 591ed0ac5c7SDavid Howells * to the key. If both keyrings are the same, nothing is done. 592ed0ac5c7SDavid Howells * 593ed0ac5c7SDavid Howells * If successful, 0 will be returned. 594ed0ac5c7SDavid Howells */ 595ed0ac5c7SDavid Howells long keyctl_keyring_move(key_serial_t id, key_serial_t from_ringid, 596ed0ac5c7SDavid Howells key_serial_t to_ringid, unsigned int flags) 597ed0ac5c7SDavid Howells { 598ed0ac5c7SDavid Howells key_ref_t key_ref, from_ref, to_ref; 599ed0ac5c7SDavid Howells long ret; 600ed0ac5c7SDavid Howells 601ed0ac5c7SDavid Howells if (flags & ~KEYCTL_MOVE_EXCL) 602ed0ac5c7SDavid Howells return -EINVAL; 603ed0ac5c7SDavid Howells 604ed0ac5c7SDavid Howells key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE, KEY_NEED_LINK); 605ed0ac5c7SDavid Howells if (IS_ERR(key_ref)) 606ed0ac5c7SDavid Howells return PTR_ERR(key_ref); 607ed0ac5c7SDavid Howells 608ed0ac5c7SDavid Howells from_ref = lookup_user_key(from_ringid, 0, KEY_NEED_WRITE); 609ed0ac5c7SDavid Howells if (IS_ERR(from_ref)) { 610ed0ac5c7SDavid Howells ret = PTR_ERR(from_ref); 611ed0ac5c7SDavid Howells goto error2; 612ed0ac5c7SDavid Howells } 613ed0ac5c7SDavid Howells 614ed0ac5c7SDavid Howells to_ref = lookup_user_key(to_ringid, KEY_LOOKUP_CREATE, KEY_NEED_WRITE); 615ed0ac5c7SDavid Howells if (IS_ERR(to_ref)) { 616ed0ac5c7SDavid Howells ret = PTR_ERR(to_ref); 617ed0ac5c7SDavid Howells goto error3; 618ed0ac5c7SDavid Howells } 619ed0ac5c7SDavid Howells 620ed0ac5c7SDavid Howells ret = key_move(key_ref_to_ptr(key_ref), key_ref_to_ptr(from_ref), 621ed0ac5c7SDavid Howells key_ref_to_ptr(to_ref), flags); 622ed0ac5c7SDavid Howells 623ed0ac5c7SDavid Howells key_ref_put(to_ref); 624ed0ac5c7SDavid Howells error3: 625ed0ac5c7SDavid Howells key_ref_put(from_ref); 626ed0ac5c7SDavid Howells error2: 627ed0ac5c7SDavid Howells key_ref_put(key_ref); 628ed0ac5c7SDavid Howells return ret; 629ed0ac5c7SDavid Howells } 630ed0ac5c7SDavid Howells 631ed0ac5c7SDavid Howells /* 632973c9f4fSDavid Howells * Return a description of a key to userspace. 633973c9f4fSDavid Howells * 634973c9f4fSDavid Howells * The key must grant the caller View permission for this to work. 635973c9f4fSDavid Howells * 636973c9f4fSDavid Howells * If there's a buffer, we place up to buflen bytes of data into it formatted 637973c9f4fSDavid Howells * in the following way: 638973c9f4fSDavid Howells * 6391da177e4SLinus Torvalds * type;uid;gid;perm;description<NUL> 640973c9f4fSDavid Howells * 641973c9f4fSDavid Howells * If successful, we return the amount of description available, irrespective 642973c9f4fSDavid Howells * of how much we may have copied into the buffer. 6431da177e4SLinus Torvalds */ 6441da177e4SLinus Torvalds long keyctl_describe_key(key_serial_t keyid, 6451da177e4SLinus Torvalds char __user *buffer, 6461da177e4SLinus Torvalds size_t buflen) 6471da177e4SLinus Torvalds { 6483e30148cSDavid Howells struct key *key, *instkey; 649664cceb0SDavid Howells key_ref_t key_ref; 650aa9d4437SDavid Howells char *infobuf; 6511da177e4SLinus Torvalds long ret; 652aa9d4437SDavid Howells int desclen, infolen; 6531da177e4SLinus Torvalds 654f5895943SDavid Howells key_ref = lookup_user_key(keyid, KEY_LOOKUP_PARTIAL, KEY_NEED_VIEW); 655664cceb0SDavid Howells if (IS_ERR(key_ref)) { 6563e30148cSDavid Howells /* viewing a key under construction is permitted if we have the 6573e30148cSDavid Howells * authorisation token handy */ 658664cceb0SDavid Howells if (PTR_ERR(key_ref) == -EACCES) { 6593e30148cSDavid Howells instkey = key_get_instantiation_authkey(keyid); 6603e30148cSDavid Howells if (!IS_ERR(instkey)) { 6613e30148cSDavid Howells key_put(instkey); 6628bbf4976SDavid Howells key_ref = lookup_user_key(keyid, 6635593122eSDavid Howells KEY_LOOKUP_PARTIAL, 6648c0637e9SDavid Howells KEY_AUTHTOKEN_OVERRIDE); 665664cceb0SDavid Howells if (!IS_ERR(key_ref)) 6663e30148cSDavid Howells goto okay; 6673e30148cSDavid Howells } 6683e30148cSDavid Howells } 6693e30148cSDavid Howells 670664cceb0SDavid Howells ret = PTR_ERR(key_ref); 6711da177e4SLinus Torvalds goto error; 6721da177e4SLinus Torvalds } 6731da177e4SLinus Torvalds 6743e30148cSDavid Howells okay: 675664cceb0SDavid Howells key = key_ref_to_ptr(key_ref); 676aa9d4437SDavid Howells desclen = strlen(key->description); 677664cceb0SDavid Howells 678aa9d4437SDavid Howells /* calculate how much information we're going to return */ 679aa9d4437SDavid Howells ret = -ENOMEM; 680aa9d4437SDavid Howells infobuf = kasprintf(GFP_KERNEL, 681aa9d4437SDavid Howells "%s;%d;%d;%08x;", 68294fd8405SDavid Howells key->type->name, 6839a56c2dbSEric W. Biederman from_kuid_munged(current_user_ns(), key->uid), 6849a56c2dbSEric W. Biederman from_kgid_munged(current_user_ns(), key->gid), 685028db3e2SLinus Torvalds key->perm); 686aa9d4437SDavid Howells if (!infobuf) 687aa9d4437SDavid Howells goto error2; 688aa9d4437SDavid Howells infolen = strlen(infobuf); 689aa9d4437SDavid Howells ret = infolen + desclen + 1; 6901da177e4SLinus Torvalds 6911da177e4SLinus Torvalds /* consider returning the data */ 692aa9d4437SDavid Howells if (buffer && buflen >= ret) { 693aa9d4437SDavid Howells if (copy_to_user(buffer, infobuf, infolen) != 0 || 694aa9d4437SDavid Howells copy_to_user(buffer + infolen, key->description, 695aa9d4437SDavid Howells desclen + 1) != 0) 6961da177e4SLinus Torvalds ret = -EFAULT; 6971da177e4SLinus Torvalds } 6981da177e4SLinus Torvalds 699aa9d4437SDavid Howells kfree(infobuf); 7001da177e4SLinus Torvalds error2: 701664cceb0SDavid Howells key_ref_put(key_ref); 7021da177e4SLinus Torvalds error: 7031da177e4SLinus Torvalds return ret; 704a8b17ed0SDavid Howells } 7051da177e4SLinus Torvalds 7061da177e4SLinus Torvalds /* 707973c9f4fSDavid Howells * Search the specified keyring and any keyrings it links to for a matching 708973c9f4fSDavid Howells * key. Only keyrings that grant the caller Search permission will be searched 709973c9f4fSDavid Howells * (this includes the starting keyring). Only keys with Search permission can 710973c9f4fSDavid Howells * be found. 711973c9f4fSDavid Howells * 712973c9f4fSDavid Howells * If successful, the found key will be linked to the destination keyring if 713973c9f4fSDavid Howells * supplied and the key has Link permission, and the found key ID will be 714973c9f4fSDavid Howells * returned. 7151da177e4SLinus Torvalds */ 7161da177e4SLinus Torvalds long keyctl_keyring_search(key_serial_t ringid, 7171da177e4SLinus Torvalds const char __user *_type, 7181da177e4SLinus Torvalds const char __user *_description, 7191da177e4SLinus Torvalds key_serial_t destringid) 7201da177e4SLinus Torvalds { 7211da177e4SLinus Torvalds struct key_type *ktype; 722664cceb0SDavid Howells key_ref_t keyring_ref, key_ref, dest_ref; 7231da177e4SLinus Torvalds char type[32], *description; 7240cb409d9SDavi Arnaut long ret; 7251da177e4SLinus Torvalds 7261da177e4SLinus Torvalds /* pull the type and description into kernel space */ 7270cb409d9SDavi Arnaut ret = key_get_type_from_user(type, _type, sizeof(type)); 7281da177e4SLinus Torvalds if (ret < 0) 7291da177e4SLinus Torvalds goto error; 7301da177e4SLinus Torvalds 731aa9d4437SDavid Howells description = strndup_user(_description, KEY_MAX_DESC_SIZE); 7320cb409d9SDavi Arnaut if (IS_ERR(description)) { 7330cb409d9SDavi Arnaut ret = PTR_ERR(description); 7341da177e4SLinus Torvalds goto error; 7350cb409d9SDavi Arnaut } 7361da177e4SLinus Torvalds 7371da177e4SLinus Torvalds /* get the keyring at which to begin the search */ 738f5895943SDavid Howells keyring_ref = lookup_user_key(ringid, 0, KEY_NEED_SEARCH); 739664cceb0SDavid Howells if (IS_ERR(keyring_ref)) { 740664cceb0SDavid Howells ret = PTR_ERR(keyring_ref); 7411da177e4SLinus Torvalds goto error2; 7421da177e4SLinus Torvalds } 7431da177e4SLinus Torvalds 7441da177e4SLinus Torvalds /* get the destination keyring if specified */ 745664cceb0SDavid Howells dest_ref = NULL; 7461da177e4SLinus Torvalds if (destringid) { 7475593122eSDavid Howells dest_ref = lookup_user_key(destringid, KEY_LOOKUP_CREATE, 748f5895943SDavid Howells KEY_NEED_WRITE); 749664cceb0SDavid Howells if (IS_ERR(dest_ref)) { 750664cceb0SDavid Howells ret = PTR_ERR(dest_ref); 7511da177e4SLinus Torvalds goto error3; 7521da177e4SLinus Torvalds } 7531da177e4SLinus Torvalds } 7541da177e4SLinus Torvalds 7551da177e4SLinus Torvalds /* find the key type */ 7561da177e4SLinus Torvalds ktype = key_type_lookup(type); 7571da177e4SLinus Torvalds if (IS_ERR(ktype)) { 7581da177e4SLinus Torvalds ret = PTR_ERR(ktype); 7591da177e4SLinus Torvalds goto error4; 7601da177e4SLinus Torvalds } 7611da177e4SLinus Torvalds 7621da177e4SLinus Torvalds /* do the search */ 763dcf49dbcSDavid Howells key_ref = keyring_search(keyring_ref, ktype, description, true); 764664cceb0SDavid Howells if (IS_ERR(key_ref)) { 765664cceb0SDavid Howells ret = PTR_ERR(key_ref); 7661da177e4SLinus Torvalds 7671da177e4SLinus Torvalds /* treat lack or presence of a negative key the same */ 7681da177e4SLinus Torvalds if (ret == -EAGAIN) 7691da177e4SLinus Torvalds ret = -ENOKEY; 7701da177e4SLinus Torvalds goto error5; 7711da177e4SLinus Torvalds } 7721da177e4SLinus Torvalds 7731da177e4SLinus Torvalds /* link the resulting key to the destination keyring if we can */ 774664cceb0SDavid Howells if (dest_ref) { 775f5895943SDavid Howells ret = key_permission(key_ref, KEY_NEED_LINK); 77629db9190SDavid Howells if (ret < 0) 7771da177e4SLinus Torvalds goto error6; 7781da177e4SLinus Torvalds 779664cceb0SDavid Howells ret = key_link(key_ref_to_ptr(dest_ref), key_ref_to_ptr(key_ref)); 7801da177e4SLinus Torvalds if (ret < 0) 7811da177e4SLinus Torvalds goto error6; 7821da177e4SLinus Torvalds } 7831da177e4SLinus Torvalds 784664cceb0SDavid Howells ret = key_ref_to_ptr(key_ref)->serial; 7851da177e4SLinus Torvalds 7861da177e4SLinus Torvalds error6: 787664cceb0SDavid Howells key_ref_put(key_ref); 7881da177e4SLinus Torvalds error5: 7891da177e4SLinus Torvalds key_type_put(ktype); 7901da177e4SLinus Torvalds error4: 791664cceb0SDavid Howells key_ref_put(dest_ref); 7921da177e4SLinus Torvalds error3: 793664cceb0SDavid Howells key_ref_put(keyring_ref); 7941da177e4SLinus Torvalds error2: 7951da177e4SLinus Torvalds kfree(description); 7961da177e4SLinus Torvalds error: 7971da177e4SLinus Torvalds return ret; 798a8b17ed0SDavid Howells } 7991da177e4SLinus Torvalds 8001da177e4SLinus Torvalds /* 801d3ec10aaSWaiman Long * Call the read method 802d3ec10aaSWaiman Long */ 803d3ec10aaSWaiman Long static long __keyctl_read_key(struct key *key, char *buffer, size_t buflen) 804d3ec10aaSWaiman Long { 805d3ec10aaSWaiman Long long ret; 806d3ec10aaSWaiman Long 807d3ec10aaSWaiman Long down_read(&key->sem); 808d3ec10aaSWaiman Long ret = key_validate(key); 809d3ec10aaSWaiman Long if (ret == 0) 810d3ec10aaSWaiman Long ret = key->type->read(key, buffer, buflen); 811d3ec10aaSWaiman Long up_read(&key->sem); 812d3ec10aaSWaiman Long return ret; 813d3ec10aaSWaiman Long } 814d3ec10aaSWaiman Long 815d3ec10aaSWaiman Long /* 816973c9f4fSDavid Howells * Read a key's payload. 817973c9f4fSDavid Howells * 818973c9f4fSDavid Howells * The key must either grant the caller Read permission, or it must grant the 819973c9f4fSDavid Howells * caller Search permission when searched for from the process keyrings. 820973c9f4fSDavid Howells * 821973c9f4fSDavid Howells * If successful, we place up to buflen bytes of data into the buffer, if one 822973c9f4fSDavid Howells * is provided, and return the amount of data that is available in the key, 823973c9f4fSDavid Howells * irrespective of how much we copied into the buffer. 8241da177e4SLinus Torvalds */ 8251da177e4SLinus Torvalds long keyctl_read_key(key_serial_t keyid, char __user *buffer, size_t buflen) 8261da177e4SLinus Torvalds { 827664cceb0SDavid Howells struct key *key; 828664cceb0SDavid Howells key_ref_t key_ref; 8291da177e4SLinus Torvalds long ret; 8304f088249SWaiman Long char *key_data = NULL; 8314f088249SWaiman Long size_t key_data_len; 8321da177e4SLinus Torvalds 8331da177e4SLinus Torvalds /* find the key first */ 8348c0637e9SDavid Howells key_ref = lookup_user_key(keyid, 0, KEY_DEFER_PERM_CHECK); 835664cceb0SDavid Howells if (IS_ERR(key_ref)) { 836664cceb0SDavid Howells ret = -ENOKEY; 837d3ec10aaSWaiman Long goto out; 838664cceb0SDavid Howells } 839664cceb0SDavid Howells 840664cceb0SDavid Howells key = key_ref_to_ptr(key_ref); 841664cceb0SDavid Howells 842363b02daSDavid Howells ret = key_read_state(key); 843363b02daSDavid Howells if (ret < 0) 844d3ec10aaSWaiman Long goto key_put_out; /* Negatively instantiated */ 84537863c43SEric Biggers 8461da177e4SLinus Torvalds /* see if we can read it directly */ 847f5895943SDavid Howells ret = key_permission(key_ref, KEY_NEED_READ); 84829db9190SDavid Howells if (ret == 0) 8491da177e4SLinus Torvalds goto can_read_key; 85029db9190SDavid Howells if (ret != -EACCES) 851d3ec10aaSWaiman Long goto key_put_out; 8521da177e4SLinus Torvalds 853664cceb0SDavid Howells /* we can't; see if it's searchable from this process's keyrings 8543e30148cSDavid Howells * - we automatically take account of the fact that it may be 8553e30148cSDavid Howells * dangling off an instantiation key 8563e30148cSDavid Howells */ 857664cceb0SDavid Howells if (!is_key_possessed(key_ref)) { 8581260f801SDavid Howells ret = -EACCES; 859d3ec10aaSWaiman Long goto key_put_out; 8601da177e4SLinus Torvalds } 8611da177e4SLinus Torvalds 8621da177e4SLinus Torvalds /* the key is probably readable - now try to read it */ 8631da177e4SLinus Torvalds can_read_key: 864d3ec10aaSWaiman Long if (!key->type->read) { 8651da177e4SLinus Torvalds ret = -EOPNOTSUPP; 866d3ec10aaSWaiman Long goto key_put_out; 8671da177e4SLinus Torvalds } 8681da177e4SLinus Torvalds 869d3ec10aaSWaiman Long if (!buffer || !buflen) { 870d3ec10aaSWaiman Long /* Get the key length from the read method */ 871d3ec10aaSWaiman Long ret = __keyctl_read_key(key, NULL, 0); 872d3ec10aaSWaiman Long goto key_put_out; 873d3ec10aaSWaiman Long } 874d3ec10aaSWaiman Long 875d3ec10aaSWaiman Long /* 876d3ec10aaSWaiman Long * Read the data with the semaphore held (since we might sleep) 877d3ec10aaSWaiman Long * to protect against the key being updated or revoked. 878d3ec10aaSWaiman Long * 879d3ec10aaSWaiman Long * Allocating a temporary buffer to hold the keys before 880d3ec10aaSWaiman Long * transferring them to user buffer to avoid potential 881c1e8d7c6SMichel Lespinasse * deadlock involving page fault and mmap_lock. 8824f088249SWaiman Long * 8834f088249SWaiman Long * key_data_len = (buflen <= PAGE_SIZE) 8844f088249SWaiman Long * ? buflen : actual length of key data 8854f088249SWaiman Long * 8864f088249SWaiman Long * This prevents allocating arbitrary large buffer which can 8874f088249SWaiman Long * be much larger than the actual key length. In the latter case, 8884f088249SWaiman Long * at least 2 passes of this loop is required. 889d3ec10aaSWaiman Long */ 8904f088249SWaiman Long key_data_len = (buflen <= PAGE_SIZE) ? buflen : 0; 8914f088249SWaiman Long for (;;) { 8924f088249SWaiman Long if (key_data_len) { 8934f088249SWaiman Long key_data = kvmalloc(key_data_len, GFP_KERNEL); 894d3ec10aaSWaiman Long if (!key_data) { 895d3ec10aaSWaiman Long ret = -ENOMEM; 896d3ec10aaSWaiman Long goto key_put_out; 897d3ec10aaSWaiman Long } 8984f088249SWaiman Long } 8994f088249SWaiman Long 9004f088249SWaiman Long ret = __keyctl_read_key(key, key_data, key_data_len); 901d3ec10aaSWaiman Long 902d3ec10aaSWaiman Long /* 903d3ec10aaSWaiman Long * Read methods will just return the required length without 904d3ec10aaSWaiman Long * any copying if the provided length isn't large enough. 905d3ec10aaSWaiman Long */ 9064f088249SWaiman Long if (ret <= 0 || ret > buflen) 9074f088249SWaiman Long break; 9084f088249SWaiman Long 9094f088249SWaiman Long /* 9104f088249SWaiman Long * The key may change (unlikely) in between 2 consecutive 9114f088249SWaiman Long * __keyctl_read_key() calls. In this case, we reallocate 9124f088249SWaiman Long * a larger buffer and redo the key read when 9134f088249SWaiman Long * key_data_len < ret <= buflen. 9144f088249SWaiman Long */ 9154f088249SWaiman Long if (ret > key_data_len) { 9164f088249SWaiman Long if (unlikely(key_data)) 917d4eaa283SWaiman Long kvfree_sensitive(key_data, key_data_len); 9184f088249SWaiman Long key_data_len = ret; 9194f088249SWaiman Long continue; /* Allocate buffer */ 9204f088249SWaiman Long } 9214f088249SWaiman Long 922d3ec10aaSWaiman Long if (copy_to_user(buffer, key_data, ret)) 923d3ec10aaSWaiman Long ret = -EFAULT; 9244f088249SWaiman Long break; 925d3ec10aaSWaiman Long } 926d4eaa283SWaiman Long kvfree_sensitive(key_data, key_data_len); 927d3ec10aaSWaiman Long 928d3ec10aaSWaiman Long key_put_out: 9291da177e4SLinus Torvalds key_put(key); 930d3ec10aaSWaiman Long out: 9311da177e4SLinus Torvalds return ret; 932a8b17ed0SDavid Howells } 9331da177e4SLinus Torvalds 9341da177e4SLinus Torvalds /* 935973c9f4fSDavid Howells * Change the ownership of a key 936973c9f4fSDavid Howells * 937973c9f4fSDavid Howells * The key must grant the caller Setattr permission for this to work, though 938973c9f4fSDavid Howells * the key need not be fully instantiated yet. For the UID to be changed, or 939973c9f4fSDavid Howells * for the GID to be changed to a group the caller is not a member of, the 940973c9f4fSDavid Howells * caller must have sysadmin capability. If either uid or gid is -1 then that 941973c9f4fSDavid Howells * attribute is not changed. 942973c9f4fSDavid Howells * 943973c9f4fSDavid Howells * If the UID is to be changed, the new user must have sufficient quota to 944973c9f4fSDavid Howells * accept the key. The quota deduction will be removed from the old user to 945973c9f4fSDavid Howells * the new user should the attribute be changed. 946973c9f4fSDavid Howells * 947973c9f4fSDavid Howells * If successful, 0 will be returned. 9481da177e4SLinus Torvalds */ 9499a56c2dbSEric W. Biederman long keyctl_chown_key(key_serial_t id, uid_t user, gid_t group) 9501da177e4SLinus Torvalds { 9515801649dSFredrik Tolf struct key_user *newowner, *zapowner = NULL; 9521da177e4SLinus Torvalds struct key *key; 953664cceb0SDavid Howells key_ref_t key_ref; 9541da177e4SLinus Torvalds long ret; 9559a56c2dbSEric W. Biederman kuid_t uid; 9569a56c2dbSEric W. Biederman kgid_t gid; 9579a56c2dbSEric W. Biederman 9589a56c2dbSEric W. Biederman uid = make_kuid(current_user_ns(), user); 9599a56c2dbSEric W. Biederman gid = make_kgid(current_user_ns(), group); 9609a56c2dbSEric W. Biederman ret = -EINVAL; 9619a56c2dbSEric W. Biederman if ((user != (uid_t) -1) && !uid_valid(uid)) 9629a56c2dbSEric W. Biederman goto error; 9639a56c2dbSEric W. Biederman if ((group != (gid_t) -1) && !gid_valid(gid)) 9649a56c2dbSEric W. Biederman goto error; 9651da177e4SLinus Torvalds 9661da177e4SLinus Torvalds ret = 0; 9679a56c2dbSEric W. Biederman if (user == (uid_t) -1 && group == (gid_t) -1) 9681da177e4SLinus Torvalds goto error; 9691da177e4SLinus Torvalds 9705593122eSDavid Howells key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE | KEY_LOOKUP_PARTIAL, 971028db3e2SLinus Torvalds KEY_NEED_SETATTR); 972664cceb0SDavid Howells if (IS_ERR(key_ref)) { 973664cceb0SDavid Howells ret = PTR_ERR(key_ref); 9741da177e4SLinus Torvalds goto error; 9751da177e4SLinus Torvalds } 9761da177e4SLinus Torvalds 977664cceb0SDavid Howells key = key_ref_to_ptr(key_ref); 978664cceb0SDavid Howells 9791da177e4SLinus Torvalds /* make the changes with the locks held to prevent chown/chown races */ 9801da177e4SLinus Torvalds ret = -EACCES; 9811da177e4SLinus Torvalds down_write(&key->sem); 9821da177e4SLinus Torvalds 983*2d7f105eSChristian Göttsche { 984*2d7f105eSChristian Göttsche bool is_privileged_op = false; 985*2d7f105eSChristian Göttsche 9861da177e4SLinus Torvalds /* only the sysadmin can chown a key to some other UID */ 9879a56c2dbSEric W. Biederman if (user != (uid_t) -1 && !uid_eq(key->uid, uid)) 988*2d7f105eSChristian Göttsche is_privileged_op = true; 9891da177e4SLinus Torvalds 9901da177e4SLinus Torvalds /* only the sysadmin can set the key's GID to a group other 9911da177e4SLinus Torvalds * than one of those that the current process subscribes to */ 9929a56c2dbSEric W. Biederman if (group != (gid_t) -1 && !gid_eq(gid, key->gid) && !in_group_p(gid)) 993*2d7f105eSChristian Göttsche is_privileged_op = true; 994*2d7f105eSChristian Göttsche 995*2d7f105eSChristian Göttsche if (is_privileged_op && !capable(CAP_SYS_ADMIN)) 9965801649dSFredrik Tolf goto error_put; 9971da177e4SLinus Torvalds } 9981da177e4SLinus Torvalds 9995801649dSFredrik Tolf /* change the UID */ 10009a56c2dbSEric W. Biederman if (user != (uid_t) -1 && !uid_eq(uid, key->uid)) { 10015801649dSFredrik Tolf ret = -ENOMEM; 10029a56c2dbSEric W. Biederman newowner = key_user_lookup(uid); 10035801649dSFredrik Tolf if (!newowner) 10045801649dSFredrik Tolf goto error_put; 10055801649dSFredrik Tolf 10065801649dSFredrik Tolf /* transfer the quota burden to the new user */ 10075801649dSFredrik Tolf if (test_bit(KEY_FLAG_IN_QUOTA, &key->flags)) { 10089a56c2dbSEric W. Biederman unsigned maxkeys = uid_eq(uid, GLOBAL_ROOT_UID) ? 10090b77f5bfSDavid Howells key_quota_root_maxkeys : key_quota_maxkeys; 10109a56c2dbSEric W. Biederman unsigned maxbytes = uid_eq(uid, GLOBAL_ROOT_UID) ? 10110b77f5bfSDavid Howells key_quota_root_maxbytes : key_quota_maxbytes; 10120b77f5bfSDavid Howells 10135801649dSFredrik Tolf spin_lock(&newowner->lock); 10142e356101SYang Xu if (newowner->qnkeys + 1 > maxkeys || 10152e356101SYang Xu newowner->qnbytes + key->quotalen > maxbytes || 10160b77f5bfSDavid Howells newowner->qnbytes + key->quotalen < 10170b77f5bfSDavid Howells newowner->qnbytes) 10185801649dSFredrik Tolf goto quota_overrun; 10195801649dSFredrik Tolf 10205801649dSFredrik Tolf newowner->qnkeys++; 10215801649dSFredrik Tolf newowner->qnbytes += key->quotalen; 10225801649dSFredrik Tolf spin_unlock(&newowner->lock); 10235801649dSFredrik Tolf 10245801649dSFredrik Tolf spin_lock(&key->user->lock); 10255801649dSFredrik Tolf key->user->qnkeys--; 10265801649dSFredrik Tolf key->user->qnbytes -= key->quotalen; 10275801649dSFredrik Tolf spin_unlock(&key->user->lock); 10285801649dSFredrik Tolf } 10295801649dSFredrik Tolf 10305801649dSFredrik Tolf atomic_dec(&key->user->nkeys); 10315801649dSFredrik Tolf atomic_inc(&newowner->nkeys); 10325801649dSFredrik Tolf 1033363b02daSDavid Howells if (key->state != KEY_IS_UNINSTANTIATED) { 10345801649dSFredrik Tolf atomic_dec(&key->user->nikeys); 10355801649dSFredrik Tolf atomic_inc(&newowner->nikeys); 10365801649dSFredrik Tolf } 10375801649dSFredrik Tolf 10385801649dSFredrik Tolf zapowner = key->user; 10395801649dSFredrik Tolf key->user = newowner; 10405801649dSFredrik Tolf key->uid = uid; 10411da177e4SLinus Torvalds } 10421da177e4SLinus Torvalds 10431da177e4SLinus Torvalds /* change the GID */ 10449a56c2dbSEric W. Biederman if (group != (gid_t) -1) 10451da177e4SLinus Torvalds key->gid = gid; 10461da177e4SLinus Torvalds 1047f7e47677SDavid Howells notify_key(key, NOTIFY_KEY_SETATTR, 0); 10481da177e4SLinus Torvalds ret = 0; 10491da177e4SLinus Torvalds 10505801649dSFredrik Tolf error_put: 10511da177e4SLinus Torvalds up_write(&key->sem); 10521da177e4SLinus Torvalds key_put(key); 10535801649dSFredrik Tolf if (zapowner) 10545801649dSFredrik Tolf key_user_put(zapowner); 10551da177e4SLinus Torvalds error: 10561da177e4SLinus Torvalds return ret; 10571da177e4SLinus Torvalds 10585801649dSFredrik Tolf quota_overrun: 10595801649dSFredrik Tolf spin_unlock(&newowner->lock); 10605801649dSFredrik Tolf zapowner = newowner; 10615801649dSFredrik Tolf ret = -EDQUOT; 10625801649dSFredrik Tolf goto error_put; 1063a8b17ed0SDavid Howells } 10645801649dSFredrik Tolf 10651da177e4SLinus Torvalds /* 1066973c9f4fSDavid Howells * Change the permission mask on a key. 1067973c9f4fSDavid Howells * 1068973c9f4fSDavid Howells * The key must grant the caller Setattr permission for this to work, though 1069973c9f4fSDavid Howells * the key need not be fully instantiated yet. If the caller does not have 1070973c9f4fSDavid Howells * sysadmin capability, it may only change the permission on keys that it owns. 10711da177e4SLinus Torvalds */ 1072028db3e2SLinus Torvalds long keyctl_setperm_key(key_serial_t id, key_perm_t perm) 10731da177e4SLinus Torvalds { 10741da177e4SLinus Torvalds struct key *key; 1075664cceb0SDavid Howells key_ref_t key_ref; 10761da177e4SLinus Torvalds long ret; 10771da177e4SLinus Torvalds 1078028db3e2SLinus Torvalds ret = -EINVAL; 1079664cceb0SDavid Howells if (perm & ~(KEY_POS_ALL | KEY_USR_ALL | KEY_GRP_ALL | KEY_OTH_ALL)) 1080028db3e2SLinus Torvalds goto error; 10811da177e4SLinus Torvalds 10825593122eSDavid Howells key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE | KEY_LOOKUP_PARTIAL, 1083028db3e2SLinus Torvalds KEY_NEED_SETATTR); 1084664cceb0SDavid Howells if (IS_ERR(key_ref)) { 1085664cceb0SDavid Howells ret = PTR_ERR(key_ref); 10861da177e4SLinus Torvalds goto error; 10871da177e4SLinus Torvalds } 10881da177e4SLinus Torvalds 1089664cceb0SDavid Howells key = key_ref_to_ptr(key_ref); 1090664cceb0SDavid Howells 10912e12256bSDavid Howells /* make the changes with the locks held to prevent chown/chmod races */ 1092028db3e2SLinus Torvalds ret = -EACCES; 10932e12256bSDavid Howells down_write(&key->sem); 1094028db3e2SLinus Torvalds 1095028db3e2SLinus Torvalds /* if we're not the sysadmin, we can only change a key that we own */ 1096*2d7f105eSChristian Göttsche if (uid_eq(key->uid, current_fsuid()) || capable(CAP_SYS_ADMIN)) { 1097028db3e2SLinus Torvalds key->perm = perm; 1098f7e47677SDavid Howells notify_key(key, NOTIFY_KEY_SETATTR, 0); 1099028db3e2SLinus Torvalds ret = 0; 1100028db3e2SLinus Torvalds } 1101028db3e2SLinus Torvalds 11021da177e4SLinus Torvalds up_write(&key->sem); 11031da177e4SLinus Torvalds key_put(key); 11041da177e4SLinus Torvalds error: 11051da177e4SLinus Torvalds return ret; 1106a8b17ed0SDavid Howells } 11071da177e4SLinus Torvalds 11088bbf4976SDavid Howells /* 1109973c9f4fSDavid Howells * Get the destination keyring for instantiation and check that the caller has 1110973c9f4fSDavid Howells * Write permission on it. 11118bbf4976SDavid Howells */ 11128bbf4976SDavid Howells static long get_instantiation_keyring(key_serial_t ringid, 11138bbf4976SDavid Howells struct request_key_auth *rka, 11148bbf4976SDavid Howells struct key **_dest_keyring) 11158bbf4976SDavid Howells { 11168bbf4976SDavid Howells key_ref_t dkref; 11178bbf4976SDavid Howells 11188bbf4976SDavid Howells *_dest_keyring = NULL; 1119eca1bf5bSDavid Howells 1120eca1bf5bSDavid Howells /* just return a NULL pointer if we weren't asked to make a link */ 1121eca1bf5bSDavid Howells if (ringid == 0) 11228bbf4976SDavid Howells return 0; 11238bbf4976SDavid Howells 11248bbf4976SDavid Howells /* if a specific keyring is nominated by ID, then use that */ 11258bbf4976SDavid Howells if (ringid > 0) { 1126f5895943SDavid Howells dkref = lookup_user_key(ringid, KEY_LOOKUP_CREATE, KEY_NEED_WRITE); 11278bbf4976SDavid Howells if (IS_ERR(dkref)) 11288bbf4976SDavid Howells return PTR_ERR(dkref); 11298bbf4976SDavid Howells *_dest_keyring = key_ref_to_ptr(dkref); 11308bbf4976SDavid Howells return 0; 11318bbf4976SDavid Howells } 11328bbf4976SDavid Howells 11338bbf4976SDavid Howells if (ringid == KEY_SPEC_REQKEY_AUTH_KEY) 11348bbf4976SDavid Howells return -EINVAL; 11358bbf4976SDavid Howells 11368bbf4976SDavid Howells /* otherwise specify the destination keyring recorded in the 11378bbf4976SDavid Howells * authorisation key (any KEY_SPEC_*_KEYRING) */ 11388bbf4976SDavid Howells if (ringid >= KEY_SPEC_REQUESTOR_KEYRING) { 113921279cfaSDavid Howells *_dest_keyring = key_get(rka->dest_keyring); 11408bbf4976SDavid Howells return 0; 11418bbf4976SDavid Howells } 11428bbf4976SDavid Howells 11438bbf4976SDavid Howells return -ENOKEY; 11448bbf4976SDavid Howells } 11458bbf4976SDavid Howells 1146d84f4f99SDavid Howells /* 1147973c9f4fSDavid Howells * Change the request_key authorisation key on the current process. 1148d84f4f99SDavid Howells */ 1149d84f4f99SDavid Howells static int keyctl_change_reqkey_auth(struct key *key) 1150d84f4f99SDavid Howells { 1151d84f4f99SDavid Howells struct cred *new; 1152d84f4f99SDavid Howells 1153d84f4f99SDavid Howells new = prepare_creds(); 1154d84f4f99SDavid Howells if (!new) 1155d84f4f99SDavid Howells return -ENOMEM; 1156d84f4f99SDavid Howells 1157d84f4f99SDavid Howells key_put(new->request_key_auth); 1158d84f4f99SDavid Howells new->request_key_auth = key_get(key); 1159d84f4f99SDavid Howells 1160d84f4f99SDavid Howells return commit_creds(new); 1161d84f4f99SDavid Howells } 1162d84f4f99SDavid Howells 11631da177e4SLinus Torvalds /* 1164973c9f4fSDavid Howells * Instantiate a key with the specified payload and link the key into the 1165973c9f4fSDavid Howells * destination keyring if one is given. 1166973c9f4fSDavid Howells * 1167973c9f4fSDavid Howells * The caller must have the appropriate instantiation permit set for this to 1168973c9f4fSDavid Howells * work (see keyctl_assume_authority). No other permissions are required. 1169973c9f4fSDavid Howells * 1170973c9f4fSDavid Howells * If successful, 0 will be returned. 11711da177e4SLinus Torvalds */ 11725d47b394SChristoph Hellwig static long keyctl_instantiate_key_common(key_serial_t id, 1173b353a1f7SAl Viro struct iov_iter *from, 11741da177e4SLinus Torvalds key_serial_t ringid) 11751da177e4SLinus Torvalds { 1176d84f4f99SDavid Howells const struct cred *cred = current_cred(); 11773e30148cSDavid Howells struct request_key_auth *rka; 11788bbf4976SDavid Howells struct key *instkey, *dest_keyring; 1179b353a1f7SAl Viro size_t plen = from ? iov_iter_count(from) : 0; 11801da177e4SLinus Torvalds void *payload; 11811da177e4SLinus Torvalds long ret; 11821da177e4SLinus Torvalds 1183d84f4f99SDavid Howells kenter("%d,,%zu,%d", id, plen, ringid); 1184d84f4f99SDavid Howells 1185b353a1f7SAl Viro if (!plen) 1186b353a1f7SAl Viro from = NULL; 1187b353a1f7SAl Viro 11881da177e4SLinus Torvalds ret = -EINVAL; 118938bbca6bSDavid Howells if (plen > 1024 * 1024 - 1) 11901da177e4SLinus Torvalds goto error; 11911da177e4SLinus Torvalds 1192b5f545c8SDavid Howells /* the appropriate instantiation authorisation key must have been 1193b5f545c8SDavid Howells * assumed before calling this */ 1194b5f545c8SDavid Howells ret = -EPERM; 1195d84f4f99SDavid Howells instkey = cred->request_key_auth; 1196b5f545c8SDavid Howells if (!instkey) 1197b5f545c8SDavid Howells goto error; 1198b5f545c8SDavid Howells 1199146aa8b1SDavid Howells rka = instkey->payload.data[0]; 1200b5f545c8SDavid Howells if (rka->target_key->serial != id) 1201b5f545c8SDavid Howells goto error; 1202b5f545c8SDavid Howells 12031da177e4SLinus Torvalds /* pull the payload in if one was supplied */ 12041da177e4SLinus Torvalds payload = NULL; 12051da177e4SLinus Torvalds 1206b353a1f7SAl Viro if (from) { 12071da177e4SLinus Torvalds ret = -ENOMEM; 1208752ade68SMichal Hocko payload = kvmalloc(plen, GFP_KERNEL); 12091da177e4SLinus Torvalds if (!payload) 12101da177e4SLinus Torvalds goto error; 12111da177e4SLinus Torvalds 1212b353a1f7SAl Viro ret = -EFAULT; 1213cbbd26b8SAl Viro if (!copy_from_iter_full(payload, plen, from)) 12141da177e4SLinus Torvalds goto error2; 12151da177e4SLinus Torvalds } 12161da177e4SLinus Torvalds 12173e30148cSDavid Howells /* find the destination keyring amongst those belonging to the 12183e30148cSDavid Howells * requesting task */ 12198bbf4976SDavid Howells ret = get_instantiation_keyring(ringid, rka, &dest_keyring); 12208bbf4976SDavid Howells if (ret < 0) 1221b5f545c8SDavid Howells goto error2; 12221da177e4SLinus Torvalds 12231da177e4SLinus Torvalds /* instantiate the key and link it into a keyring */ 12243e30148cSDavid Howells ret = key_instantiate_and_link(rka->target_key, payload, plen, 12258bbf4976SDavid Howells dest_keyring, instkey); 12261da177e4SLinus Torvalds 12278bbf4976SDavid Howells key_put(dest_keyring); 1228b5f545c8SDavid Howells 1229b5f545c8SDavid Howells /* discard the assumed authority if it's just been disabled by 1230b5f545c8SDavid Howells * instantiation of the key */ 1231d84f4f99SDavid Howells if (ret == 0) 1232d84f4f99SDavid Howells keyctl_change_reqkey_auth(NULL); 1233b5f545c8SDavid Howells 12341da177e4SLinus Torvalds error2: 1235d4eaa283SWaiman Long kvfree_sensitive(payload, plen); 12361da177e4SLinus Torvalds error: 12371da177e4SLinus Torvalds return ret; 1238a8b17ed0SDavid Howells } 12391da177e4SLinus Torvalds 12401da177e4SLinus Torvalds /* 1241ee009e4aSDavid Howells * Instantiate a key with the specified payload and link the key into the 1242ee009e4aSDavid Howells * destination keyring if one is given. 1243ee009e4aSDavid Howells * 1244ee009e4aSDavid Howells * The caller must have the appropriate instantiation permit set for this to 1245ee009e4aSDavid Howells * work (see keyctl_assume_authority). No other permissions are required. 1246ee009e4aSDavid Howells * 1247ee009e4aSDavid Howells * If successful, 0 will be returned. 1248ee009e4aSDavid Howells */ 1249ee009e4aSDavid Howells long keyctl_instantiate_key(key_serial_t id, 1250ee009e4aSDavid Howells const void __user *_payload, 1251ee009e4aSDavid Howells size_t plen, 1252ee009e4aSDavid Howells key_serial_t ringid) 1253ee009e4aSDavid Howells { 1254ee009e4aSDavid Howells if (_payload && plen) { 1255b353a1f7SAl Viro struct iovec iov; 1256b353a1f7SAl Viro struct iov_iter from; 1257b353a1f7SAl Viro int ret; 1258ee009e4aSDavid Howells 1259de4eda9dSAl Viro ret = import_single_range(ITER_SOURCE, (void __user *)_payload, plen, 1260b353a1f7SAl Viro &iov, &from); 1261b353a1f7SAl Viro if (unlikely(ret)) 1262b353a1f7SAl Viro return ret; 1263b353a1f7SAl Viro 1264b353a1f7SAl Viro return keyctl_instantiate_key_common(id, &from, ringid); 1265ee009e4aSDavid Howells } 1266ee009e4aSDavid Howells 1267b353a1f7SAl Viro return keyctl_instantiate_key_common(id, NULL, ringid); 1268ee009e4aSDavid Howells } 1269ee009e4aSDavid Howells 1270ee009e4aSDavid Howells /* 1271ee009e4aSDavid Howells * Instantiate a key with the specified multipart payload and link the key into 1272ee009e4aSDavid Howells * the destination keyring if one is given. 1273ee009e4aSDavid Howells * 1274ee009e4aSDavid Howells * The caller must have the appropriate instantiation permit set for this to 1275ee009e4aSDavid Howells * work (see keyctl_assume_authority). No other permissions are required. 1276ee009e4aSDavid Howells * 1277ee009e4aSDavid Howells * If successful, 0 will be returned. 1278ee009e4aSDavid Howells */ 1279ee009e4aSDavid Howells long keyctl_instantiate_key_iov(key_serial_t id, 1280ee009e4aSDavid Howells const struct iovec __user *_payload_iov, 1281ee009e4aSDavid Howells unsigned ioc, 1282ee009e4aSDavid Howells key_serial_t ringid) 1283ee009e4aSDavid Howells { 1284ee009e4aSDavid Howells struct iovec iovstack[UIO_FASTIOV], *iov = iovstack; 1285b353a1f7SAl Viro struct iov_iter from; 1286ee009e4aSDavid Howells long ret; 1287ee009e4aSDavid Howells 1288b353a1f7SAl Viro if (!_payload_iov) 1289b353a1f7SAl Viro ioc = 0; 1290ee009e4aSDavid Howells 1291de4eda9dSAl Viro ret = import_iovec(ITER_SOURCE, _payload_iov, ioc, 1292b353a1f7SAl Viro ARRAY_SIZE(iovstack), &iov, &from); 1293ee009e4aSDavid Howells if (ret < 0) 1294b353a1f7SAl Viro return ret; 1295b353a1f7SAl Viro ret = keyctl_instantiate_key_common(id, &from, ringid); 1296ee009e4aSDavid Howells kfree(iov); 1297ee009e4aSDavid Howells return ret; 1298ee009e4aSDavid Howells } 1299ee009e4aSDavid Howells 1300ee009e4aSDavid Howells /* 1301973c9f4fSDavid Howells * Negatively instantiate the key with the given timeout (in seconds) and link 1302973c9f4fSDavid Howells * the key into the destination keyring if one is given. 1303973c9f4fSDavid Howells * 1304973c9f4fSDavid Howells * The caller must have the appropriate instantiation permit set for this to 1305973c9f4fSDavid Howells * work (see keyctl_assume_authority). No other permissions are required. 1306973c9f4fSDavid Howells * 1307973c9f4fSDavid Howells * The key and any links to the key will be automatically garbage collected 1308973c9f4fSDavid Howells * after the timeout expires. 1309973c9f4fSDavid Howells * 1310973c9f4fSDavid Howells * Negative keys are used to rate limit repeated request_key() calls by causing 1311973c9f4fSDavid Howells * them to return -ENOKEY until the negative key expires. 1312973c9f4fSDavid Howells * 1313973c9f4fSDavid Howells * If successful, 0 will be returned. 13141da177e4SLinus Torvalds */ 13151da177e4SLinus Torvalds long keyctl_negate_key(key_serial_t id, unsigned timeout, key_serial_t ringid) 13161da177e4SLinus Torvalds { 1317fdd1b945SDavid Howells return keyctl_reject_key(id, timeout, ENOKEY, ringid); 1318fdd1b945SDavid Howells } 1319fdd1b945SDavid Howells 1320fdd1b945SDavid Howells /* 1321fdd1b945SDavid Howells * Negatively instantiate the key with the given timeout (in seconds) and error 1322fdd1b945SDavid Howells * code and link the key into the destination keyring if one is given. 1323fdd1b945SDavid Howells * 1324fdd1b945SDavid Howells * The caller must have the appropriate instantiation permit set for this to 1325fdd1b945SDavid Howells * work (see keyctl_assume_authority). No other permissions are required. 1326fdd1b945SDavid Howells * 1327fdd1b945SDavid Howells * The key and any links to the key will be automatically garbage collected 1328fdd1b945SDavid Howells * after the timeout expires. 1329fdd1b945SDavid Howells * 1330fdd1b945SDavid Howells * Negative keys are used to rate limit repeated request_key() calls by causing 1331fdd1b945SDavid Howells * them to return the specified error code until the negative key expires. 1332fdd1b945SDavid Howells * 1333fdd1b945SDavid Howells * If successful, 0 will be returned. 1334fdd1b945SDavid Howells */ 1335fdd1b945SDavid Howells long keyctl_reject_key(key_serial_t id, unsigned timeout, unsigned error, 1336fdd1b945SDavid Howells key_serial_t ringid) 1337fdd1b945SDavid Howells { 1338d84f4f99SDavid Howells const struct cred *cred = current_cred(); 13393e30148cSDavid Howells struct request_key_auth *rka; 13408bbf4976SDavid Howells struct key *instkey, *dest_keyring; 13411da177e4SLinus Torvalds long ret; 13421da177e4SLinus Torvalds 1343fdd1b945SDavid Howells kenter("%d,%u,%u,%d", id, timeout, error, ringid); 1344fdd1b945SDavid Howells 1345fdd1b945SDavid Howells /* must be a valid error code and mustn't be a kernel special */ 1346fdd1b945SDavid Howells if (error <= 0 || 1347fdd1b945SDavid Howells error >= MAX_ERRNO || 1348fdd1b945SDavid Howells error == ERESTARTSYS || 1349fdd1b945SDavid Howells error == ERESTARTNOINTR || 1350fdd1b945SDavid Howells error == ERESTARTNOHAND || 1351fdd1b945SDavid Howells error == ERESTART_RESTARTBLOCK) 1352fdd1b945SDavid Howells return -EINVAL; 1353d84f4f99SDavid Howells 1354b5f545c8SDavid Howells /* the appropriate instantiation authorisation key must have been 1355b5f545c8SDavid Howells * assumed before calling this */ 1356b5f545c8SDavid Howells ret = -EPERM; 1357d84f4f99SDavid Howells instkey = cred->request_key_auth; 1358b5f545c8SDavid Howells if (!instkey) 13591da177e4SLinus Torvalds goto error; 13601da177e4SLinus Torvalds 1361146aa8b1SDavid Howells rka = instkey->payload.data[0]; 1362b5f545c8SDavid Howells if (rka->target_key->serial != id) 1363b5f545c8SDavid Howells goto error; 13643e30148cSDavid Howells 13651da177e4SLinus Torvalds /* find the destination keyring if present (which must also be 13661da177e4SLinus Torvalds * writable) */ 13678bbf4976SDavid Howells ret = get_instantiation_keyring(ringid, rka, &dest_keyring); 13688bbf4976SDavid Howells if (ret < 0) 1369b5f545c8SDavid Howells goto error; 13701da177e4SLinus Torvalds 13711da177e4SLinus Torvalds /* instantiate the key and link it into a keyring */ 1372fdd1b945SDavid Howells ret = key_reject_and_link(rka->target_key, timeout, error, 13738bbf4976SDavid Howells dest_keyring, instkey); 13741da177e4SLinus Torvalds 13758bbf4976SDavid Howells key_put(dest_keyring); 1376b5f545c8SDavid Howells 1377b5f545c8SDavid Howells /* discard the assumed authority if it's just been disabled by 1378b5f545c8SDavid Howells * instantiation of the key */ 1379d84f4f99SDavid Howells if (ret == 0) 1380d84f4f99SDavid Howells keyctl_change_reqkey_auth(NULL); 1381b5f545c8SDavid Howells 13821da177e4SLinus Torvalds error: 13831da177e4SLinus Torvalds return ret; 1384a8b17ed0SDavid Howells } 13851da177e4SLinus Torvalds 13861da177e4SLinus Torvalds /* 1387973c9f4fSDavid Howells * Read or set the default keyring in which request_key() will cache keys and 1388973c9f4fSDavid Howells * return the old setting. 1389973c9f4fSDavid Howells * 1390c9f838d1SEric Biggers * If a thread or process keyring is specified then it will be created if it 1391c9f838d1SEric Biggers * doesn't yet exist. The old setting will be returned if successful. 13923e30148cSDavid Howells */ 13933e30148cSDavid Howells long keyctl_set_reqkey_keyring(int reqkey_defl) 13943e30148cSDavid Howells { 1395d84f4f99SDavid Howells struct cred *new; 1396d84f4f99SDavid Howells int ret, old_setting; 1397d84f4f99SDavid Howells 1398d84f4f99SDavid Howells old_setting = current_cred_xxx(jit_keyring); 1399d84f4f99SDavid Howells 1400d84f4f99SDavid Howells if (reqkey_defl == KEY_REQKEY_DEFL_NO_CHANGE) 1401d84f4f99SDavid Howells return old_setting; 1402d84f4f99SDavid Howells 1403d84f4f99SDavid Howells new = prepare_creds(); 1404d84f4f99SDavid Howells if (!new) 1405d84f4f99SDavid Howells return -ENOMEM; 14063e30148cSDavid Howells 14073e30148cSDavid Howells switch (reqkey_defl) { 14083e30148cSDavid Howells case KEY_REQKEY_DEFL_THREAD_KEYRING: 1409d84f4f99SDavid Howells ret = install_thread_keyring_to_cred(new); 14103e30148cSDavid Howells if (ret < 0) 1411d84f4f99SDavid Howells goto error; 14123e30148cSDavid Howells goto set; 14133e30148cSDavid Howells 14143e30148cSDavid Howells case KEY_REQKEY_DEFL_PROCESS_KEYRING: 1415d84f4f99SDavid Howells ret = install_process_keyring_to_cred(new); 1416c9f838d1SEric Biggers if (ret < 0) 1417d84f4f99SDavid Howells goto error; 1418d84f4f99SDavid Howells goto set; 14193e30148cSDavid Howells 14203e30148cSDavid Howells case KEY_REQKEY_DEFL_DEFAULT: 14213e30148cSDavid Howells case KEY_REQKEY_DEFL_SESSION_KEYRING: 14223e30148cSDavid Howells case KEY_REQKEY_DEFL_USER_KEYRING: 14233e30148cSDavid Howells case KEY_REQKEY_DEFL_USER_SESSION_KEYRING: 1424d84f4f99SDavid Howells case KEY_REQKEY_DEFL_REQUESTOR_KEYRING: 1425d84f4f99SDavid Howells goto set; 14263e30148cSDavid Howells 14273e30148cSDavid Howells case KEY_REQKEY_DEFL_NO_CHANGE: 14283e30148cSDavid Howells case KEY_REQKEY_DEFL_GROUP_KEYRING: 14293e30148cSDavid Howells default: 1430d84f4f99SDavid Howells ret = -EINVAL; 1431d84f4f99SDavid Howells goto error; 14323e30148cSDavid Howells } 14333e30148cSDavid Howells 1434d84f4f99SDavid Howells set: 1435d84f4f99SDavid Howells new->jit_keyring = reqkey_defl; 1436d84f4f99SDavid Howells commit_creds(new); 1437d84f4f99SDavid Howells return old_setting; 1438d84f4f99SDavid Howells error: 1439d84f4f99SDavid Howells abort_creds(new); 14404303ef19SDan Carpenter return ret; 1441a8b17ed0SDavid Howells } 1442d84f4f99SDavid Howells 14433e30148cSDavid Howells /* 1444973c9f4fSDavid Howells * Set or clear the timeout on a key. 1445973c9f4fSDavid Howells * 1446973c9f4fSDavid Howells * Either the key must grant the caller Setattr permission or else the caller 1447973c9f4fSDavid Howells * must hold an instantiation authorisation token for the key. 1448973c9f4fSDavid Howells * 1449973c9f4fSDavid Howells * The timeout is either 0 to clear the timeout, or a number of seconds from 1450973c9f4fSDavid Howells * the current time. The key and any links to the key will be automatically 1451973c9f4fSDavid Howells * garbage collected after the timeout expires. 1452973c9f4fSDavid Howells * 1453d3600bcfSMimi Zohar * Keys with KEY_FLAG_KEEP set should not be timed out. 1454d3600bcfSMimi Zohar * 1455973c9f4fSDavid Howells * If successful, 0 is returned. 1456017679c4SDavid Howells */ 1457017679c4SDavid Howells long keyctl_set_timeout(key_serial_t id, unsigned timeout) 1458017679c4SDavid Howells { 14599156235bSDavid Howells struct key *key, *instkey; 1460017679c4SDavid Howells key_ref_t key_ref; 1461017679c4SDavid Howells long ret; 1462017679c4SDavid Howells 14635593122eSDavid Howells key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE | KEY_LOOKUP_PARTIAL, 1464028db3e2SLinus Torvalds KEY_NEED_SETATTR); 1465017679c4SDavid Howells if (IS_ERR(key_ref)) { 14669156235bSDavid Howells /* setting the timeout on a key under construction is permitted 14679156235bSDavid Howells * if we have the authorisation token handy */ 14689156235bSDavid Howells if (PTR_ERR(key_ref) == -EACCES) { 14699156235bSDavid Howells instkey = key_get_instantiation_authkey(id); 14709156235bSDavid Howells if (!IS_ERR(instkey)) { 14719156235bSDavid Howells key_put(instkey); 14729156235bSDavid Howells key_ref = lookup_user_key(id, 14739156235bSDavid Howells KEY_LOOKUP_PARTIAL, 14748c0637e9SDavid Howells KEY_AUTHTOKEN_OVERRIDE); 14759156235bSDavid Howells if (!IS_ERR(key_ref)) 14769156235bSDavid Howells goto okay; 14779156235bSDavid Howells } 14789156235bSDavid Howells } 14799156235bSDavid Howells 1480017679c4SDavid Howells ret = PTR_ERR(key_ref); 1481017679c4SDavid Howells goto error; 1482017679c4SDavid Howells } 1483017679c4SDavid Howells 14849156235bSDavid Howells okay: 1485017679c4SDavid Howells key = key_ref_to_ptr(key_ref); 14861d6d167cSMimi Zohar ret = 0; 1487f7e47677SDavid Howells if (test_bit(KEY_FLAG_KEEP, &key->flags)) { 1488d3600bcfSMimi Zohar ret = -EPERM; 1489f7e47677SDavid Howells } else { 149059e6b9c1SBryan Schumaker key_set_timeout(key, timeout); 1491f7e47677SDavid Howells notify_key(key, NOTIFY_KEY_SETATTR, 0); 1492f7e47677SDavid Howells } 1493017679c4SDavid Howells key_put(key); 1494017679c4SDavid Howells 1495017679c4SDavid Howells error: 1496017679c4SDavid Howells return ret; 1497a8b17ed0SDavid Howells } 1498017679c4SDavid Howells 1499017679c4SDavid Howells /* 1500973c9f4fSDavid Howells * Assume (or clear) the authority to instantiate the specified key. 1501973c9f4fSDavid Howells * 1502973c9f4fSDavid Howells * This sets the authoritative token currently in force for key instantiation. 1503973c9f4fSDavid Howells * This must be done for a key to be instantiated. It has the effect of making 1504973c9f4fSDavid Howells * available all the keys from the caller of the request_key() that created a 1505973c9f4fSDavid Howells * key to request_key() calls made by the caller of this function. 1506973c9f4fSDavid Howells * 1507973c9f4fSDavid Howells * The caller must have the instantiation key in their process keyrings with a 1508973c9f4fSDavid Howells * Search permission grant available to the caller. 1509973c9f4fSDavid Howells * 1510973c9f4fSDavid Howells * If the ID given is 0, then the setting will be cleared and 0 returned. 1511973c9f4fSDavid Howells * 1512973c9f4fSDavid Howells * If the ID given has a matching an authorisation key, then that key will be 1513973c9f4fSDavid Howells * set and its ID will be returned. The authorisation key can be read to get 1514973c9f4fSDavid Howells * the callout information passed to request_key(). 1515b5f545c8SDavid Howells */ 1516b5f545c8SDavid Howells long keyctl_assume_authority(key_serial_t id) 1517b5f545c8SDavid Howells { 1518b5f545c8SDavid Howells struct key *authkey; 1519b5f545c8SDavid Howells long ret; 1520b5f545c8SDavid Howells 1521b5f545c8SDavid Howells /* special key IDs aren't permitted */ 1522b5f545c8SDavid Howells ret = -EINVAL; 1523b5f545c8SDavid Howells if (id < 0) 1524b5f545c8SDavid Howells goto error; 1525b5f545c8SDavid Howells 1526b5f545c8SDavid Howells /* we divest ourselves of authority if given an ID of 0 */ 1527b5f545c8SDavid Howells if (id == 0) { 1528d84f4f99SDavid Howells ret = keyctl_change_reqkey_auth(NULL); 1529b5f545c8SDavid Howells goto error; 1530b5f545c8SDavid Howells } 1531b5f545c8SDavid Howells 1532b5f545c8SDavid Howells /* attempt to assume the authority temporarily granted to us whilst we 1533b5f545c8SDavid Howells * instantiate the specified key 1534b5f545c8SDavid Howells * - the authorisation key must be in the current task's keyrings 1535b5f545c8SDavid Howells * somewhere 1536b5f545c8SDavid Howells */ 1537b5f545c8SDavid Howells authkey = key_get_instantiation_authkey(id); 1538b5f545c8SDavid Howells if (IS_ERR(authkey)) { 1539b5f545c8SDavid Howells ret = PTR_ERR(authkey); 1540b5f545c8SDavid Howells goto error; 1541b5f545c8SDavid Howells } 1542b5f545c8SDavid Howells 1543d84f4f99SDavid Howells ret = keyctl_change_reqkey_auth(authkey); 1544884bee02SEric Biggers if (ret == 0) 1545d84f4f99SDavid Howells ret = authkey->serial; 1546884bee02SEric Biggers key_put(authkey); 1547b5f545c8SDavid Howells error: 1548b5f545c8SDavid Howells return ret; 1549a8b17ed0SDavid Howells } 1550b5f545c8SDavid Howells 155170a5bb72SDavid Howells /* 1552973c9f4fSDavid Howells * Get a key's the LSM security label. 1553973c9f4fSDavid Howells * 1554973c9f4fSDavid Howells * The key must grant the caller View permission for this to work. 1555973c9f4fSDavid Howells * 1556973c9f4fSDavid Howells * If there's a buffer, then up to buflen bytes of data will be placed into it. 1557973c9f4fSDavid Howells * 1558973c9f4fSDavid Howells * If successful, the amount of information available will be returned, 1559973c9f4fSDavid Howells * irrespective of how much was copied (including the terminal NUL). 156070a5bb72SDavid Howells */ 156170a5bb72SDavid Howells long keyctl_get_security(key_serial_t keyid, 156270a5bb72SDavid Howells char __user *buffer, 156370a5bb72SDavid Howells size_t buflen) 156470a5bb72SDavid Howells { 156570a5bb72SDavid Howells struct key *key, *instkey; 156670a5bb72SDavid Howells key_ref_t key_ref; 156770a5bb72SDavid Howells char *context; 156870a5bb72SDavid Howells long ret; 156970a5bb72SDavid Howells 1570f5895943SDavid Howells key_ref = lookup_user_key(keyid, KEY_LOOKUP_PARTIAL, KEY_NEED_VIEW); 157170a5bb72SDavid Howells if (IS_ERR(key_ref)) { 157270a5bb72SDavid Howells if (PTR_ERR(key_ref) != -EACCES) 157370a5bb72SDavid Howells return PTR_ERR(key_ref); 157470a5bb72SDavid Howells 157570a5bb72SDavid Howells /* viewing a key under construction is also permitted if we 157670a5bb72SDavid Howells * have the authorisation token handy */ 157770a5bb72SDavid Howells instkey = key_get_instantiation_authkey(keyid); 157870a5bb72SDavid Howells if (IS_ERR(instkey)) 1579fa1cc7b5SRoel Kluin return PTR_ERR(instkey); 158070a5bb72SDavid Howells key_put(instkey); 158170a5bb72SDavid Howells 15828c0637e9SDavid Howells key_ref = lookup_user_key(keyid, KEY_LOOKUP_PARTIAL, 15838c0637e9SDavid Howells KEY_AUTHTOKEN_OVERRIDE); 158470a5bb72SDavid Howells if (IS_ERR(key_ref)) 158570a5bb72SDavid Howells return PTR_ERR(key_ref); 158670a5bb72SDavid Howells } 158770a5bb72SDavid Howells 158870a5bb72SDavid Howells key = key_ref_to_ptr(key_ref); 158970a5bb72SDavid Howells ret = security_key_getsecurity(key, &context); 159070a5bb72SDavid Howells if (ret == 0) { 159170a5bb72SDavid Howells /* if no information was returned, give userspace an empty 159270a5bb72SDavid Howells * string */ 159370a5bb72SDavid Howells ret = 1; 159470a5bb72SDavid Howells if (buffer && buflen > 0 && 159570a5bb72SDavid Howells copy_to_user(buffer, "", 1) != 0) 159670a5bb72SDavid Howells ret = -EFAULT; 159770a5bb72SDavid Howells } else if (ret > 0) { 159870a5bb72SDavid Howells /* return as much data as there's room for */ 159970a5bb72SDavid Howells if (buffer && buflen > 0) { 160070a5bb72SDavid Howells if (buflen > ret) 160170a5bb72SDavid Howells buflen = ret; 160270a5bb72SDavid Howells 160370a5bb72SDavid Howells if (copy_to_user(buffer, context, buflen) != 0) 160470a5bb72SDavid Howells ret = -EFAULT; 160570a5bb72SDavid Howells } 160670a5bb72SDavid Howells 160770a5bb72SDavid Howells kfree(context); 160870a5bb72SDavid Howells } 160970a5bb72SDavid Howells 161070a5bb72SDavid Howells key_ref_put(key_ref); 161170a5bb72SDavid Howells return ret; 161270a5bb72SDavid Howells } 161370a5bb72SDavid Howells 1614ee18d64cSDavid Howells /* 1615973c9f4fSDavid Howells * Attempt to install the calling process's session keyring on the process's 1616973c9f4fSDavid Howells * parent process. 1617973c9f4fSDavid Howells * 1618028db3e2SLinus Torvalds * The keyring must exist and must grant the caller LINK permission, and the 1619973c9f4fSDavid Howells * parent process must be single-threaded and must have the same effective 1620973c9f4fSDavid Howells * ownership as this process and mustn't be SUID/SGID. 1621973c9f4fSDavid Howells * 1622973c9f4fSDavid Howells * The keyring will be emplaced on the parent when it next resumes userspace. 1623973c9f4fSDavid Howells * 1624973c9f4fSDavid Howells * If successful, 0 will be returned. 1625ee18d64cSDavid Howells */ 1626ee18d64cSDavid Howells long keyctl_session_to_parent(void) 1627ee18d64cSDavid Howells { 1628ee18d64cSDavid Howells struct task_struct *me, *parent; 1629ee18d64cSDavid Howells const struct cred *mycred, *pcred; 163067d12145SAl Viro struct callback_head *newwork, *oldwork; 1631ee18d64cSDavid Howells key_ref_t keyring_r; 1632413cd3d9SOleg Nesterov struct cred *cred; 1633ee18d64cSDavid Howells int ret; 1634ee18d64cSDavid Howells 1635028db3e2SLinus Torvalds keyring_r = lookup_user_key(KEY_SPEC_SESSION_KEYRING, 0, KEY_NEED_LINK); 1636ee18d64cSDavid Howells if (IS_ERR(keyring_r)) 1637ee18d64cSDavid Howells return PTR_ERR(keyring_r); 1638ee18d64cSDavid Howells 1639413cd3d9SOleg Nesterov ret = -ENOMEM; 1640413cd3d9SOleg Nesterov 1641ee18d64cSDavid Howells /* our parent is going to need a new cred struct, a new tgcred struct 1642ee18d64cSDavid Howells * and new security data, so we allocate them here to prevent ENOMEM in 1643ee18d64cSDavid Howells * our parent */ 1644ee18d64cSDavid Howells cred = cred_alloc_blank(); 1645ee18d64cSDavid Howells if (!cred) 164667d12145SAl Viro goto error_keyring; 164767d12145SAl Viro newwork = &cred->rcu; 1648ee18d64cSDavid Howells 16493a50597dSDavid Howells cred->session_keyring = key_ref_to_ptr(keyring_r); 16503a50597dSDavid Howells keyring_r = NULL; 165167d12145SAl Viro init_task_work(newwork, key_change_session_keyring); 1652ee18d64cSDavid Howells 1653ee18d64cSDavid Howells me = current; 16549d1ac65aSDavid Howells rcu_read_lock(); 1655ee18d64cSDavid Howells write_lock_irq(&tasklist_lock); 1656ee18d64cSDavid Howells 1657ee18d64cSDavid Howells ret = -EPERM; 1658413cd3d9SOleg Nesterov oldwork = NULL; 16597936d16dSDavid Howells parent = rcu_dereference_protected(me->real_parent, 16607936d16dSDavid Howells lockdep_is_held(&tasklist_lock)); 1661ee18d64cSDavid Howells 1662ee18d64cSDavid Howells /* the parent mustn't be init and mustn't be a kernel thread */ 1663ee18d64cSDavid Howells if (parent->pid <= 1 || !parent->mm) 1664413cd3d9SOleg Nesterov goto unlock; 1665ee18d64cSDavid Howells 1666ee18d64cSDavid Howells /* the parent must be single threaded */ 1667dd98acf7SOleg Nesterov if (!thread_group_empty(parent)) 1668413cd3d9SOleg Nesterov goto unlock; 1669ee18d64cSDavid Howells 1670ee18d64cSDavid Howells /* the parent and the child must have different session keyrings or 1671ee18d64cSDavid Howells * there's no point */ 1672ee18d64cSDavid Howells mycred = current_cred(); 1673ee18d64cSDavid Howells pcred = __task_cred(parent); 1674ee18d64cSDavid Howells if (mycred == pcred || 16753a50597dSDavid Howells mycred->session_keyring == pcred->session_keyring) { 1676413cd3d9SOleg Nesterov ret = 0; 1677413cd3d9SOleg Nesterov goto unlock; 1678413cd3d9SOleg Nesterov } 1679ee18d64cSDavid Howells 1680ee18d64cSDavid Howells /* the parent must have the same effective ownership and mustn't be 1681ee18d64cSDavid Howells * SUID/SGID */ 16829a56c2dbSEric W. Biederman if (!uid_eq(pcred->uid, mycred->euid) || 16839a56c2dbSEric W. Biederman !uid_eq(pcred->euid, mycred->euid) || 16849a56c2dbSEric W. Biederman !uid_eq(pcred->suid, mycred->euid) || 16859a56c2dbSEric W. Biederman !gid_eq(pcred->gid, mycred->egid) || 16869a56c2dbSEric W. Biederman !gid_eq(pcred->egid, mycred->egid) || 16879a56c2dbSEric W. Biederman !gid_eq(pcred->sgid, mycred->egid)) 1688413cd3d9SOleg Nesterov goto unlock; 1689ee18d64cSDavid Howells 1690ee18d64cSDavid Howells /* the keyrings must have the same UID */ 16913a50597dSDavid Howells if ((pcred->session_keyring && 16922a74dbb9SLinus Torvalds !uid_eq(pcred->session_keyring->uid, mycred->euid)) || 16932a74dbb9SLinus Torvalds !uid_eq(mycred->session_keyring->uid, mycred->euid)) 1694413cd3d9SOleg Nesterov goto unlock; 1695ee18d64cSDavid Howells 1696413cd3d9SOleg Nesterov /* cancel an already pending keyring replacement */ 1697413cd3d9SOleg Nesterov oldwork = task_work_cancel(parent, key_change_session_keyring); 1698ee18d64cSDavid Howells 1699ee18d64cSDavid Howells /* the replacement session keyring is applied just prior to userspace 1700ee18d64cSDavid Howells * restarting */ 170191989c70SJens Axboe ret = task_work_add(parent, newwork, TWA_RESUME); 1702413cd3d9SOleg Nesterov if (!ret) 1703413cd3d9SOleg Nesterov newwork = NULL; 1704413cd3d9SOleg Nesterov unlock: 1705ee18d64cSDavid Howells write_unlock_irq(&tasklist_lock); 17069d1ac65aSDavid Howells rcu_read_unlock(); 170767d12145SAl Viro if (oldwork) 170867d12145SAl Viro put_cred(container_of(oldwork, struct cred, rcu)); 170967d12145SAl Viro if (newwork) 171067d12145SAl Viro put_cred(cred); 1711ee18d64cSDavid Howells return ret; 1712ee18d64cSDavid Howells 1713ee18d64cSDavid Howells error_keyring: 1714ee18d64cSDavid Howells key_ref_put(keyring_r); 1715ee18d64cSDavid Howells return ret; 1716ee18d64cSDavid Howells } 1717ee18d64cSDavid Howells 1718b5f545c8SDavid Howells /* 17196563c91fSMat Martineau * Apply a restriction to a given keyring. 17206563c91fSMat Martineau * 17216563c91fSMat Martineau * The caller must have Setattr permission to change keyring restrictions. 17226563c91fSMat Martineau * 17236563c91fSMat Martineau * The requested type name may be a NULL pointer to reject all attempts 172418026d86SEric Biggers * to link to the keyring. In this case, _restriction must also be NULL. 172518026d86SEric Biggers * Otherwise, both _type and _restriction must be non-NULL. 17266563c91fSMat Martineau * 17276563c91fSMat Martineau * Returns 0 if successful. 17286563c91fSMat Martineau */ 17296563c91fSMat Martineau long keyctl_restrict_keyring(key_serial_t id, const char __user *_type, 17306563c91fSMat Martineau const char __user *_restriction) 17316563c91fSMat Martineau { 17326563c91fSMat Martineau key_ref_t key_ref; 17336563c91fSMat Martineau char type[32]; 17346563c91fSMat Martineau char *restriction = NULL; 17356563c91fSMat Martineau long ret; 17366563c91fSMat Martineau 1737028db3e2SLinus Torvalds key_ref = lookup_user_key(id, 0, KEY_NEED_SETATTR); 17386563c91fSMat Martineau if (IS_ERR(key_ref)) 17396563c91fSMat Martineau return PTR_ERR(key_ref); 17406563c91fSMat Martineau 174118026d86SEric Biggers ret = -EINVAL; 17426563c91fSMat Martineau if (_type) { 174318026d86SEric Biggers if (!_restriction) 174418026d86SEric Biggers goto error; 174518026d86SEric Biggers 17466563c91fSMat Martineau ret = key_get_type_from_user(type, _type, sizeof(type)); 17476563c91fSMat Martineau if (ret < 0) 17486563c91fSMat Martineau goto error; 17496563c91fSMat Martineau 17506563c91fSMat Martineau restriction = strndup_user(_restriction, PAGE_SIZE); 17516563c91fSMat Martineau if (IS_ERR(restriction)) { 17526563c91fSMat Martineau ret = PTR_ERR(restriction); 17536563c91fSMat Martineau goto error; 17546563c91fSMat Martineau } 175518026d86SEric Biggers } else { 175618026d86SEric Biggers if (_restriction) 175718026d86SEric Biggers goto error; 17586563c91fSMat Martineau } 17596563c91fSMat Martineau 176018026d86SEric Biggers ret = keyring_restrict(key_ref, _type ? type : NULL, restriction); 17616563c91fSMat Martineau kfree(restriction); 17626563c91fSMat Martineau error: 17636563c91fSMat Martineau key_ref_put(key_ref); 17646563c91fSMat Martineau return ret; 17656563c91fSMat Martineau } 17666563c91fSMat Martineau 1767f7e47677SDavid Howells #ifdef CONFIG_KEY_NOTIFICATIONS 1768f7e47677SDavid Howells /* 1769f7e47677SDavid Howells * Watch for changes to a key. 1770f7e47677SDavid Howells * 1771f7e47677SDavid Howells * The caller must have View permission to watch a key or keyring. 1772f7e47677SDavid Howells */ 1773f7e47677SDavid Howells long keyctl_watch_key(key_serial_t id, int watch_queue_fd, int watch_id) 1774f7e47677SDavid Howells { 1775f7e47677SDavid Howells struct watch_queue *wqueue; 1776f7e47677SDavid Howells struct watch_list *wlist = NULL; 1777f7e47677SDavid Howells struct watch *watch = NULL; 1778f7e47677SDavid Howells struct key *key; 1779f7e47677SDavid Howells key_ref_t key_ref; 1780f7e47677SDavid Howells long ret; 1781f7e47677SDavid Howells 1782f7e47677SDavid Howells if (watch_id < -1 || watch_id > 0xff) 1783f7e47677SDavid Howells return -EINVAL; 1784f7e47677SDavid Howells 1785f7e47677SDavid Howells key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE, KEY_NEED_VIEW); 1786f7e47677SDavid Howells if (IS_ERR(key_ref)) 1787f7e47677SDavid Howells return PTR_ERR(key_ref); 1788f7e47677SDavid Howells key = key_ref_to_ptr(key_ref); 1789f7e47677SDavid Howells 1790f7e47677SDavid Howells wqueue = get_watch_queue(watch_queue_fd); 1791f7e47677SDavid Howells if (IS_ERR(wqueue)) { 1792f7e47677SDavid Howells ret = PTR_ERR(wqueue); 1793f7e47677SDavid Howells goto err_key; 1794f7e47677SDavid Howells } 1795f7e47677SDavid Howells 1796f7e47677SDavid Howells if (watch_id >= 0) { 1797f7e47677SDavid Howells ret = -ENOMEM; 1798f7e47677SDavid Howells if (!key->watchers) { 1799f7e47677SDavid Howells wlist = kzalloc(sizeof(*wlist), GFP_KERNEL); 1800f7e47677SDavid Howells if (!wlist) 1801f7e47677SDavid Howells goto err_wqueue; 1802f7e47677SDavid Howells init_watch_list(wlist, NULL); 1803f7e47677SDavid Howells } 1804f7e47677SDavid Howells 1805f7e47677SDavid Howells watch = kzalloc(sizeof(*watch), GFP_KERNEL); 1806f7e47677SDavid Howells if (!watch) 1807f7e47677SDavid Howells goto err_wlist; 1808f7e47677SDavid Howells 1809f7e47677SDavid Howells init_watch(watch, wqueue); 1810f7e47677SDavid Howells watch->id = key->serial; 1811f7e47677SDavid Howells watch->info_id = (u32)watch_id << WATCH_INFO_ID__SHIFT; 1812f7e47677SDavid Howells 1813f7e47677SDavid Howells ret = security_watch_key(key); 1814f7e47677SDavid Howells if (ret < 0) 1815f7e47677SDavid Howells goto err_watch; 1816f7e47677SDavid Howells 1817f7e47677SDavid Howells down_write(&key->sem); 1818f7e47677SDavid Howells if (!key->watchers) { 1819f7e47677SDavid Howells key->watchers = wlist; 1820f7e47677SDavid Howells wlist = NULL; 1821f7e47677SDavid Howells } 1822f7e47677SDavid Howells 1823f7e47677SDavid Howells ret = add_watch_to_object(watch, key->watchers); 1824f7e47677SDavid Howells up_write(&key->sem); 1825f7e47677SDavid Howells 1826f7e47677SDavid Howells if (ret == 0) 1827f7e47677SDavid Howells watch = NULL; 1828f7e47677SDavid Howells } else { 1829f7e47677SDavid Howells ret = -EBADSLT; 1830f7e47677SDavid Howells if (key->watchers) { 1831f7e47677SDavid Howells down_write(&key->sem); 1832f7e47677SDavid Howells ret = remove_watch_from_object(key->watchers, 1833f7e47677SDavid Howells wqueue, key_serial(key), 1834f7e47677SDavid Howells false); 1835f7e47677SDavid Howells up_write(&key->sem); 1836f7e47677SDavid Howells } 1837f7e47677SDavid Howells } 1838f7e47677SDavid Howells 1839f7e47677SDavid Howells err_watch: 1840f7e47677SDavid Howells kfree(watch); 1841f7e47677SDavid Howells err_wlist: 1842f7e47677SDavid Howells kfree(wlist); 1843f7e47677SDavid Howells err_wqueue: 1844f7e47677SDavid Howells put_watch_queue(wqueue); 1845f7e47677SDavid Howells err_key: 1846f7e47677SDavid Howells key_put(key); 1847f7e47677SDavid Howells return ret; 1848f7e47677SDavid Howells } 1849f7e47677SDavid Howells #endif /* CONFIG_KEY_NOTIFICATIONS */ 1850f7e47677SDavid Howells 18516563c91fSMat Martineau /* 185245e0f30cSDavid Howells * Get keyrings subsystem capabilities. 185345e0f30cSDavid Howells */ 185445e0f30cSDavid Howells long keyctl_capabilities(unsigned char __user *_buffer, size_t buflen) 185545e0f30cSDavid Howells { 185645e0f30cSDavid Howells size_t size = buflen; 185745e0f30cSDavid Howells 185845e0f30cSDavid Howells if (size > 0) { 185945e0f30cSDavid Howells if (size > sizeof(keyrings_capabilities)) 186045e0f30cSDavid Howells size = sizeof(keyrings_capabilities); 186145e0f30cSDavid Howells if (copy_to_user(_buffer, keyrings_capabilities, size) != 0) 186245e0f30cSDavid Howells return -EFAULT; 186345e0f30cSDavid Howells if (size < buflen && 186445e0f30cSDavid Howells clear_user(_buffer + size, buflen - size) != 0) 186545e0f30cSDavid Howells return -EFAULT; 186645e0f30cSDavid Howells } 186745e0f30cSDavid Howells 186845e0f30cSDavid Howells return sizeof(keyrings_capabilities); 186945e0f30cSDavid Howells } 187045e0f30cSDavid Howells 187145e0f30cSDavid Howells /* 1872973c9f4fSDavid Howells * The key control system call 18731da177e4SLinus Torvalds */ 1874938bb9f5SHeiko Carstens SYSCALL_DEFINE5(keyctl, int, option, unsigned long, arg2, unsigned long, arg3, 1875938bb9f5SHeiko Carstens unsigned long, arg4, unsigned long, arg5) 18761da177e4SLinus Torvalds { 18771da177e4SLinus Torvalds switch (option) { 18781da177e4SLinus Torvalds case KEYCTL_GET_KEYRING_ID: 18791da177e4SLinus Torvalds return keyctl_get_keyring_ID((key_serial_t) arg2, 18801da177e4SLinus Torvalds (int) arg3); 18811da177e4SLinus Torvalds 18821da177e4SLinus Torvalds case KEYCTL_JOIN_SESSION_KEYRING: 18831da177e4SLinus Torvalds return keyctl_join_session_keyring((const char __user *) arg2); 18841da177e4SLinus Torvalds 18851da177e4SLinus Torvalds case KEYCTL_UPDATE: 18861da177e4SLinus Torvalds return keyctl_update_key((key_serial_t) arg2, 18871da177e4SLinus Torvalds (const void __user *) arg3, 18881da177e4SLinus Torvalds (size_t) arg4); 18891da177e4SLinus Torvalds 18901da177e4SLinus Torvalds case KEYCTL_REVOKE: 18911da177e4SLinus Torvalds return keyctl_revoke_key((key_serial_t) arg2); 18921da177e4SLinus Torvalds 18931da177e4SLinus Torvalds case KEYCTL_DESCRIBE: 18941da177e4SLinus Torvalds return keyctl_describe_key((key_serial_t) arg2, 18951da177e4SLinus Torvalds (char __user *) arg3, 18961da177e4SLinus Torvalds (unsigned) arg4); 18971da177e4SLinus Torvalds 18981da177e4SLinus Torvalds case KEYCTL_CLEAR: 18991da177e4SLinus Torvalds return keyctl_keyring_clear((key_serial_t) arg2); 19001da177e4SLinus Torvalds 19011da177e4SLinus Torvalds case KEYCTL_LINK: 19021da177e4SLinus Torvalds return keyctl_keyring_link((key_serial_t) arg2, 19031da177e4SLinus Torvalds (key_serial_t) arg3); 19041da177e4SLinus Torvalds 19051da177e4SLinus Torvalds case KEYCTL_UNLINK: 19061da177e4SLinus Torvalds return keyctl_keyring_unlink((key_serial_t) arg2, 19071da177e4SLinus Torvalds (key_serial_t) arg3); 19081da177e4SLinus Torvalds 19091da177e4SLinus Torvalds case KEYCTL_SEARCH: 19101da177e4SLinus Torvalds return keyctl_keyring_search((key_serial_t) arg2, 19111da177e4SLinus Torvalds (const char __user *) arg3, 19121da177e4SLinus Torvalds (const char __user *) arg4, 19131da177e4SLinus Torvalds (key_serial_t) arg5); 19141da177e4SLinus Torvalds 19151da177e4SLinus Torvalds case KEYCTL_READ: 19161da177e4SLinus Torvalds return keyctl_read_key((key_serial_t) arg2, 19171da177e4SLinus Torvalds (char __user *) arg3, 19181da177e4SLinus Torvalds (size_t) arg4); 19191da177e4SLinus Torvalds 19201da177e4SLinus Torvalds case KEYCTL_CHOWN: 19211da177e4SLinus Torvalds return keyctl_chown_key((key_serial_t) arg2, 19221da177e4SLinus Torvalds (uid_t) arg3, 19231da177e4SLinus Torvalds (gid_t) arg4); 19241da177e4SLinus Torvalds 19251da177e4SLinus Torvalds case KEYCTL_SETPERM: 19261da177e4SLinus Torvalds return keyctl_setperm_key((key_serial_t) arg2, 1927028db3e2SLinus Torvalds (key_perm_t) arg3); 19281da177e4SLinus Torvalds 19291da177e4SLinus Torvalds case KEYCTL_INSTANTIATE: 19301da177e4SLinus Torvalds return keyctl_instantiate_key((key_serial_t) arg2, 19311da177e4SLinus Torvalds (const void __user *) arg3, 19321da177e4SLinus Torvalds (size_t) arg4, 19331da177e4SLinus Torvalds (key_serial_t) arg5); 19341da177e4SLinus Torvalds 19351da177e4SLinus Torvalds case KEYCTL_NEGATE: 19361da177e4SLinus Torvalds return keyctl_negate_key((key_serial_t) arg2, 19371da177e4SLinus Torvalds (unsigned) arg3, 19381da177e4SLinus Torvalds (key_serial_t) arg4); 19391da177e4SLinus Torvalds 19403e30148cSDavid Howells case KEYCTL_SET_REQKEY_KEYRING: 19413e30148cSDavid Howells return keyctl_set_reqkey_keyring(arg2); 19423e30148cSDavid Howells 1943017679c4SDavid Howells case KEYCTL_SET_TIMEOUT: 1944017679c4SDavid Howells return keyctl_set_timeout((key_serial_t) arg2, 1945017679c4SDavid Howells (unsigned) arg3); 1946017679c4SDavid Howells 1947b5f545c8SDavid Howells case KEYCTL_ASSUME_AUTHORITY: 1948b5f545c8SDavid Howells return keyctl_assume_authority((key_serial_t) arg2); 1949b5f545c8SDavid Howells 195070a5bb72SDavid Howells case KEYCTL_GET_SECURITY: 195170a5bb72SDavid Howells return keyctl_get_security((key_serial_t) arg2, 195290bd49abSJames Morris (char __user *) arg3, 195370a5bb72SDavid Howells (size_t) arg4); 195470a5bb72SDavid Howells 1955ee18d64cSDavid Howells case KEYCTL_SESSION_TO_PARENT: 1956ee18d64cSDavid Howells return keyctl_session_to_parent(); 1957ee18d64cSDavid Howells 1958fdd1b945SDavid Howells case KEYCTL_REJECT: 1959fdd1b945SDavid Howells return keyctl_reject_key((key_serial_t) arg2, 1960fdd1b945SDavid Howells (unsigned) arg3, 1961fdd1b945SDavid Howells (unsigned) arg4, 1962fdd1b945SDavid Howells (key_serial_t) arg5); 1963fdd1b945SDavid Howells 1964ee009e4aSDavid Howells case KEYCTL_INSTANTIATE_IOV: 1965ee009e4aSDavid Howells return keyctl_instantiate_key_iov( 1966ee009e4aSDavid Howells (key_serial_t) arg2, 1967ee009e4aSDavid Howells (const struct iovec __user *) arg3, 1968ee009e4aSDavid Howells (unsigned) arg4, 1969ee009e4aSDavid Howells (key_serial_t) arg5); 1970ee009e4aSDavid Howells 1971fd75815fSDavid Howells case KEYCTL_INVALIDATE: 1972fd75815fSDavid Howells return keyctl_invalidate_key((key_serial_t) arg2); 1973fd75815fSDavid Howells 1974f36f8c75SDavid Howells case KEYCTL_GET_PERSISTENT: 1975f36f8c75SDavid Howells return keyctl_get_persistent((uid_t)arg2, (key_serial_t)arg3); 1976f36f8c75SDavid Howells 1977ddbb4114SMat Martineau case KEYCTL_DH_COMPUTE: 1978ddbb4114SMat Martineau return keyctl_dh_compute((struct keyctl_dh_params __user *) arg2, 19794693fc73SStephan Mueller (char __user *) arg3, (size_t) arg4, 1980f1c316a3SStephan Mueller (struct keyctl_kdf_params __user *) arg5); 1981ddbb4114SMat Martineau 19826563c91fSMat Martineau case KEYCTL_RESTRICT_KEYRING: 19836563c91fSMat Martineau return keyctl_restrict_keyring((key_serial_t) arg2, 19846563c91fSMat Martineau (const char __user *) arg3, 19856563c91fSMat Martineau (const char __user *) arg4); 19861da177e4SLinus Torvalds 198700d60fd3SDavid Howells case KEYCTL_PKEY_QUERY: 198800d60fd3SDavid Howells if (arg3 != 0) 198900d60fd3SDavid Howells return -EINVAL; 199000d60fd3SDavid Howells return keyctl_pkey_query((key_serial_t)arg2, 199100d60fd3SDavid Howells (const char __user *)arg4, 1992468e91ceSBen Dooks (struct keyctl_pkey_query __user *)arg5); 199300d60fd3SDavid Howells 199400d60fd3SDavid Howells case KEYCTL_PKEY_ENCRYPT: 199500d60fd3SDavid Howells case KEYCTL_PKEY_DECRYPT: 199600d60fd3SDavid Howells case KEYCTL_PKEY_SIGN: 199700d60fd3SDavid Howells return keyctl_pkey_e_d_s( 199800d60fd3SDavid Howells option, 199900d60fd3SDavid Howells (const struct keyctl_pkey_params __user *)arg2, 200000d60fd3SDavid Howells (const char __user *)arg3, 200100d60fd3SDavid Howells (const void __user *)arg4, 200200d60fd3SDavid Howells (void __user *)arg5); 200300d60fd3SDavid Howells 200400d60fd3SDavid Howells case KEYCTL_PKEY_VERIFY: 200500d60fd3SDavid Howells return keyctl_pkey_verify( 200600d60fd3SDavid Howells (const struct keyctl_pkey_params __user *)arg2, 200700d60fd3SDavid Howells (const char __user *)arg3, 200800d60fd3SDavid Howells (const void __user *)arg4, 200900d60fd3SDavid Howells (const void __user *)arg5); 201000d60fd3SDavid Howells 2011ed0ac5c7SDavid Howells case KEYCTL_MOVE: 2012ed0ac5c7SDavid Howells return keyctl_keyring_move((key_serial_t)arg2, 2013ed0ac5c7SDavid Howells (key_serial_t)arg3, 2014ed0ac5c7SDavid Howells (key_serial_t)arg4, 2015ed0ac5c7SDavid Howells (unsigned int)arg5); 2016ed0ac5c7SDavid Howells 201745e0f30cSDavid Howells case KEYCTL_CAPABILITIES: 201845e0f30cSDavid Howells return keyctl_capabilities((unsigned char __user *)arg2, (size_t)arg3); 201945e0f30cSDavid Howells 2020f7e47677SDavid Howells case KEYCTL_WATCH_KEY: 2021f7e47677SDavid Howells return keyctl_watch_key((key_serial_t)arg2, (int)arg3, (int)arg4); 2022f7e47677SDavid Howells 20231da177e4SLinus Torvalds default: 20241da177e4SLinus Torvalds return -EOPNOTSUPP; 20251da177e4SLinus Torvalds } 20261da177e4SLinus Torvalds } 2027