blob: 6ece7f2e5707f45c2736ca4a05504c2dd391ea00 [file] [log] [blame]
David Howells69664cf2008-04-29 01:01:31 -07001/* Keyring handling
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 *
David Howells69664cf2008-04-29 01:01:31 -07003 * Copyright (C) 2004-2005, 2008 Red Hat, Inc. All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * Written by David Howells (dhowells@redhat.com)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
11
12#include <linux/module.h>
13#include <linux/init.h>
14#include <linux/sched.h>
15#include <linux/slab.h>
David Howells29db9192005-10-30 15:02:44 -080016#include <linux/security.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/seq_file.h>
18#include <linux/err.h>
David Howellse9e349b2008-11-14 10:39:13 +110019#include <keys/keyring-type.h>
Chihau Chau512ea3b2010-03-08 20:11:34 -030020#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include "internal.h"
22
David Howellsf0641cb2010-04-30 14:32:18 +010023#define rcu_dereference_locked_keyring(keyring) \
24 (rcu_dereference_protected( \
25 (keyring)->payload.subscriptions, \
26 rwsem_is_locked((struct rw_semaphore *)&(keyring)->sem)))
27
David Howells233e4732012-05-11 10:56:56 +010028#define rcu_deref_link_locked(klist, index, keyring) \
29 (rcu_dereference_protected( \
30 (klist)->keys[index], \
31 rwsem_is_locked((struct rw_semaphore *)&(keyring)->sem)))
32
David Howells31d5a792012-05-11 10:56:56 +010033#define MAX_KEYRING_LINKS \
34 min_t(size_t, USHRT_MAX - 1, \
35 ((PAGE_SIZE - sizeof(struct keyring_list)) / sizeof(struct key *)))
36
David Howellsceb73c12011-01-25 16:34:28 +000037#define KEY_LINK_FIXQUOTA 1UL
38
Linus Torvalds1da177e2005-04-16 15:20:36 -070039/*
David Howells973c9f42011-01-20 16:38:33 +000040 * When plumbing the depths of the key tree, this sets a hard limit
41 * set on how deep we're willing to go.
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 */
43#define KEYRING_SEARCH_MAX_DEPTH 6
44
45/*
David Howells973c9f42011-01-20 16:38:33 +000046 * We keep all named keyrings in a hash to speed looking them up.
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 */
48#define KEYRING_NAME_HASH_SIZE (1 << 5)
49
50static struct list_head keyring_name_hash[KEYRING_NAME_HASH_SIZE];
51static DEFINE_RWLOCK(keyring_name_lock);
52
53static inline unsigned keyring_hash(const char *desc)
54{
55 unsigned bucket = 0;
56
57 for (; *desc; desc++)
Justin P. Mattockc5b60b52010-04-21 00:02:11 -070058 bucket += (unsigned char)*desc;
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
60 return bucket & (KEYRING_NAME_HASH_SIZE - 1);
61}
62
63/*
David Howells973c9f42011-01-20 16:38:33 +000064 * The keyring key type definition. Keyrings are simply keys of this type and
65 * can be treated as ordinary keys in addition to having their own special
66 * operations.
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 */
68static int keyring_instantiate(struct key *keyring,
David Howellscf7f6012012-09-13 13:06:29 +010069 struct key_preparsed_payload *prep);
Linus Torvalds1da177e2005-04-16 15:20:36 -070070static int keyring_match(const struct key *keyring, const void *criterion);
David Howells31204ed2006-06-26 00:24:51 -070071static void keyring_revoke(struct key *keyring);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072static void keyring_destroy(struct key *keyring);
73static void keyring_describe(const struct key *keyring, struct seq_file *m);
74static long keyring_read(const struct key *keyring,
75 char __user *buffer, size_t buflen);
76
77struct key_type key_type_keyring = {
78 .name = "keyring",
79 .def_datalen = sizeof(struct keyring_list),
80 .instantiate = keyring_instantiate,
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 .match = keyring_match,
David Howells31204ed2006-06-26 00:24:51 -070082 .revoke = keyring_revoke,
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 .destroy = keyring_destroy,
84 .describe = keyring_describe,
85 .read = keyring_read,
86};
David Howells73182262007-04-26 15:46:23 -070087EXPORT_SYMBOL(key_type_keyring);
88
Linus Torvalds1da177e2005-04-16 15:20:36 -070089/*
David Howells973c9f42011-01-20 16:38:33 +000090 * Semaphore to serialise link/link calls to prevent two link calls in parallel
91 * introducing a cycle.
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 */
Adrian Bunk1ae8f402006-01-06 00:11:25 -080093static DECLARE_RWSEM(keyring_serialise_link_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Linus Torvalds1da177e2005-04-16 15:20:36 -070095/*
David Howells973c9f42011-01-20 16:38:33 +000096 * Publish the name of a keyring so that it can be found by name (if it has
97 * one).
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 */
David Howells69664cf2008-04-29 01:01:31 -070099static void keyring_publish_name(struct key *keyring)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100{
101 int bucket;
102
103 if (keyring->description) {
104 bucket = keyring_hash(keyring->description);
105
106 write_lock(&keyring_name_lock);
107
108 if (!keyring_name_hash[bucket].next)
109 INIT_LIST_HEAD(&keyring_name_hash[bucket]);
110
111 list_add_tail(&keyring->type_data.link,
112 &keyring_name_hash[bucket]);
113
114 write_unlock(&keyring_name_lock);
115 }
David Howellsa8b17ed2011-01-20 16:38:27 +0000116}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118/*
David Howells973c9f42011-01-20 16:38:33 +0000119 * Initialise a keyring.
120 *
121 * Returns 0 on success, -EINVAL if given any data.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 */
123static int keyring_instantiate(struct key *keyring,
David Howellscf7f6012012-09-13 13:06:29 +0100124 struct key_preparsed_payload *prep)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125{
126 int ret;
127
128 ret = -EINVAL;
David Howellscf7f6012012-09-13 13:06:29 +0100129 if (prep->datalen == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 /* make the keyring available by name if it has one */
131 keyring_publish_name(keyring);
132 ret = 0;
133 }
134
135 return ret;
David Howellsa8b17ed2011-01-20 16:38:27 +0000136}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138/*
David Howells973c9f42011-01-20 16:38:33 +0000139 * Match keyrings on their name
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 */
141static int keyring_match(const struct key *keyring, const void *description)
142{
143 return keyring->description &&
144 strcmp(keyring->description, description) == 0;
David Howellsa8b17ed2011-01-20 16:38:27 +0000145}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147/*
David Howells973c9f42011-01-20 16:38:33 +0000148 * Clean up a keyring when it is destroyed. Unpublish its name if it had one
149 * and dispose of its data.
David Howells233e4732012-05-11 10:56:56 +0100150 *
151 * The garbage collector detects the final key_put(), removes the keyring from
152 * the serial number tree and then does RCU synchronisation before coming here,
153 * so we shouldn't need to worry about code poking around here with the RCU
154 * readlock held by this time.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 */
156static void keyring_destroy(struct key *keyring)
157{
158 struct keyring_list *klist;
159 int loop;
160
161 if (keyring->description) {
162 write_lock(&keyring_name_lock);
David Howells94efe722005-08-04 13:07:07 -0700163
164 if (keyring->type_data.link.next != NULL &&
165 !list_empty(&keyring->type_data.link))
166 list_del(&keyring->type_data.link);
167
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 write_unlock(&keyring_name_lock);
169 }
170
David Howells233e4732012-05-11 10:56:56 +0100171 klist = rcu_access_pointer(keyring->payload.subscriptions);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 if (klist) {
173 for (loop = klist->nkeys - 1; loop >= 0; loop--)
David Howells233e4732012-05-11 10:56:56 +0100174 key_put(rcu_access_pointer(klist->keys[loop]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 kfree(klist);
176 }
David Howellsa8b17ed2011-01-20 16:38:27 +0000177}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179/*
David Howells973c9f42011-01-20 16:38:33 +0000180 * Describe a keyring for /proc.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 */
182static void keyring_describe(const struct key *keyring, struct seq_file *m)
183{
184 struct keyring_list *klist;
185
wzt.wzt@gmail.comc8563472010-03-04 21:26:23 +0800186 if (keyring->description)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 seq_puts(m, keyring->description);
wzt.wzt@gmail.comc8563472010-03-04 21:26:23 +0800188 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 seq_puts(m, "[anon]");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
David Howells78b72802011-03-11 17:57:23 +0000191 if (key_is_instantiated(keyring)) {
192 rcu_read_lock();
193 klist = rcu_dereference(keyring->payload.subscriptions);
194 if (klist)
195 seq_printf(m, ": %u/%u", klist->nkeys, klist->maxkeys);
196 else
197 seq_puts(m, ": empty");
198 rcu_read_unlock();
199 }
David Howellsa8b17ed2011-01-20 16:38:27 +0000200}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202/*
David Howells973c9f42011-01-20 16:38:33 +0000203 * Read a list of key IDs from the keyring's contents in binary form
204 *
205 * The keyring's semaphore is read-locked by the caller.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 */
207static long keyring_read(const struct key *keyring,
208 char __user *buffer, size_t buflen)
209{
210 struct keyring_list *klist;
211 struct key *key;
212 size_t qty, tmp;
213 int loop, ret;
214
215 ret = 0;
David Howellsf0641cb2010-04-30 14:32:18 +0100216 klist = rcu_dereference_locked_keyring(keyring);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 if (klist) {
218 /* calculate how much data we could return */
219 qty = klist->nkeys * sizeof(key_serial_t);
220
221 if (buffer && buflen > 0) {
222 if (buflen > qty)
223 buflen = qty;
224
225 /* copy the IDs of the subscribed keys into the
226 * buffer */
227 ret = -EFAULT;
228
229 for (loop = 0; loop < klist->nkeys; loop++) {
David Howells233e4732012-05-11 10:56:56 +0100230 key = rcu_deref_link_locked(klist, loop,
231 keyring);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
233 tmp = sizeof(key_serial_t);
234 if (tmp > buflen)
235 tmp = buflen;
236
237 if (copy_to_user(buffer,
238 &key->serial,
239 tmp) != 0)
240 goto error;
241
242 buflen -= tmp;
243 if (buflen == 0)
244 break;
245 buffer += tmp;
246 }
247 }
248
249 ret = qty;
250 }
251
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700252error:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 return ret;
David Howellsa8b17ed2011-01-20 16:38:27 +0000254}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256/*
David Howells973c9f42011-01-20 16:38:33 +0000257 * Allocate a keyring and link into the destination keyring.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 */
Eric W. Biederman9a56c2d2012-02-08 07:53:04 -0800259struct key *keyring_alloc(const char *description, kuid_t uid, kgid_t gid,
David Howells96b5c8f2012-10-02 19:24:56 +0100260 const struct cred *cred, key_perm_t perm,
261 unsigned long flags, struct key *dest)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262{
263 struct key *keyring;
264 int ret;
265
266 keyring = key_alloc(&key_type_keyring, description,
David Howells96b5c8f2012-10-02 19:24:56 +0100267 uid, gid, cred, perm, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 if (!IS_ERR(keyring)) {
David Howells3e301482005-06-23 22:00:56 -0700269 ret = key_instantiate_and_link(keyring, NULL, 0, dest, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 if (ret < 0) {
271 key_put(keyring);
272 keyring = ERR_PTR(ret);
273 }
274 }
275
276 return keyring;
David Howellsa8b17ed2011-01-20 16:38:27 +0000277}
David Howellsf8aa23a2012-10-02 19:24:56 +0100278EXPORT_SYMBOL(keyring_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279
David Howells973c9f42011-01-20 16:38:33 +0000280/**
281 * keyring_search_aux - Search a keyring tree for a key matching some criteria
282 * @keyring_ref: A pointer to the keyring with possession indicator.
283 * @cred: The credentials to use for permissions checks.
284 * @type: The type of key to search for.
285 * @description: Parameter for @match.
286 * @match: Function to rule on whether or not a key is the one required.
David Howells78b72802011-03-11 17:57:23 +0000287 * @no_state_check: Don't check if a matching key is bad
David Howells973c9f42011-01-20 16:38:33 +0000288 *
289 * Search the supplied keyring tree for a key that matches the criteria given.
290 * The root keyring and any linked keyrings must grant Search permission to the
291 * caller to be searchable and keys can only be found if they too grant Search
292 * to the caller. The possession flag on the root keyring pointer controls use
293 * of the possessor bits in permissions checking of the entire tree. In
294 * addition, the LSM gets to forbid keyring searches and key matches.
295 *
296 * The search is performed as a breadth-then-depth search up to the prescribed
297 * limit (KEYRING_SEARCH_MAX_DEPTH).
298 *
299 * Keys are matched to the type provided and are then filtered by the match
300 * function, which is given the description to use in any way it sees fit. The
301 * match function may use any attributes of a key that it wishes to to
302 * determine the match. Normally the match function from the key type would be
303 * used.
304 *
305 * RCU is used to prevent the keyring key lists from disappearing without the
306 * need to take lots of locks.
307 *
308 * Returns a pointer to the found key and increments the key usage count if
309 * successful; -EAGAIN if no matching keys were found, or if expired or revoked
310 * keys were found; -ENOKEY if only negative keys were found; -ENOTDIR if the
311 * specified keyring wasn't a keyring.
312 *
313 * In the case of a successful return, the possession attribute from
314 * @keyring_ref is propagated to the returned key reference.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 */
David Howells664cceb2005-09-28 17:03:15 +0100316key_ref_t keyring_search_aux(key_ref_t keyring_ref,
David Howellsd84f4f92008-11-14 10:39:23 +1100317 const struct cred *cred,
David Howells664cceb2005-09-28 17:03:15 +0100318 struct key_type *type,
319 const void *description,
David Howells78b72802011-03-11 17:57:23 +0000320 key_match_func_t match,
321 bool no_state_check)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322{
323 struct {
David Howells31d5a792012-05-11 10:56:56 +0100324 /* Need a separate keylist pointer for RCU purposes */
325 struct key *keyring;
David Howells76d8aea2005-06-23 22:00:49 -0700326 struct keyring_list *keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 int kix;
328 } stack[KEYRING_SEARCH_MAX_DEPTH];
329
330 struct keyring_list *keylist;
331 struct timespec now;
Kevin Coffmandceba992008-04-29 01:01:22 -0700332 unsigned long possessed, kflags;
David Howells664cceb2005-09-28 17:03:15 +0100333 struct key *keyring, *key;
334 key_ref_t key_ref;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 long err;
David Howellsefde8b62012-01-17 20:39:40 +0000336 int sp, nkeys, kix;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
David Howells664cceb2005-09-28 17:03:15 +0100338 keyring = key_ref_to_ptr(keyring_ref);
339 possessed = is_key_possessed(keyring_ref);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 key_check(keyring);
341
342 /* top keyring must have search permission to begin the search */
Chihau Chau512ea3b2010-03-08 20:11:34 -0300343 err = key_task_permission(keyring_ref, cred, KEY_SEARCH);
David Howells29db9192005-10-30 15:02:44 -0800344 if (err < 0) {
345 key_ref = ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 goto error;
David Howells29db9192005-10-30 15:02:44 -0800347 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
David Howells664cceb2005-09-28 17:03:15 +0100349 key_ref = ERR_PTR(-ENOTDIR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 if (keyring->type != &key_type_keyring)
351 goto error;
352
David Howells664cceb2005-09-28 17:03:15 +0100353 rcu_read_lock();
354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 now = current_kernel_time();
356 err = -EAGAIN;
357 sp = 0;
358
Kevin Coffmandceba992008-04-29 01:01:22 -0700359 /* firstly we should check to see if this top-level keyring is what we
360 * are looking for */
361 key_ref = ERR_PTR(-EAGAIN);
362 kflags = keyring->flags;
363 if (keyring->type == type && match(keyring, description)) {
364 key = keyring;
David Howells78b72802011-03-11 17:57:23 +0000365 if (no_state_check)
366 goto found;
Kevin Coffmandceba992008-04-29 01:01:22 -0700367
368 /* check it isn't negative and hasn't expired or been
369 * revoked */
370 if (kflags & (1 << KEY_FLAG_REVOKED))
371 goto error_2;
372 if (key->expiry && now.tv_sec >= key->expiry)
373 goto error_2;
David Howellsfdd1b942011-03-07 15:06:09 +0000374 key_ref = ERR_PTR(key->type_data.reject_error);
Kevin Coffmandceba992008-04-29 01:01:22 -0700375 if (kflags & (1 << KEY_FLAG_NEGATIVE))
376 goto error_2;
377 goto found;
378 }
379
380 /* otherwise, the top keyring must not be revoked, expired, or
381 * negatively instantiated if we are to search it */
382 key_ref = ERR_PTR(-EAGAIN);
David Howellsfd758152012-05-11 10:56:56 +0100383 if (kflags & ((1 << KEY_FLAG_INVALIDATED) |
384 (1 << KEY_FLAG_REVOKED) |
385 (1 << KEY_FLAG_NEGATIVE)) ||
Kevin Coffmandceba992008-04-29 01:01:22 -0700386 (keyring->expiry && now.tv_sec >= keyring->expiry))
387 goto error_2;
388
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 /* start processing a new keyring */
David Howells664cceb2005-09-28 17:03:15 +0100390descend:
David Howellsfd758152012-05-11 10:56:56 +0100391 kflags = keyring->flags;
392 if (kflags & ((1 << KEY_FLAG_INVALIDATED) |
393 (1 << KEY_FLAG_REVOKED)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 goto not_this_keyring;
395
David Howells76d8aea2005-06-23 22:00:49 -0700396 keylist = rcu_dereference(keyring->payload.subscriptions);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 if (!keylist)
398 goto not_this_keyring;
399
400 /* iterate through the keys in this keyring first */
David Howellsefde8b62012-01-17 20:39:40 +0000401 nkeys = keylist->nkeys;
402 smp_rmb();
403 for (kix = 0; kix < nkeys; kix++) {
David Howells233e4732012-05-11 10:56:56 +0100404 key = rcu_dereference(keylist->keys[kix]);
Kevin Coffmandceba992008-04-29 01:01:22 -0700405 kflags = key->flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
407 /* ignore keys not of this type */
408 if (key->type != type)
409 continue;
410
David Howellsfd758152012-05-11 10:56:56 +0100411 /* skip invalidated, revoked and expired keys */
David Howells78b72802011-03-11 17:57:23 +0000412 if (!no_state_check) {
David Howellsfd758152012-05-11 10:56:56 +0100413 if (kflags & ((1 << KEY_FLAG_INVALIDATED) |
414 (1 << KEY_FLAG_REVOKED)))
David Howells78b72802011-03-11 17:57:23 +0000415 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
David Howells78b72802011-03-11 17:57:23 +0000417 if (key->expiry && now.tv_sec >= key->expiry)
418 continue;
419 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
421 /* keys that don't match */
422 if (!match(key, description))
423 continue;
424
425 /* key must have search permissions */
David Howells29db9192005-10-30 15:02:44 -0800426 if (key_task_permission(make_key_ref(key, possessed),
David Howellsd84f4f92008-11-14 10:39:23 +1100427 cred, KEY_SEARCH) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 continue;
429
David Howells78b72802011-03-11 17:57:23 +0000430 if (no_state_check)
431 goto found;
432
Kevin Coffmandceba992008-04-29 01:01:22 -0700433 /* we set a different error code if we pass a negative key */
434 if (kflags & (1 << KEY_FLAG_NEGATIVE)) {
David Howellsfdd1b942011-03-07 15:06:09 +0000435 err = key->type_data.reject_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 continue;
437 }
438
439 goto found;
440 }
441
442 /* search through the keyrings nested in this one */
443 kix = 0;
David Howells664cceb2005-09-28 17:03:15 +0100444ascend:
David Howellsefde8b62012-01-17 20:39:40 +0000445 nkeys = keylist->nkeys;
446 smp_rmb();
447 for (; kix < nkeys; kix++) {
David Howells233e4732012-05-11 10:56:56 +0100448 key = rcu_dereference(keylist->keys[kix]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 if (key->type != &key_type_keyring)
David Howells76d8aea2005-06-23 22:00:49 -0700450 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
452 /* recursively search nested keyrings
453 * - only search keyrings for which we have search permission
454 */
455 if (sp >= KEYRING_SEARCH_MAX_DEPTH)
David Howells76d8aea2005-06-23 22:00:49 -0700456 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457
David Howells0f6ed7c2005-11-07 00:59:30 -0800458 if (key_task_permission(make_key_ref(key, possessed),
David Howellsd84f4f92008-11-14 10:39:23 +1100459 cred, KEY_SEARCH) < 0)
David Howells76d8aea2005-06-23 22:00:49 -0700460 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461
462 /* stack the current position */
David Howells31d5a792012-05-11 10:56:56 +0100463 stack[sp].keyring = keyring;
David Howells76d8aea2005-06-23 22:00:49 -0700464 stack[sp].keylist = keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 stack[sp].kix = kix;
466 sp++;
467
468 /* begin again with the new keyring */
469 keyring = key;
470 goto descend;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 }
472
473 /* the keyring we're looking at was disqualified or didn't contain a
474 * matching key */
David Howells664cceb2005-09-28 17:03:15 +0100475not_this_keyring:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 if (sp > 0) {
477 /* resume the processing of a keyring higher up in the tree */
478 sp--;
David Howells31d5a792012-05-11 10:56:56 +0100479 keyring = stack[sp].keyring;
David Howells76d8aea2005-06-23 22:00:49 -0700480 keylist = stack[sp].keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 kix = stack[sp].kix + 1;
482 goto ascend;
483 }
484
David Howells664cceb2005-09-28 17:03:15 +0100485 key_ref = ERR_PTR(err);
486 goto error_2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
488 /* we found a viable match */
David Howells664cceb2005-09-28 17:03:15 +0100489found:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 atomic_inc(&key->usage);
David Howells31d5a792012-05-11 10:56:56 +0100491 key->last_used_at = now.tv_sec;
492 keyring->last_used_at = now.tv_sec;
493 while (sp > 0)
494 stack[--sp].keyring->last_used_at = now.tv_sec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 key_check(key);
David Howells664cceb2005-09-28 17:03:15 +0100496 key_ref = make_key_ref(key, possessed);
497error_2:
David Howells76d8aea2005-06-23 22:00:49 -0700498 rcu_read_unlock();
David Howells664cceb2005-09-28 17:03:15 +0100499error:
500 return key_ref;
David Howellsa8b17ed2011-01-20 16:38:27 +0000501}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
David Howells973c9f42011-01-20 16:38:33 +0000503/**
504 * keyring_search - Search the supplied keyring tree for a matching key
505 * @keyring: The root of the keyring tree to be searched.
506 * @type: The type of keyring we want to find.
507 * @description: The name of the keyring we want to find.
508 *
509 * As keyring_search_aux() above, but using the current task's credentials and
510 * type's default matching function.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 */
David Howells664cceb2005-09-28 17:03:15 +0100512key_ref_t keyring_search(key_ref_t keyring,
513 struct key_type *type,
514 const char *description)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515{
David Howells3e301482005-06-23 22:00:56 -0700516 if (!type->match)
517 return ERR_PTR(-ENOKEY);
518
David Howellsd84f4f92008-11-14 10:39:23 +1100519 return keyring_search_aux(keyring, current->cred,
David Howells78b72802011-03-11 17:57:23 +0000520 type, description, type->match, false);
David Howellsa8b17ed2011-01-20 16:38:27 +0000521}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522EXPORT_SYMBOL(keyring_search);
523
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524/*
David Howells973c9f42011-01-20 16:38:33 +0000525 * Search the given keyring only (no recursion).
526 *
527 * The caller must guarantee that the keyring is a keyring and that the
528 * permission is granted to search the keyring as no check is made here.
529 *
530 * RCU is used to make it unnecessary to lock the keyring key list here.
531 *
532 * Returns a pointer to the found key with usage count incremented if
533 * successful and returns -ENOKEY if not found. Revoked keys and keys not
534 * providing the requested permission are skipped over.
535 *
536 * If successful, the possession indicator is propagated from the keyring ref
537 * to the returned key reference.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 */
David Howells664cceb2005-09-28 17:03:15 +0100539key_ref_t __keyring_search_one(key_ref_t keyring_ref,
540 const struct key_type *ktype,
541 const char *description,
542 key_perm_t perm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543{
544 struct keyring_list *klist;
David Howells664cceb2005-09-28 17:03:15 +0100545 unsigned long possessed;
546 struct key *keyring, *key;
David Howellsefde8b62012-01-17 20:39:40 +0000547 int nkeys, loop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
David Howells664cceb2005-09-28 17:03:15 +0100549 keyring = key_ref_to_ptr(keyring_ref);
550 possessed = is_key_possessed(keyring_ref);
551
David Howells76d8aea2005-06-23 22:00:49 -0700552 rcu_read_lock();
553
554 klist = rcu_dereference(keyring->payload.subscriptions);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 if (klist) {
David Howellsefde8b62012-01-17 20:39:40 +0000556 nkeys = klist->nkeys;
557 smp_rmb();
558 for (loop = 0; loop < nkeys ; loop++) {
David Howells233e4732012-05-11 10:56:56 +0100559 key = rcu_dereference(klist->keys[loop]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 if (key->type == ktype &&
David Howells3e301482005-06-23 22:00:56 -0700561 (!key->type->match ||
562 key->type->match(key, description)) &&
David Howells664cceb2005-09-28 17:03:15 +0100563 key_permission(make_key_ref(key, possessed),
David Howellsdb1d1d52005-12-01 00:51:18 -0800564 perm) == 0 &&
David Howellsfd758152012-05-11 10:56:56 +0100565 !(key->flags & ((1 << KEY_FLAG_INVALIDATED) |
566 (1 << KEY_FLAG_REVOKED)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 )
568 goto found;
569 }
570 }
571
David Howells664cceb2005-09-28 17:03:15 +0100572 rcu_read_unlock();
573 return ERR_PTR(-ENOKEY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700575found:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 atomic_inc(&key->usage);
David Howells31d5a792012-05-11 10:56:56 +0100577 keyring->last_used_at = key->last_used_at =
578 current_kernel_time().tv_sec;
David Howells76d8aea2005-06-23 22:00:49 -0700579 rcu_read_unlock();
David Howells664cceb2005-09-28 17:03:15 +0100580 return make_key_ref(key, possessed);
David Howellsa8b17ed2011-01-20 16:38:27 +0000581}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583/*
David Howells973c9f42011-01-20 16:38:33 +0000584 * Find a keyring with the specified name.
585 *
586 * All named keyrings in the current user namespace are searched, provided they
587 * grant Search permission directly to the caller (unless this check is
588 * skipped). Keyrings whose usage points have reached zero or who have been
589 * revoked are skipped.
590 *
591 * Returns a pointer to the keyring with the keyring's refcount having being
592 * incremented on success. -ENOKEY is returned if a key could not be found.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 */
David Howells69664cf2008-04-29 01:01:31 -0700594struct key *find_keyring_by_name(const char *name, bool skip_perm_check)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595{
596 struct key *keyring;
597 int bucket;
598
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 if (!name)
Toshiyuki Okajimacea7daa2010-04-30 14:32:13 +0100600 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
602 bucket = keyring_hash(name);
603
604 read_lock(&keyring_name_lock);
605
606 if (keyring_name_hash[bucket].next) {
607 /* search this hash bucket for a keyring with a matching name
608 * that's readable and that hasn't been revoked */
609 list_for_each_entry(keyring,
610 &keyring_name_hash[bucket],
611 type_data.link
612 ) {
Eric W. Biederman9a56c2d2012-02-08 07:53:04 -0800613 if (!kuid_has_mapping(current_user_ns(), keyring->user->uid))
Serge E. Hallyn2ea190d2009-02-26 18:27:55 -0600614 continue;
615
David Howells76d8aea2005-06-23 22:00:49 -0700616 if (test_bit(KEY_FLAG_REVOKED, &keyring->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 continue;
618
619 if (strcmp(keyring->description, name) != 0)
620 continue;
621
David Howells69664cf2008-04-29 01:01:31 -0700622 if (!skip_perm_check &&
623 key_permission(make_key_ref(keyring, 0),
David Howells0f6ed7c2005-11-07 00:59:30 -0800624 KEY_SEARCH) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 continue;
626
Toshiyuki Okajimacea7daa2010-04-30 14:32:13 +0100627 /* we've got a match but we might end up racing with
628 * key_cleanup() if the keyring is currently 'dead'
629 * (ie. it has a zero usage count) */
630 if (!atomic_inc_not_zero(&keyring->usage))
631 continue;
David Howells31d5a792012-05-11 10:56:56 +0100632 keyring->last_used_at = current_kernel_time().tv_sec;
Toshiyuki Okajimacea7daa2010-04-30 14:32:13 +0100633 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 }
635 }
636
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 keyring = ERR_PTR(-ENOKEY);
Toshiyuki Okajimacea7daa2010-04-30 14:32:13 +0100638out:
639 read_unlock(&keyring_name_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 return keyring;
David Howellsa8b17ed2011-01-20 16:38:27 +0000641}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643/*
David Howells973c9f42011-01-20 16:38:33 +0000644 * See if a cycle will will be created by inserting acyclic tree B in acyclic
645 * tree A at the topmost level (ie: as a direct child of A).
646 *
647 * Since we are adding B to A at the top level, checking for cycles should just
648 * be a matter of seeing if node A is somewhere in tree B.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 */
650static int keyring_detect_cycle(struct key *A, struct key *B)
651{
652 struct {
David Howells76d8aea2005-06-23 22:00:49 -0700653 struct keyring_list *keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 int kix;
655 } stack[KEYRING_SEARCH_MAX_DEPTH];
656
657 struct keyring_list *keylist;
658 struct key *subtree, *key;
David Howellsefde8b62012-01-17 20:39:40 +0000659 int sp, nkeys, kix, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660
David Howells76d8aea2005-06-23 22:00:49 -0700661 rcu_read_lock();
662
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 ret = -EDEADLK;
664 if (A == B)
David Howells76d8aea2005-06-23 22:00:49 -0700665 goto cycle_detected;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666
667 subtree = B;
668 sp = 0;
669
670 /* start processing a new keyring */
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700671descend:
David Howells76d8aea2005-06-23 22:00:49 -0700672 if (test_bit(KEY_FLAG_REVOKED, &subtree->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 goto not_this_keyring;
674
David Howells76d8aea2005-06-23 22:00:49 -0700675 keylist = rcu_dereference(subtree->payload.subscriptions);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 if (!keylist)
677 goto not_this_keyring;
678 kix = 0;
679
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700680ascend:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 /* iterate through the remaining keys in this keyring */
David Howellsefde8b62012-01-17 20:39:40 +0000682 nkeys = keylist->nkeys;
683 smp_rmb();
684 for (; kix < nkeys; kix++) {
David Howells233e4732012-05-11 10:56:56 +0100685 key = rcu_dereference(keylist->keys[kix]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
687 if (key == A)
688 goto cycle_detected;
689
690 /* recursively check nested keyrings */
691 if (key->type == &key_type_keyring) {
692 if (sp >= KEYRING_SEARCH_MAX_DEPTH)
693 goto too_deep;
694
695 /* stack the current position */
David Howells76d8aea2005-06-23 22:00:49 -0700696 stack[sp].keylist = keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 stack[sp].kix = kix;
698 sp++;
699
700 /* begin again with the new keyring */
701 subtree = key;
702 goto descend;
703 }
704 }
705
706 /* the keyring we're looking at was disqualified or didn't contain a
707 * matching key */
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700708not_this_keyring:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 if (sp > 0) {
710 /* resume the checking of a keyring higher up in the tree */
711 sp--;
David Howells76d8aea2005-06-23 22:00:49 -0700712 keylist = stack[sp].keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 kix = stack[sp].kix + 1;
714 goto ascend;
715 }
716
717 ret = 0; /* no cycles detected */
718
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700719error:
David Howells76d8aea2005-06-23 22:00:49 -0700720 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 return ret;
722
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700723too_deep:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 ret = -ELOOP;
David Howells76d8aea2005-06-23 22:00:49 -0700725 goto error;
726
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700727cycle_detected:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 ret = -EDEADLK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 goto error;
David Howellsa8b17ed2011-01-20 16:38:27 +0000730}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731
David Howells76d8aea2005-06-23 22:00:49 -0700732/*
David Howells973c9f42011-01-20 16:38:33 +0000733 * Dispose of a keyring list after the RCU grace period, freeing the unlinked
David Howellscab8eb52006-01-08 01:02:45 -0800734 * key
735 */
736static void keyring_unlink_rcu_disposal(struct rcu_head *rcu)
737{
738 struct keyring_list *klist =
739 container_of(rcu, struct keyring_list, rcu);
740
Alexey Dobriyan4be929b2010-05-24 14:33:03 -0700741 if (klist->delkey != USHRT_MAX)
David Howells233e4732012-05-11 10:56:56 +0100742 key_put(rcu_access_pointer(klist->keys[klist->delkey]));
David Howellscab8eb52006-01-08 01:02:45 -0800743 kfree(klist);
David Howellsf70e2e02010-04-30 14:32:39 +0100744}
David Howellscab8eb52006-01-08 01:02:45 -0800745
David Howellscab8eb52006-01-08 01:02:45 -0800746/*
David Howells973c9f42011-01-20 16:38:33 +0000747 * Preallocate memory so that a key can be linked into to a keyring.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 */
David Howellsf70e2e02010-04-30 14:32:39 +0100749int __key_link_begin(struct key *keyring, const struct key_type *type,
David Howellsceb73c12011-01-25 16:34:28 +0000750 const char *description, unsigned long *_prealloc)
David Howellsf70e2e02010-04-30 14:32:39 +0100751 __acquires(&keyring->sem)
David Howells423b97882012-05-21 12:32:13 +0100752 __acquires(&keyring_serialise_link_sem)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753{
754 struct keyring_list *klist, *nklist;
David Howellsceb73c12011-01-25 16:34:28 +0000755 unsigned long prealloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 unsigned max;
David Howells31d5a792012-05-11 10:56:56 +0100757 time_t lowest_lru;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 size_t size;
David Howells31d5a792012-05-11 10:56:56 +0100759 int loop, lru, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
David Howellsf70e2e02010-04-30 14:32:39 +0100761 kenter("%d,%s,%s,", key_serial(keyring), type->name, description);
762
763 if (keyring->type != &key_type_keyring)
764 return -ENOTDIR;
765
766 down_write(&keyring->sem);
767
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 ret = -EKEYREVOKED;
David Howells76d8aea2005-06-23 22:00:49 -0700769 if (test_bit(KEY_FLAG_REVOKED, &keyring->flags))
David Howellsf70e2e02010-04-30 14:32:39 +0100770 goto error_krsem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771
David Howellsf70e2e02010-04-30 14:32:39 +0100772 /* serialise link/link calls to prevent parallel calls causing a cycle
773 * when linking two keyring in opposite orders */
774 if (type == &key_type_keyring)
David Howells553d6032010-04-30 14:32:28 +0100775 down_write(&keyring_serialise_link_sem);
776
David Howellsf70e2e02010-04-30 14:32:39 +0100777 klist = rcu_dereference_locked_keyring(keyring);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
David Howellscab8eb52006-01-08 01:02:45 -0800779 /* see if there's a matching key we can displace */
David Howells31d5a792012-05-11 10:56:56 +0100780 lru = -1;
David Howellscab8eb52006-01-08 01:02:45 -0800781 if (klist && klist->nkeys > 0) {
David Howells31d5a792012-05-11 10:56:56 +0100782 lowest_lru = TIME_T_MAX;
David Howellscab8eb52006-01-08 01:02:45 -0800783 for (loop = klist->nkeys - 1; loop >= 0; loop--) {
David Howells233e4732012-05-11 10:56:56 +0100784 struct key *key = rcu_deref_link_locked(klist, loop,
785 keyring);
786 if (key->type == type &&
787 strcmp(key->description, description) == 0) {
788 /* Found a match - we'll replace the link with
789 * one to the new key. We record the slot
790 * position.
791 */
792 klist->delkey = loop;
793 prealloc = 0;
David Howellscab8eb52006-01-08 01:02:45 -0800794 goto done;
795 }
David Howells31d5a792012-05-11 10:56:56 +0100796 if (key->last_used_at < lowest_lru) {
797 lowest_lru = key->last_used_at;
798 lru = loop;
799 }
David Howellscab8eb52006-01-08 01:02:45 -0800800 }
801 }
802
David Howells31d5a792012-05-11 10:56:56 +0100803 /* If the keyring is full then do an LRU discard */
804 if (klist &&
805 klist->nkeys == klist->maxkeys &&
806 klist->maxkeys >= MAX_KEYRING_LINKS) {
807 kdebug("LRU discard %d\n", lru);
808 klist->delkey = lru;
809 prealloc = 0;
810 goto done;
811 }
812
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 /* check that we aren't going to overrun the user's quota */
814 ret = key_payload_reserve(keyring,
815 keyring->datalen + KEYQUOTA_LINK_BYTES);
816 if (ret < 0)
David Howellsf70e2e02010-04-30 14:32:39 +0100817 goto error_sem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 if (klist && klist->nkeys < klist->maxkeys) {
David Howellsf70e2e02010-04-30 14:32:39 +0100820 /* there's sufficient slack space to append directly */
David Howells233e4732012-05-11 10:56:56 +0100821 klist->delkey = klist->nkeys;
David Howellsceb73c12011-01-25 16:34:28 +0000822 prealloc = KEY_LINK_FIXQUOTA;
Chihau Chau512ea3b2010-03-08 20:11:34 -0300823 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 /* grow the key list */
825 max = 4;
David Howells31d5a792012-05-11 10:56:56 +0100826 if (klist) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 max += klist->maxkeys;
David Howells31d5a792012-05-11 10:56:56 +0100828 if (max > MAX_KEYRING_LINKS)
829 max = MAX_KEYRING_LINKS;
830 BUG_ON(max <= klist->maxkeys);
831 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
David Howellsa4014d82005-07-07 17:57:03 -0700833 size = sizeof(*klist) + sizeof(struct key *) * max;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
835 ret = -ENOMEM;
836 nklist = kmalloc(size, GFP_KERNEL);
837 if (!nklist)
David Howellsf70e2e02010-04-30 14:32:39 +0100838 goto error_quota;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
David Howellsf70e2e02010-04-30 14:32:39 +0100840 nklist->maxkeys = max;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 if (klist) {
David Howellsf70e2e02010-04-30 14:32:39 +0100842 memcpy(nklist->keys, klist->keys,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 sizeof(struct key *) * klist->nkeys);
David Howellsf70e2e02010-04-30 14:32:39 +0100844 nklist->delkey = klist->nkeys;
845 nklist->nkeys = klist->nkeys + 1;
Alexey Dobriyan4be929b2010-05-24 14:33:03 -0700846 klist->delkey = USHRT_MAX;
David Howellsf70e2e02010-04-30 14:32:39 +0100847 } else {
848 nklist->nkeys = 1;
849 nklist->delkey = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 }
851
852 /* add the key into the new space */
David Howells233e4732012-05-11 10:56:56 +0100853 RCU_INIT_POINTER(nklist->keys[nklist->delkey], NULL);
854 prealloc = (unsigned long)nklist | KEY_LINK_FIXQUOTA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 }
856
David Howellscab8eb52006-01-08 01:02:45 -0800857done:
David Howellsceb73c12011-01-25 16:34:28 +0000858 *_prealloc = prealloc;
David Howellsf70e2e02010-04-30 14:32:39 +0100859 kleave(" = 0");
860 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
David Howellsf70e2e02010-04-30 14:32:39 +0100862error_quota:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 /* undo the quota changes */
864 key_payload_reserve(keyring,
865 keyring->datalen - KEYQUOTA_LINK_BYTES);
David Howellsf70e2e02010-04-30 14:32:39 +0100866error_sem:
867 if (type == &key_type_keyring)
868 up_write(&keyring_serialise_link_sem);
869error_krsem:
870 up_write(&keyring->sem);
871 kleave(" = %d", ret);
872 return ret;
873}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874
David Howellsf70e2e02010-04-30 14:32:39 +0100875/*
David Howells973c9f42011-01-20 16:38:33 +0000876 * Check already instantiated keys aren't going to be a problem.
877 *
878 * The caller must have called __key_link_begin(). Don't need to call this for
879 * keys that were created since __key_link_begin() was called.
David Howellsf70e2e02010-04-30 14:32:39 +0100880 */
881int __key_link_check_live_key(struct key *keyring, struct key *key)
882{
883 if (key->type == &key_type_keyring)
884 /* check that we aren't going to create a cycle by linking one
885 * keyring to another */
886 return keyring_detect_cycle(keyring, key);
887 return 0;
888}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889
David Howellsf70e2e02010-04-30 14:32:39 +0100890/*
David Howells973c9f42011-01-20 16:38:33 +0000891 * Link a key into to a keyring.
892 *
893 * Must be called with __key_link_begin() having being called. Discards any
894 * already extant link to matching key if there is one, so that each keyring
895 * holds at most one link to any given key of a particular type+description
896 * combination.
David Howellsf70e2e02010-04-30 14:32:39 +0100897 */
898void __key_link(struct key *keyring, struct key *key,
David Howellsceb73c12011-01-25 16:34:28 +0000899 unsigned long *_prealloc)
David Howellsf70e2e02010-04-30 14:32:39 +0100900{
901 struct keyring_list *klist, *nklist;
David Howells233e4732012-05-11 10:56:56 +0100902 struct key *discard;
David Howellsf70e2e02010-04-30 14:32:39 +0100903
David Howellsceb73c12011-01-25 16:34:28 +0000904 nklist = (struct keyring_list *)(*_prealloc & ~KEY_LINK_FIXQUOTA);
905 *_prealloc = 0;
David Howellsf70e2e02010-04-30 14:32:39 +0100906
907 kenter("%d,%d,%p", keyring->serial, key->serial, nklist);
908
David Howells6d528b02011-08-22 14:08:51 +0100909 klist = rcu_dereference_locked_keyring(keyring);
David Howellsf70e2e02010-04-30 14:32:39 +0100910
911 atomic_inc(&key->usage);
David Howells31d5a792012-05-11 10:56:56 +0100912 keyring->last_used_at = key->last_used_at =
913 current_kernel_time().tv_sec;
David Howellsf70e2e02010-04-30 14:32:39 +0100914
915 /* there's a matching key we can displace or an empty slot in a newly
916 * allocated list we can fill */
917 if (nklist) {
David Howells233e4732012-05-11 10:56:56 +0100918 kdebug("reissue %hu/%hu/%hu",
David Howellsf70e2e02010-04-30 14:32:39 +0100919 nklist->delkey, nklist->nkeys, nklist->maxkeys);
920
David Howells233e4732012-05-11 10:56:56 +0100921 RCU_INIT_POINTER(nklist->keys[nklist->delkey], key);
David Howellsf70e2e02010-04-30 14:32:39 +0100922
923 rcu_assign_pointer(keyring->payload.subscriptions, nklist);
924
925 /* dispose of the old keyring list and, if there was one, the
926 * displaced key */
927 if (klist) {
928 kdebug("dispose %hu/%hu/%hu",
929 klist->delkey, klist->nkeys, klist->maxkeys);
930 call_rcu(&klist->rcu, keyring_unlink_rcu_disposal);
931 }
David Howells233e4732012-05-11 10:56:56 +0100932 } else if (klist->delkey < klist->nkeys) {
933 kdebug("replace %hu/%hu/%hu",
934 klist->delkey, klist->nkeys, klist->maxkeys);
935
936 discard = rcu_dereference_protected(
937 klist->keys[klist->delkey],
938 rwsem_is_locked(&keyring->sem));
939 rcu_assign_pointer(klist->keys[klist->delkey], key);
940 /* The garbage collector will take care of RCU
941 * synchronisation */
942 key_put(discard);
David Howellsf70e2e02010-04-30 14:32:39 +0100943 } else {
944 /* there's sufficient slack space to append directly */
David Howells233e4732012-05-11 10:56:56 +0100945 kdebug("append %hu/%hu/%hu",
946 klist->delkey, klist->nkeys, klist->maxkeys);
947
948 RCU_INIT_POINTER(klist->keys[klist->delkey], key);
David Howellsf70e2e02010-04-30 14:32:39 +0100949 smp_wmb();
950 klist->nkeys++;
951 }
952}
953
954/*
David Howells973c9f42011-01-20 16:38:33 +0000955 * Finish linking a key into to a keyring.
956 *
957 * Must be called with __key_link_begin() having being called.
David Howellsf70e2e02010-04-30 14:32:39 +0100958 */
959void __key_link_end(struct key *keyring, struct key_type *type,
David Howellsceb73c12011-01-25 16:34:28 +0000960 unsigned long prealloc)
David Howellsf70e2e02010-04-30 14:32:39 +0100961 __releases(&keyring->sem)
David Howells423b97882012-05-21 12:32:13 +0100962 __releases(&keyring_serialise_link_sem)
David Howellsf70e2e02010-04-30 14:32:39 +0100963{
964 BUG_ON(type == NULL);
965 BUG_ON(type->name == NULL);
David Howellsceb73c12011-01-25 16:34:28 +0000966 kenter("%d,%s,%lx", keyring->serial, type->name, prealloc);
David Howellsf70e2e02010-04-30 14:32:39 +0100967
968 if (type == &key_type_keyring)
969 up_write(&keyring_serialise_link_sem);
970
971 if (prealloc) {
David Howellsceb73c12011-01-25 16:34:28 +0000972 if (prealloc & KEY_LINK_FIXQUOTA)
973 key_payload_reserve(keyring,
974 keyring->datalen -
975 KEYQUOTA_LINK_BYTES);
976 kfree((struct keyring_list *)(prealloc & ~KEY_LINK_FIXQUOTA));
David Howellsf70e2e02010-04-30 14:32:39 +0100977 }
978 up_write(&keyring->sem);
979}
980
David Howells973c9f42011-01-20 16:38:33 +0000981/**
982 * key_link - Link a key to a keyring
983 * @keyring: The keyring to make the link in.
984 * @key: The key to link to.
985 *
986 * Make a link in a keyring to a key, such that the keyring holds a reference
987 * on that key and the key can potentially be found by searching that keyring.
988 *
989 * This function will write-lock the keyring's semaphore and will consume some
990 * of the user's key data quota to hold the link.
991 *
992 * Returns 0 if successful, -ENOTDIR if the keyring isn't a keyring,
993 * -EKEYREVOKED if the keyring has been revoked, -ENFILE if the keyring is
994 * full, -EDQUOT if there is insufficient key data quota remaining to add
995 * another link or -ENOMEM if there's insufficient memory.
996 *
997 * It is assumed that the caller has checked that it is permitted for a link to
998 * be made (the keyring should have Write permission and the key Link
999 * permission).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 */
1001int key_link(struct key *keyring, struct key *key)
1002{
David Howellsceb73c12011-01-25 16:34:28 +00001003 unsigned long prealloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 int ret;
1005
1006 key_check(keyring);
1007 key_check(key);
1008
David Howellsf70e2e02010-04-30 14:32:39 +01001009 ret = __key_link_begin(keyring, key->type, key->description, &prealloc);
1010 if (ret == 0) {
1011 ret = __key_link_check_live_key(keyring, key);
1012 if (ret == 0)
1013 __key_link(keyring, key, &prealloc);
1014 __key_link_end(keyring, key->type, prealloc);
1015 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016
1017 return ret;
David Howellsf70e2e02010-04-30 14:32:39 +01001018}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019EXPORT_SYMBOL(key_link);
1020
David Howells973c9f42011-01-20 16:38:33 +00001021/**
1022 * key_unlink - Unlink the first link to a key from a keyring.
1023 * @keyring: The keyring to remove the link from.
1024 * @key: The key the link is to.
1025 *
1026 * Remove a link from a keyring to a key.
1027 *
1028 * This function will write-lock the keyring's semaphore.
1029 *
1030 * Returns 0 if successful, -ENOTDIR if the keyring isn't a keyring, -ENOENT if
1031 * the key isn't linked to by the keyring or -ENOMEM if there's insufficient
1032 * memory.
1033 *
1034 * It is assumed that the caller has checked that it is permitted for a link to
1035 * be removed (the keyring should have Write permission; no permissions are
1036 * required on the key).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 */
1038int key_unlink(struct key *keyring, struct key *key)
1039{
David Howells76d8aea2005-06-23 22:00:49 -07001040 struct keyring_list *klist, *nklist;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 int loop, ret;
1042
1043 key_check(keyring);
1044 key_check(key);
1045
1046 ret = -ENOTDIR;
1047 if (keyring->type != &key_type_keyring)
1048 goto error;
1049
1050 down_write(&keyring->sem);
1051
David Howellsf0641cb2010-04-30 14:32:18 +01001052 klist = rcu_dereference_locked_keyring(keyring);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 if (klist) {
1054 /* search the keyring for the key */
1055 for (loop = 0; loop < klist->nkeys; loop++)
David Howells233e4732012-05-11 10:56:56 +01001056 if (rcu_access_pointer(klist->keys[loop]) == key)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 goto key_is_present;
1058 }
1059
1060 up_write(&keyring->sem);
1061 ret = -ENOENT;
1062 goto error;
1063
David Howells76d8aea2005-06-23 22:00:49 -07001064key_is_present:
1065 /* we need to copy the key list for RCU purposes */
David Howellsa4014d82005-07-07 17:57:03 -07001066 nklist = kmalloc(sizeof(*klist) +
1067 sizeof(struct key *) * klist->maxkeys,
David Howells76d8aea2005-06-23 22:00:49 -07001068 GFP_KERNEL);
1069 if (!nklist)
1070 goto nomem;
1071 nklist->maxkeys = klist->maxkeys;
1072 nklist->nkeys = klist->nkeys - 1;
1073
1074 if (loop > 0)
1075 memcpy(&nklist->keys[0],
1076 &klist->keys[0],
David Howellsa4014d82005-07-07 17:57:03 -07001077 loop * sizeof(struct key *));
David Howells76d8aea2005-06-23 22:00:49 -07001078
1079 if (loop < nklist->nkeys)
1080 memcpy(&nklist->keys[loop],
1081 &klist->keys[loop + 1],
David Howellsa4014d82005-07-07 17:57:03 -07001082 (nklist->nkeys - loop) * sizeof(struct key *));
David Howells76d8aea2005-06-23 22:00:49 -07001083
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 /* adjust the user's quota */
1085 key_payload_reserve(keyring,
1086 keyring->datalen - KEYQUOTA_LINK_BYTES);
1087
David Howells76d8aea2005-06-23 22:00:49 -07001088 rcu_assign_pointer(keyring->payload.subscriptions, nklist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089
1090 up_write(&keyring->sem);
David Howells76d8aea2005-06-23 22:00:49 -07001091
1092 /* schedule for later cleanup */
1093 klist->delkey = loop;
1094 call_rcu(&klist->rcu, keyring_unlink_rcu_disposal);
1095
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 ret = 0;
1097
David Howells76d8aea2005-06-23 22:00:49 -07001098error:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 return ret;
David Howells76d8aea2005-06-23 22:00:49 -07001100nomem:
1101 ret = -ENOMEM;
1102 up_write(&keyring->sem);
1103 goto error;
David Howellsa8b17ed2011-01-20 16:38:27 +00001104}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105EXPORT_SYMBOL(key_unlink);
1106
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107/*
David Howells973c9f42011-01-20 16:38:33 +00001108 * Dispose of a keyring list after the RCU grace period, releasing the keys it
1109 * links to.
David Howells76d8aea2005-06-23 22:00:49 -07001110 */
1111static void keyring_clear_rcu_disposal(struct rcu_head *rcu)
1112{
1113 struct keyring_list *klist;
1114 int loop;
1115
1116 klist = container_of(rcu, struct keyring_list, rcu);
1117
1118 for (loop = klist->nkeys - 1; loop >= 0; loop--)
David Howells233e4732012-05-11 10:56:56 +01001119 key_put(rcu_access_pointer(klist->keys[loop]));
David Howells76d8aea2005-06-23 22:00:49 -07001120
1121 kfree(klist);
David Howellsa8b17ed2011-01-20 16:38:27 +00001122}
David Howells76d8aea2005-06-23 22:00:49 -07001123
David Howells973c9f42011-01-20 16:38:33 +00001124/**
1125 * keyring_clear - Clear a keyring
1126 * @keyring: The keyring to clear.
1127 *
1128 * Clear the contents of the specified keyring.
1129 *
1130 * Returns 0 if successful or -ENOTDIR if the keyring isn't a keyring.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 */
1132int keyring_clear(struct key *keyring)
1133{
1134 struct keyring_list *klist;
David Howells76d8aea2005-06-23 22:00:49 -07001135 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136
1137 ret = -ENOTDIR;
1138 if (keyring->type == &key_type_keyring) {
1139 /* detach the pointer block with the locks held */
1140 down_write(&keyring->sem);
1141
David Howellsf0641cb2010-04-30 14:32:18 +01001142 klist = rcu_dereference_locked_keyring(keyring);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 if (klist) {
1144 /* adjust the quota */
1145 key_payload_reserve(keyring,
1146 sizeof(struct keyring_list));
1147
David Howells76d8aea2005-06-23 22:00:49 -07001148 rcu_assign_pointer(keyring->payload.subscriptions,
1149 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 }
1151
1152 up_write(&keyring->sem);
1153
1154 /* free the keys after the locks have been dropped */
David Howells76d8aea2005-06-23 22:00:49 -07001155 if (klist)
1156 call_rcu(&klist->rcu, keyring_clear_rcu_disposal);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157
1158 ret = 0;
1159 }
1160
1161 return ret;
David Howellsa8b17ed2011-01-20 16:38:27 +00001162}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163EXPORT_SYMBOL(keyring_clear);
David Howells31204ed2006-06-26 00:24:51 -07001164
David Howells31204ed2006-06-26 00:24:51 -07001165/*
David Howells973c9f42011-01-20 16:38:33 +00001166 * Dispose of the links from a revoked keyring.
1167 *
1168 * This is called with the key sem write-locked.
David Howells31204ed2006-06-26 00:24:51 -07001169 */
1170static void keyring_revoke(struct key *keyring)
1171{
David Howellsf0641cb2010-04-30 14:32:18 +01001172 struct keyring_list *klist;
1173
1174 klist = rcu_dereference_locked_keyring(keyring);
David Howells31204ed2006-06-26 00:24:51 -07001175
1176 /* adjust the quota */
1177 key_payload_reserve(keyring, 0);
1178
1179 if (klist) {
1180 rcu_assign_pointer(keyring->payload.subscriptions, NULL);
1181 call_rcu(&klist->rcu, keyring_clear_rcu_disposal);
1182 }
David Howellsa8b17ed2011-01-20 16:38:27 +00001183}
David Howells5d135442009-09-02 09:14:00 +01001184
1185/*
David Howells973c9f42011-01-20 16:38:33 +00001186 * Collect garbage from the contents of a keyring, replacing the old list with
1187 * a new one with the pointers all shuffled down.
1188 *
1189 * Dead keys are classed as oned that are flagged as being dead or are revoked,
1190 * expired or negative keys that were revoked or expired before the specified
1191 * limit.
David Howells5d135442009-09-02 09:14:00 +01001192 */
1193void keyring_gc(struct key *keyring, time_t limit)
1194{
1195 struct keyring_list *klist, *new;
1196 struct key *key;
1197 int loop, keep, max;
1198
David Howellsc08ef802009-09-14 17:26:13 +01001199 kenter("{%x,%s}", key_serial(keyring), keyring->description);
David Howells5d135442009-09-02 09:14:00 +01001200
1201 down_write(&keyring->sem);
1202
David Howellsf0641cb2010-04-30 14:32:18 +01001203 klist = rcu_dereference_locked_keyring(keyring);
David Howells5d135442009-09-02 09:14:00 +01001204 if (!klist)
David Howellsc08ef802009-09-14 17:26:13 +01001205 goto no_klist;
David Howells5d135442009-09-02 09:14:00 +01001206
1207 /* work out how many subscriptions we're keeping */
1208 keep = 0;
1209 for (loop = klist->nkeys - 1; loop >= 0; loop--)
David Howells233e4732012-05-11 10:56:56 +01001210 if (!key_is_dead(rcu_deref_link_locked(klist, loop, keyring),
1211 limit))
David Howells5d135442009-09-02 09:14:00 +01001212 keep++;
1213
1214 if (keep == klist->nkeys)
1215 goto just_return;
1216
1217 /* allocate a new keyring payload */
1218 max = roundup(keep, 4);
1219 new = kmalloc(sizeof(struct keyring_list) + max * sizeof(struct key *),
1220 GFP_KERNEL);
1221 if (!new)
David Howellsc08ef802009-09-14 17:26:13 +01001222 goto nomem;
David Howells5d135442009-09-02 09:14:00 +01001223 new->maxkeys = max;
1224 new->nkeys = 0;
1225 new->delkey = 0;
1226
1227 /* install the live keys
1228 * - must take care as expired keys may be updated back to life
1229 */
1230 keep = 0;
1231 for (loop = klist->nkeys - 1; loop >= 0; loop--) {
David Howells233e4732012-05-11 10:56:56 +01001232 key = rcu_deref_link_locked(klist, loop, keyring);
David Howells5d135442009-09-02 09:14:00 +01001233 if (!key_is_dead(key, limit)) {
1234 if (keep >= max)
1235 goto discard_new;
David Howells233e4732012-05-11 10:56:56 +01001236 RCU_INIT_POINTER(new->keys[keep++], key_get(key));
David Howells5d135442009-09-02 09:14:00 +01001237 }
1238 }
1239 new->nkeys = keep;
1240
1241 /* adjust the quota */
1242 key_payload_reserve(keyring,
1243 sizeof(struct keyring_list) +
1244 KEYQUOTA_LINK_BYTES * keep);
1245
1246 if (keep == 0) {
1247 rcu_assign_pointer(keyring->payload.subscriptions, NULL);
1248 kfree(new);
1249 } else {
1250 rcu_assign_pointer(keyring->payload.subscriptions, new);
1251 }
1252
1253 up_write(&keyring->sem);
1254
1255 call_rcu(&klist->rcu, keyring_clear_rcu_disposal);
1256 kleave(" [yes]");
1257 return;
1258
1259discard_new:
1260 new->nkeys = keep;
1261 keyring_clear_rcu_disposal(&new->rcu);
David Howellsc08ef802009-09-14 17:26:13 +01001262 up_write(&keyring->sem);
1263 kleave(" [discard]");
1264 return;
1265
David Howells5d135442009-09-02 09:14:00 +01001266just_return:
1267 up_write(&keyring->sem);
David Howellsc08ef802009-09-14 17:26:13 +01001268 kleave(" [no dead]");
1269 return;
1270
1271no_klist:
1272 up_write(&keyring->sem);
1273 kleave(" [no_klist]");
1274 return;
1275
1276nomem:
1277 up_write(&keyring->sem);
1278 kleave(" [oom]");
David Howells5d135442009-09-02 09:14:00 +01001279}