blob: a5f5c4b6edc5c521b9e65508fcd50310980fce15 [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,
69 const void *data, size_t datalen);
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,
124 const void *data, size_t datalen)
125{
126 int ret;
127
128 ret = -EINVAL;
129 if (datalen == 0) {
130 /* 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 Howellsd84f4f92008-11-14 10:39:23 +1100260 const struct cred *cred, unsigned long flags,
Michael LeMayd7200242006-06-22 14:47:17 -0700261 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 Howellsd84f4f92008-11-14 10:39:23 +1100267 uid, gid, cred,
David Howells29db9192005-10-30 15:02:44 -0800268 (KEY_POS_ALL & ~KEY_POS_SETATTR) | KEY_USR_ALL,
David Howells7e047ef2006-06-26 00:24:50 -0700269 flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
271 if (!IS_ERR(keyring)) {
David Howells3e301482005-06-23 22:00:56 -0700272 ret = key_instantiate_and_link(keyring, NULL, 0, dest, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 if (ret < 0) {
274 key_put(keyring);
275 keyring = ERR_PTR(ret);
276 }
277 }
278
279 return keyring;
David Howellsa8b17ed2011-01-20 16:38:27 +0000280}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
David Howells973c9f42011-01-20 16:38:33 +0000282/**
283 * keyring_search_aux - Search a keyring tree for a key matching some criteria
284 * @keyring_ref: A pointer to the keyring with possession indicator.
285 * @cred: The credentials to use for permissions checks.
286 * @type: The type of key to search for.
287 * @description: Parameter for @match.
288 * @match: Function to rule on whether or not a key is the one required.
David Howells78b72802011-03-11 17:57:23 +0000289 * @no_state_check: Don't check if a matching key is bad
David Howells973c9f42011-01-20 16:38:33 +0000290 *
291 * Search the supplied keyring tree for a key that matches the criteria given.
292 * The root keyring and any linked keyrings must grant Search permission to the
293 * caller to be searchable and keys can only be found if they too grant Search
294 * to the caller. The possession flag on the root keyring pointer controls use
295 * of the possessor bits in permissions checking of the entire tree. In
296 * addition, the LSM gets to forbid keyring searches and key matches.
297 *
298 * The search is performed as a breadth-then-depth search up to the prescribed
299 * limit (KEYRING_SEARCH_MAX_DEPTH).
300 *
301 * Keys are matched to the type provided and are then filtered by the match
302 * function, which is given the description to use in any way it sees fit. The
303 * match function may use any attributes of a key that it wishes to to
304 * determine the match. Normally the match function from the key type would be
305 * used.
306 *
307 * RCU is used to prevent the keyring key lists from disappearing without the
308 * need to take lots of locks.
309 *
310 * Returns a pointer to the found key and increments the key usage count if
311 * successful; -EAGAIN if no matching keys were found, or if expired or revoked
312 * keys were found; -ENOKEY if only negative keys were found; -ENOTDIR if the
313 * specified keyring wasn't a keyring.
314 *
315 * In the case of a successful return, the possession attribute from
316 * @keyring_ref is propagated to the returned key reference.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 */
David Howells664cceb2005-09-28 17:03:15 +0100318key_ref_t keyring_search_aux(key_ref_t keyring_ref,
David Howellsd84f4f92008-11-14 10:39:23 +1100319 const struct cred *cred,
David Howells664cceb2005-09-28 17:03:15 +0100320 struct key_type *type,
321 const void *description,
David Howells78b72802011-03-11 17:57:23 +0000322 key_match_func_t match,
323 bool no_state_check)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324{
325 struct {
David Howells31d5a792012-05-11 10:56:56 +0100326 /* Need a separate keylist pointer for RCU purposes */
327 struct key *keyring;
David Howells76d8aea2005-06-23 22:00:49 -0700328 struct keyring_list *keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 int kix;
330 } stack[KEYRING_SEARCH_MAX_DEPTH];
331
332 struct keyring_list *keylist;
333 struct timespec now;
Kevin Coffmandceba992008-04-29 01:01:22 -0700334 unsigned long possessed, kflags;
David Howells664cceb2005-09-28 17:03:15 +0100335 struct key *keyring, *key;
336 key_ref_t key_ref;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 long err;
David Howellsefde8b62012-01-17 20:39:40 +0000338 int sp, nkeys, kix;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
David Howells664cceb2005-09-28 17:03:15 +0100340 keyring = key_ref_to_ptr(keyring_ref);
341 possessed = is_key_possessed(keyring_ref);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 key_check(keyring);
343
344 /* top keyring must have search permission to begin the search */
Chihau Chau512ea3b2010-03-08 20:11:34 -0300345 err = key_task_permission(keyring_ref, cred, KEY_SEARCH);
David Howells29db9192005-10-30 15:02:44 -0800346 if (err < 0) {
347 key_ref = ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 goto error;
David Howells29db9192005-10-30 15:02:44 -0800349 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350
David Howells664cceb2005-09-28 17:03:15 +0100351 key_ref = ERR_PTR(-ENOTDIR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 if (keyring->type != &key_type_keyring)
353 goto error;
354
David Howells664cceb2005-09-28 17:03:15 +0100355 rcu_read_lock();
356
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 now = current_kernel_time();
358 err = -EAGAIN;
359 sp = 0;
360
Kevin Coffmandceba992008-04-29 01:01:22 -0700361 /* firstly we should check to see if this top-level keyring is what we
362 * are looking for */
363 key_ref = ERR_PTR(-EAGAIN);
364 kflags = keyring->flags;
365 if (keyring->type == type && match(keyring, description)) {
366 key = keyring;
David Howells78b72802011-03-11 17:57:23 +0000367 if (no_state_check)
368 goto found;
Kevin Coffmandceba992008-04-29 01:01:22 -0700369
370 /* check it isn't negative and hasn't expired or been
371 * revoked */
372 if (kflags & (1 << KEY_FLAG_REVOKED))
373 goto error_2;
374 if (key->expiry && now.tv_sec >= key->expiry)
375 goto error_2;
David Howellsfdd1b942011-03-07 15:06:09 +0000376 key_ref = ERR_PTR(key->type_data.reject_error);
Kevin Coffmandceba992008-04-29 01:01:22 -0700377 if (kflags & (1 << KEY_FLAG_NEGATIVE))
378 goto error_2;
379 goto found;
380 }
381
382 /* otherwise, the top keyring must not be revoked, expired, or
383 * negatively instantiated if we are to search it */
384 key_ref = ERR_PTR(-EAGAIN);
David Howellsfd758152012-05-11 10:56:56 +0100385 if (kflags & ((1 << KEY_FLAG_INVALIDATED) |
386 (1 << KEY_FLAG_REVOKED) |
387 (1 << KEY_FLAG_NEGATIVE)) ||
Kevin Coffmandceba992008-04-29 01:01:22 -0700388 (keyring->expiry && now.tv_sec >= keyring->expiry))
389 goto error_2;
390
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 /* start processing a new keyring */
David Howells664cceb2005-09-28 17:03:15 +0100392descend:
David Howellsfd758152012-05-11 10:56:56 +0100393 kflags = keyring->flags;
394 if (kflags & ((1 << KEY_FLAG_INVALIDATED) |
395 (1 << KEY_FLAG_REVOKED)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 goto not_this_keyring;
397
David Howells76d8aea2005-06-23 22:00:49 -0700398 keylist = rcu_dereference(keyring->payload.subscriptions);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 if (!keylist)
400 goto not_this_keyring;
401
402 /* iterate through the keys in this keyring first */
David Howellsefde8b62012-01-17 20:39:40 +0000403 nkeys = keylist->nkeys;
404 smp_rmb();
405 for (kix = 0; kix < nkeys; kix++) {
David Howells233e4732012-05-11 10:56:56 +0100406 key = rcu_dereference(keylist->keys[kix]);
Kevin Coffmandceba992008-04-29 01:01:22 -0700407 kflags = key->flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
409 /* ignore keys not of this type */
410 if (key->type != type)
411 continue;
412
David Howellsfd758152012-05-11 10:56:56 +0100413 /* skip invalidated, revoked and expired keys */
David Howells78b72802011-03-11 17:57:23 +0000414 if (!no_state_check) {
David Howellsfd758152012-05-11 10:56:56 +0100415 if (kflags & ((1 << KEY_FLAG_INVALIDATED) |
416 (1 << KEY_FLAG_REVOKED)))
David Howells78b72802011-03-11 17:57:23 +0000417 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
David Howells78b72802011-03-11 17:57:23 +0000419 if (key->expiry && now.tv_sec >= key->expiry)
420 continue;
421 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
423 /* keys that don't match */
424 if (!match(key, description))
425 continue;
426
427 /* key must have search permissions */
David Howells29db9192005-10-30 15:02:44 -0800428 if (key_task_permission(make_key_ref(key, possessed),
David Howellsd84f4f92008-11-14 10:39:23 +1100429 cred, KEY_SEARCH) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 continue;
431
David Howells78b72802011-03-11 17:57:23 +0000432 if (no_state_check)
433 goto found;
434
Kevin Coffmandceba992008-04-29 01:01:22 -0700435 /* we set a different error code if we pass a negative key */
436 if (kflags & (1 << KEY_FLAG_NEGATIVE)) {
David Howellsfdd1b942011-03-07 15:06:09 +0000437 err = key->type_data.reject_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 continue;
439 }
440
441 goto found;
442 }
443
444 /* search through the keyrings nested in this one */
445 kix = 0;
David Howells664cceb2005-09-28 17:03:15 +0100446ascend:
David Howellsefde8b62012-01-17 20:39:40 +0000447 nkeys = keylist->nkeys;
448 smp_rmb();
449 for (; kix < nkeys; kix++) {
David Howells233e4732012-05-11 10:56:56 +0100450 key = rcu_dereference(keylist->keys[kix]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 if (key->type != &key_type_keyring)
David Howells76d8aea2005-06-23 22:00:49 -0700452 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
454 /* recursively search nested keyrings
455 * - only search keyrings for which we have search permission
456 */
457 if (sp >= KEYRING_SEARCH_MAX_DEPTH)
David Howells76d8aea2005-06-23 22:00:49 -0700458 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
David Howells0f6ed7c2005-11-07 00:59:30 -0800460 if (key_task_permission(make_key_ref(key, possessed),
David Howellsd84f4f92008-11-14 10:39:23 +1100461 cred, KEY_SEARCH) < 0)
David Howells76d8aea2005-06-23 22:00:49 -0700462 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
464 /* stack the current position */
David Howells31d5a792012-05-11 10:56:56 +0100465 stack[sp].keyring = keyring;
David Howells76d8aea2005-06-23 22:00:49 -0700466 stack[sp].keylist = keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 stack[sp].kix = kix;
468 sp++;
469
470 /* begin again with the new keyring */
471 keyring = key;
472 goto descend;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 }
474
475 /* the keyring we're looking at was disqualified or didn't contain a
476 * matching key */
David Howells664cceb2005-09-28 17:03:15 +0100477not_this_keyring:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 if (sp > 0) {
479 /* resume the processing of a keyring higher up in the tree */
480 sp--;
David Howells31d5a792012-05-11 10:56:56 +0100481 keyring = stack[sp].keyring;
David Howells76d8aea2005-06-23 22:00:49 -0700482 keylist = stack[sp].keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 kix = stack[sp].kix + 1;
484 goto ascend;
485 }
486
David Howells664cceb2005-09-28 17:03:15 +0100487 key_ref = ERR_PTR(err);
488 goto error_2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
490 /* we found a viable match */
David Howells664cceb2005-09-28 17:03:15 +0100491found:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 atomic_inc(&key->usage);
David Howells31d5a792012-05-11 10:56:56 +0100493 key->last_used_at = now.tv_sec;
494 keyring->last_used_at = now.tv_sec;
495 while (sp > 0)
496 stack[--sp].keyring->last_used_at = now.tv_sec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 key_check(key);
David Howells664cceb2005-09-28 17:03:15 +0100498 key_ref = make_key_ref(key, possessed);
499error_2:
David Howells76d8aea2005-06-23 22:00:49 -0700500 rcu_read_unlock();
David Howells664cceb2005-09-28 17:03:15 +0100501error:
502 return key_ref;
David Howellsa8b17ed2011-01-20 16:38:27 +0000503}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
David Howells973c9f42011-01-20 16:38:33 +0000505/**
506 * keyring_search - Search the supplied keyring tree for a matching key
507 * @keyring: The root of the keyring tree to be searched.
508 * @type: The type of keyring we want to find.
509 * @description: The name of the keyring we want to find.
510 *
511 * As keyring_search_aux() above, but using the current task's credentials and
512 * type's default matching function.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 */
David Howells664cceb2005-09-28 17:03:15 +0100514key_ref_t keyring_search(key_ref_t keyring,
515 struct key_type *type,
516 const char *description)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517{
David Howells3e301482005-06-23 22:00:56 -0700518 if (!type->match)
519 return ERR_PTR(-ENOKEY);
520
David Howellsd84f4f92008-11-14 10:39:23 +1100521 return keyring_search_aux(keyring, current->cred,
David Howells78b72802011-03-11 17:57:23 +0000522 type, description, type->match, false);
David Howellsa8b17ed2011-01-20 16:38:27 +0000523}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524EXPORT_SYMBOL(keyring_search);
525
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526/*
David Howells973c9f42011-01-20 16:38:33 +0000527 * Search the given keyring only (no recursion).
528 *
529 * The caller must guarantee that the keyring is a keyring and that the
530 * permission is granted to search the keyring as no check is made here.
531 *
532 * RCU is used to make it unnecessary to lock the keyring key list here.
533 *
534 * Returns a pointer to the found key with usage count incremented if
535 * successful and returns -ENOKEY if not found. Revoked keys and keys not
536 * providing the requested permission are skipped over.
537 *
538 * If successful, the possession indicator is propagated from the keyring ref
539 * to the returned key reference.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 */
David Howells664cceb2005-09-28 17:03:15 +0100541key_ref_t __keyring_search_one(key_ref_t keyring_ref,
542 const struct key_type *ktype,
543 const char *description,
544 key_perm_t perm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545{
546 struct keyring_list *klist;
David Howells664cceb2005-09-28 17:03:15 +0100547 unsigned long possessed;
548 struct key *keyring, *key;
David Howellsefde8b62012-01-17 20:39:40 +0000549 int nkeys, loop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550
David Howells664cceb2005-09-28 17:03:15 +0100551 keyring = key_ref_to_ptr(keyring_ref);
552 possessed = is_key_possessed(keyring_ref);
553
David Howells76d8aea2005-06-23 22:00:49 -0700554 rcu_read_lock();
555
556 klist = rcu_dereference(keyring->payload.subscriptions);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 if (klist) {
David Howellsefde8b62012-01-17 20:39:40 +0000558 nkeys = klist->nkeys;
559 smp_rmb();
560 for (loop = 0; loop < nkeys ; loop++) {
David Howells233e4732012-05-11 10:56:56 +0100561 key = rcu_dereference(klist->keys[loop]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 if (key->type == ktype &&
David Howells3e301482005-06-23 22:00:56 -0700563 (!key->type->match ||
564 key->type->match(key, description)) &&
David Howells664cceb2005-09-28 17:03:15 +0100565 key_permission(make_key_ref(key, possessed),
David Howellsdb1d1d52005-12-01 00:51:18 -0800566 perm) == 0 &&
David Howellsfd758152012-05-11 10:56:56 +0100567 !(key->flags & ((1 << KEY_FLAG_INVALIDATED) |
568 (1 << KEY_FLAG_REVOKED)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 )
570 goto found;
571 }
572 }
573
David Howells664cceb2005-09-28 17:03:15 +0100574 rcu_read_unlock();
575 return ERR_PTR(-ENOKEY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700577found:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 atomic_inc(&key->usage);
David Howells31d5a792012-05-11 10:56:56 +0100579 keyring->last_used_at = key->last_used_at =
580 current_kernel_time().tv_sec;
David Howells76d8aea2005-06-23 22:00:49 -0700581 rcu_read_unlock();
David Howells664cceb2005-09-28 17:03:15 +0100582 return make_key_ref(key, possessed);
David Howellsa8b17ed2011-01-20 16:38:27 +0000583}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585/*
David Howells973c9f42011-01-20 16:38:33 +0000586 * Find a keyring with the specified name.
587 *
588 * All named keyrings in the current user namespace are searched, provided they
589 * grant Search permission directly to the caller (unless this check is
590 * skipped). Keyrings whose usage points have reached zero or who have been
591 * revoked are skipped.
592 *
593 * Returns a pointer to the keyring with the keyring's refcount having being
594 * incremented on success. -ENOKEY is returned if a key could not be found.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 */
David Howells69664cf2008-04-29 01:01:31 -0700596struct key *find_keyring_by_name(const char *name, bool skip_perm_check)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597{
598 struct key *keyring;
599 int bucket;
600
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 if (!name)
Toshiyuki Okajimacea7daa2010-04-30 14:32:13 +0100602 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603
604 bucket = keyring_hash(name);
605
606 read_lock(&keyring_name_lock);
607
608 if (keyring_name_hash[bucket].next) {
609 /* search this hash bucket for a keyring with a matching name
610 * that's readable and that hasn't been revoked */
611 list_for_each_entry(keyring,
612 &keyring_name_hash[bucket],
613 type_data.link
614 ) {
Eric W. Biederman9a56c2d2012-02-08 07:53:04 -0800615 if (!kuid_has_mapping(current_user_ns(), keyring->user->uid))
Serge E. Hallyn2ea190d2009-02-26 18:27:55 -0600616 continue;
617
David Howells76d8aea2005-06-23 22:00:49 -0700618 if (test_bit(KEY_FLAG_REVOKED, &keyring->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 continue;
620
621 if (strcmp(keyring->description, name) != 0)
622 continue;
623
David Howells69664cf2008-04-29 01:01:31 -0700624 if (!skip_perm_check &&
625 key_permission(make_key_ref(keyring, 0),
David Howells0f6ed7c2005-11-07 00:59:30 -0800626 KEY_SEARCH) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 continue;
628
Toshiyuki Okajimacea7daa2010-04-30 14:32:13 +0100629 /* we've got a match but we might end up racing with
630 * key_cleanup() if the keyring is currently 'dead'
631 * (ie. it has a zero usage count) */
632 if (!atomic_inc_not_zero(&keyring->usage))
633 continue;
David Howells31d5a792012-05-11 10:56:56 +0100634 keyring->last_used_at = current_kernel_time().tv_sec;
Toshiyuki Okajimacea7daa2010-04-30 14:32:13 +0100635 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 }
637 }
638
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 keyring = ERR_PTR(-ENOKEY);
Toshiyuki Okajimacea7daa2010-04-30 14:32:13 +0100640out:
641 read_unlock(&keyring_name_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 return keyring;
David Howellsa8b17ed2011-01-20 16:38:27 +0000643}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645/*
David Howells973c9f42011-01-20 16:38:33 +0000646 * See if a cycle will will be created by inserting acyclic tree B in acyclic
647 * tree A at the topmost level (ie: as a direct child of A).
648 *
649 * Since we are adding B to A at the top level, checking for cycles should just
650 * be a matter of seeing if node A is somewhere in tree B.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 */
652static int keyring_detect_cycle(struct key *A, struct key *B)
653{
654 struct {
David Howells76d8aea2005-06-23 22:00:49 -0700655 struct keyring_list *keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 int kix;
657 } stack[KEYRING_SEARCH_MAX_DEPTH];
658
659 struct keyring_list *keylist;
660 struct key *subtree, *key;
David Howellsefde8b62012-01-17 20:39:40 +0000661 int sp, nkeys, kix, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662
David Howells76d8aea2005-06-23 22:00:49 -0700663 rcu_read_lock();
664
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 ret = -EDEADLK;
666 if (A == B)
David Howells76d8aea2005-06-23 22:00:49 -0700667 goto cycle_detected;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668
669 subtree = B;
670 sp = 0;
671
672 /* start processing a new keyring */
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700673descend:
David Howells76d8aea2005-06-23 22:00:49 -0700674 if (test_bit(KEY_FLAG_REVOKED, &subtree->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 goto not_this_keyring;
676
David Howells76d8aea2005-06-23 22:00:49 -0700677 keylist = rcu_dereference(subtree->payload.subscriptions);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 if (!keylist)
679 goto not_this_keyring;
680 kix = 0;
681
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700682ascend:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 /* iterate through the remaining keys in this keyring */
David Howellsefde8b62012-01-17 20:39:40 +0000684 nkeys = keylist->nkeys;
685 smp_rmb();
686 for (; kix < nkeys; kix++) {
David Howells233e4732012-05-11 10:56:56 +0100687 key = rcu_dereference(keylist->keys[kix]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
689 if (key == A)
690 goto cycle_detected;
691
692 /* recursively check nested keyrings */
693 if (key->type == &key_type_keyring) {
694 if (sp >= KEYRING_SEARCH_MAX_DEPTH)
695 goto too_deep;
696
697 /* stack the current position */
David Howells76d8aea2005-06-23 22:00:49 -0700698 stack[sp].keylist = keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 stack[sp].kix = kix;
700 sp++;
701
702 /* begin again with the new keyring */
703 subtree = key;
704 goto descend;
705 }
706 }
707
708 /* the keyring we're looking at was disqualified or didn't contain a
709 * matching key */
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700710not_this_keyring:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 if (sp > 0) {
712 /* resume the checking of a keyring higher up in the tree */
713 sp--;
David Howells76d8aea2005-06-23 22:00:49 -0700714 keylist = stack[sp].keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 kix = stack[sp].kix + 1;
716 goto ascend;
717 }
718
719 ret = 0; /* no cycles detected */
720
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700721error:
David Howells76d8aea2005-06-23 22:00:49 -0700722 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 return ret;
724
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700725too_deep:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 ret = -ELOOP;
David Howells76d8aea2005-06-23 22:00:49 -0700727 goto error;
728
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700729cycle_detected:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 ret = -EDEADLK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 goto error;
David Howellsa8b17ed2011-01-20 16:38:27 +0000732}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733
David Howells76d8aea2005-06-23 22:00:49 -0700734/*
David Howells973c9f42011-01-20 16:38:33 +0000735 * Dispose of a keyring list after the RCU grace period, freeing the unlinked
David Howellscab8eb52006-01-08 01:02:45 -0800736 * key
737 */
738static void keyring_unlink_rcu_disposal(struct rcu_head *rcu)
739{
740 struct keyring_list *klist =
741 container_of(rcu, struct keyring_list, rcu);
742
Alexey Dobriyan4be929b2010-05-24 14:33:03 -0700743 if (klist->delkey != USHRT_MAX)
David Howells233e4732012-05-11 10:56:56 +0100744 key_put(rcu_access_pointer(klist->keys[klist->delkey]));
David Howellscab8eb52006-01-08 01:02:45 -0800745 kfree(klist);
David Howellsf70e2e02010-04-30 14:32:39 +0100746}
David Howellscab8eb52006-01-08 01:02:45 -0800747
David Howellscab8eb52006-01-08 01:02:45 -0800748/*
David Howells973c9f42011-01-20 16:38:33 +0000749 * Preallocate memory so that a key can be linked into to a keyring.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 */
David Howellsf70e2e02010-04-30 14:32:39 +0100751int __key_link_begin(struct key *keyring, const struct key_type *type,
David Howellsceb73c12011-01-25 16:34:28 +0000752 const char *description, unsigned long *_prealloc)
David Howellsf70e2e02010-04-30 14:32:39 +0100753 __acquires(&keyring->sem)
David Howells423b97882012-05-21 12:32:13 +0100754 __acquires(&keyring_serialise_link_sem)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755{
756 struct keyring_list *klist, *nklist;
David Howellsceb73c12011-01-25 16:34:28 +0000757 unsigned long prealloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 unsigned max;
David Howells31d5a792012-05-11 10:56:56 +0100759 time_t lowest_lru;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 size_t size;
David Howells31d5a792012-05-11 10:56:56 +0100761 int loop, lru, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762
David Howellsf70e2e02010-04-30 14:32:39 +0100763 kenter("%d,%s,%s,", key_serial(keyring), type->name, description);
764
765 if (keyring->type != &key_type_keyring)
766 return -ENOTDIR;
767
768 down_write(&keyring->sem);
769
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 ret = -EKEYREVOKED;
David Howells76d8aea2005-06-23 22:00:49 -0700771 if (test_bit(KEY_FLAG_REVOKED, &keyring->flags))
David Howellsf70e2e02010-04-30 14:32:39 +0100772 goto error_krsem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
David Howellsf70e2e02010-04-30 14:32:39 +0100774 /* serialise link/link calls to prevent parallel calls causing a cycle
775 * when linking two keyring in opposite orders */
776 if (type == &key_type_keyring)
David Howells553d6032010-04-30 14:32:28 +0100777 down_write(&keyring_serialise_link_sem);
778
David Howellsf70e2e02010-04-30 14:32:39 +0100779 klist = rcu_dereference_locked_keyring(keyring);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
David Howellscab8eb52006-01-08 01:02:45 -0800781 /* see if there's a matching key we can displace */
David Howells31d5a792012-05-11 10:56:56 +0100782 lru = -1;
David Howellscab8eb52006-01-08 01:02:45 -0800783 if (klist && klist->nkeys > 0) {
David Howells31d5a792012-05-11 10:56:56 +0100784 lowest_lru = TIME_T_MAX;
David Howellscab8eb52006-01-08 01:02:45 -0800785 for (loop = klist->nkeys - 1; loop >= 0; loop--) {
David Howells233e4732012-05-11 10:56:56 +0100786 struct key *key = rcu_deref_link_locked(klist, loop,
787 keyring);
788 if (key->type == type &&
789 strcmp(key->description, description) == 0) {
790 /* Found a match - we'll replace the link with
791 * one to the new key. We record the slot
792 * position.
793 */
794 klist->delkey = loop;
795 prealloc = 0;
David Howellscab8eb52006-01-08 01:02:45 -0800796 goto done;
797 }
David Howells31d5a792012-05-11 10:56:56 +0100798 if (key->last_used_at < lowest_lru) {
799 lowest_lru = key->last_used_at;
800 lru = loop;
801 }
David Howellscab8eb52006-01-08 01:02:45 -0800802 }
803 }
804
David Howells31d5a792012-05-11 10:56:56 +0100805 /* If the keyring is full then do an LRU discard */
806 if (klist &&
807 klist->nkeys == klist->maxkeys &&
808 klist->maxkeys >= MAX_KEYRING_LINKS) {
809 kdebug("LRU discard %d\n", lru);
810 klist->delkey = lru;
811 prealloc = 0;
812 goto done;
813 }
814
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 /* check that we aren't going to overrun the user's quota */
816 ret = key_payload_reserve(keyring,
817 keyring->datalen + KEYQUOTA_LINK_BYTES);
818 if (ret < 0)
David Howellsf70e2e02010-04-30 14:32:39 +0100819 goto error_sem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 if (klist && klist->nkeys < klist->maxkeys) {
David Howellsf70e2e02010-04-30 14:32:39 +0100822 /* there's sufficient slack space to append directly */
David Howells233e4732012-05-11 10:56:56 +0100823 klist->delkey = klist->nkeys;
David Howellsceb73c12011-01-25 16:34:28 +0000824 prealloc = KEY_LINK_FIXQUOTA;
Chihau Chau512ea3b2010-03-08 20:11:34 -0300825 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 /* grow the key list */
827 max = 4;
David Howells31d5a792012-05-11 10:56:56 +0100828 if (klist) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 max += klist->maxkeys;
David Howells31d5a792012-05-11 10:56:56 +0100830 if (max > MAX_KEYRING_LINKS)
831 max = MAX_KEYRING_LINKS;
832 BUG_ON(max <= klist->maxkeys);
833 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
David Howellsa4014d82005-07-07 17:57:03 -0700835 size = sizeof(*klist) + sizeof(struct key *) * max;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836
837 ret = -ENOMEM;
838 nklist = kmalloc(size, GFP_KERNEL);
839 if (!nklist)
David Howellsf70e2e02010-04-30 14:32:39 +0100840 goto error_quota;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841
David Howellsf70e2e02010-04-30 14:32:39 +0100842 nklist->maxkeys = max;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 if (klist) {
David Howellsf70e2e02010-04-30 14:32:39 +0100844 memcpy(nklist->keys, klist->keys,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 sizeof(struct key *) * klist->nkeys);
David Howellsf70e2e02010-04-30 14:32:39 +0100846 nklist->delkey = klist->nkeys;
847 nklist->nkeys = klist->nkeys + 1;
Alexey Dobriyan4be929b2010-05-24 14:33:03 -0700848 klist->delkey = USHRT_MAX;
David Howellsf70e2e02010-04-30 14:32:39 +0100849 } else {
850 nklist->nkeys = 1;
851 nklist->delkey = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 }
853
854 /* add the key into the new space */
David Howells233e4732012-05-11 10:56:56 +0100855 RCU_INIT_POINTER(nklist->keys[nklist->delkey], NULL);
856 prealloc = (unsigned long)nklist | KEY_LINK_FIXQUOTA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 }
858
David Howellscab8eb52006-01-08 01:02:45 -0800859done:
David Howellsceb73c12011-01-25 16:34:28 +0000860 *_prealloc = prealloc;
David Howellsf70e2e02010-04-30 14:32:39 +0100861 kleave(" = 0");
862 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863
David Howellsf70e2e02010-04-30 14:32:39 +0100864error_quota:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 /* undo the quota changes */
866 key_payload_reserve(keyring,
867 keyring->datalen - KEYQUOTA_LINK_BYTES);
David Howellsf70e2e02010-04-30 14:32:39 +0100868error_sem:
869 if (type == &key_type_keyring)
870 up_write(&keyring_serialise_link_sem);
871error_krsem:
872 up_write(&keyring->sem);
873 kleave(" = %d", ret);
874 return ret;
875}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876
David Howellsf70e2e02010-04-30 14:32:39 +0100877/*
David Howells973c9f42011-01-20 16:38:33 +0000878 * Check already instantiated keys aren't going to be a problem.
879 *
880 * The caller must have called __key_link_begin(). Don't need to call this for
881 * keys that were created since __key_link_begin() was called.
David Howellsf70e2e02010-04-30 14:32:39 +0100882 */
883int __key_link_check_live_key(struct key *keyring, struct key *key)
884{
885 if (key->type == &key_type_keyring)
886 /* check that we aren't going to create a cycle by linking one
887 * keyring to another */
888 return keyring_detect_cycle(keyring, key);
889 return 0;
890}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891
David Howellsf70e2e02010-04-30 14:32:39 +0100892/*
David Howells973c9f42011-01-20 16:38:33 +0000893 * Link a key into to a keyring.
894 *
895 * Must be called with __key_link_begin() having being called. Discards any
896 * already extant link to matching key if there is one, so that each keyring
897 * holds at most one link to any given key of a particular type+description
898 * combination.
David Howellsf70e2e02010-04-30 14:32:39 +0100899 */
900void __key_link(struct key *keyring, struct key *key,
David Howellsceb73c12011-01-25 16:34:28 +0000901 unsigned long *_prealloc)
David Howellsf70e2e02010-04-30 14:32:39 +0100902{
903 struct keyring_list *klist, *nklist;
David Howells233e4732012-05-11 10:56:56 +0100904 struct key *discard;
David Howellsf70e2e02010-04-30 14:32:39 +0100905
David Howellsceb73c12011-01-25 16:34:28 +0000906 nklist = (struct keyring_list *)(*_prealloc & ~KEY_LINK_FIXQUOTA);
907 *_prealloc = 0;
David Howellsf70e2e02010-04-30 14:32:39 +0100908
909 kenter("%d,%d,%p", keyring->serial, key->serial, nklist);
910
David Howells6d528b02011-08-22 14:08:51 +0100911 klist = rcu_dereference_locked_keyring(keyring);
David Howellsf70e2e02010-04-30 14:32:39 +0100912
913 atomic_inc(&key->usage);
David Howells31d5a792012-05-11 10:56:56 +0100914 keyring->last_used_at = key->last_used_at =
915 current_kernel_time().tv_sec;
David Howellsf70e2e02010-04-30 14:32:39 +0100916
917 /* there's a matching key we can displace or an empty slot in a newly
918 * allocated list we can fill */
919 if (nklist) {
David Howells233e4732012-05-11 10:56:56 +0100920 kdebug("reissue %hu/%hu/%hu",
David Howellsf70e2e02010-04-30 14:32:39 +0100921 nklist->delkey, nklist->nkeys, nklist->maxkeys);
922
David Howells233e4732012-05-11 10:56:56 +0100923 RCU_INIT_POINTER(nklist->keys[nklist->delkey], key);
David Howellsf70e2e02010-04-30 14:32:39 +0100924
925 rcu_assign_pointer(keyring->payload.subscriptions, nklist);
926
927 /* dispose of the old keyring list and, if there was one, the
928 * displaced key */
929 if (klist) {
930 kdebug("dispose %hu/%hu/%hu",
931 klist->delkey, klist->nkeys, klist->maxkeys);
932 call_rcu(&klist->rcu, keyring_unlink_rcu_disposal);
933 }
David Howells233e4732012-05-11 10:56:56 +0100934 } else if (klist->delkey < klist->nkeys) {
935 kdebug("replace %hu/%hu/%hu",
936 klist->delkey, klist->nkeys, klist->maxkeys);
937
938 discard = rcu_dereference_protected(
939 klist->keys[klist->delkey],
940 rwsem_is_locked(&keyring->sem));
941 rcu_assign_pointer(klist->keys[klist->delkey], key);
942 /* The garbage collector will take care of RCU
943 * synchronisation */
944 key_put(discard);
David Howellsf70e2e02010-04-30 14:32:39 +0100945 } else {
946 /* there's sufficient slack space to append directly */
David Howells233e4732012-05-11 10:56:56 +0100947 kdebug("append %hu/%hu/%hu",
948 klist->delkey, klist->nkeys, klist->maxkeys);
949
950 RCU_INIT_POINTER(klist->keys[klist->delkey], key);
David Howellsf70e2e02010-04-30 14:32:39 +0100951 smp_wmb();
952 klist->nkeys++;
953 }
954}
955
956/*
David Howells973c9f42011-01-20 16:38:33 +0000957 * Finish linking a key into to a keyring.
958 *
959 * Must be called with __key_link_begin() having being called.
David Howellsf70e2e02010-04-30 14:32:39 +0100960 */
961void __key_link_end(struct key *keyring, struct key_type *type,
David Howellsceb73c12011-01-25 16:34:28 +0000962 unsigned long prealloc)
David Howellsf70e2e02010-04-30 14:32:39 +0100963 __releases(&keyring->sem)
David Howells423b97882012-05-21 12:32:13 +0100964 __releases(&keyring_serialise_link_sem)
David Howellsf70e2e02010-04-30 14:32:39 +0100965{
966 BUG_ON(type == NULL);
967 BUG_ON(type->name == NULL);
David Howellsceb73c12011-01-25 16:34:28 +0000968 kenter("%d,%s,%lx", keyring->serial, type->name, prealloc);
David Howellsf70e2e02010-04-30 14:32:39 +0100969
970 if (type == &key_type_keyring)
971 up_write(&keyring_serialise_link_sem);
972
973 if (prealloc) {
David Howellsceb73c12011-01-25 16:34:28 +0000974 if (prealloc & KEY_LINK_FIXQUOTA)
975 key_payload_reserve(keyring,
976 keyring->datalen -
977 KEYQUOTA_LINK_BYTES);
978 kfree((struct keyring_list *)(prealloc & ~KEY_LINK_FIXQUOTA));
David Howellsf70e2e02010-04-30 14:32:39 +0100979 }
980 up_write(&keyring->sem);
981}
982
David Howells973c9f42011-01-20 16:38:33 +0000983/**
984 * key_link - Link a key to a keyring
985 * @keyring: The keyring to make the link in.
986 * @key: The key to link to.
987 *
988 * Make a link in a keyring to a key, such that the keyring holds a reference
989 * on that key and the key can potentially be found by searching that keyring.
990 *
991 * This function will write-lock the keyring's semaphore and will consume some
992 * of the user's key data quota to hold the link.
993 *
994 * Returns 0 if successful, -ENOTDIR if the keyring isn't a keyring,
995 * -EKEYREVOKED if the keyring has been revoked, -ENFILE if the keyring is
996 * full, -EDQUOT if there is insufficient key data quota remaining to add
997 * another link or -ENOMEM if there's insufficient memory.
998 *
999 * It is assumed that the caller has checked that it is permitted for a link to
1000 * be made (the keyring should have Write permission and the key Link
1001 * permission).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 */
1003int key_link(struct key *keyring, struct key *key)
1004{
David Howellsceb73c12011-01-25 16:34:28 +00001005 unsigned long prealloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 int ret;
1007
1008 key_check(keyring);
1009 key_check(key);
1010
David Howellsf70e2e02010-04-30 14:32:39 +01001011 ret = __key_link_begin(keyring, key->type, key->description, &prealloc);
1012 if (ret == 0) {
1013 ret = __key_link_check_live_key(keyring, key);
1014 if (ret == 0)
1015 __key_link(keyring, key, &prealloc);
1016 __key_link_end(keyring, key->type, prealloc);
1017 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018
1019 return ret;
David Howellsf70e2e02010-04-30 14:32:39 +01001020}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021EXPORT_SYMBOL(key_link);
1022
David Howells973c9f42011-01-20 16:38:33 +00001023/**
1024 * key_unlink - Unlink the first link to a key from a keyring.
1025 * @keyring: The keyring to remove the link from.
1026 * @key: The key the link is to.
1027 *
1028 * Remove a link from a keyring to a key.
1029 *
1030 * This function will write-lock the keyring's semaphore.
1031 *
1032 * Returns 0 if successful, -ENOTDIR if the keyring isn't a keyring, -ENOENT if
1033 * the key isn't linked to by the keyring or -ENOMEM if there's insufficient
1034 * memory.
1035 *
1036 * It is assumed that the caller has checked that it is permitted for a link to
1037 * be removed (the keyring should have Write permission; no permissions are
1038 * required on the key).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 */
1040int key_unlink(struct key *keyring, struct key *key)
1041{
David Howells76d8aea2005-06-23 22:00:49 -07001042 struct keyring_list *klist, *nklist;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 int loop, ret;
1044
1045 key_check(keyring);
1046 key_check(key);
1047
1048 ret = -ENOTDIR;
1049 if (keyring->type != &key_type_keyring)
1050 goto error;
1051
1052 down_write(&keyring->sem);
1053
David Howellsf0641cb2010-04-30 14:32:18 +01001054 klist = rcu_dereference_locked_keyring(keyring);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 if (klist) {
1056 /* search the keyring for the key */
1057 for (loop = 0; loop < klist->nkeys; loop++)
David Howells233e4732012-05-11 10:56:56 +01001058 if (rcu_access_pointer(klist->keys[loop]) == key)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 goto key_is_present;
1060 }
1061
1062 up_write(&keyring->sem);
1063 ret = -ENOENT;
1064 goto error;
1065
David Howells76d8aea2005-06-23 22:00:49 -07001066key_is_present:
1067 /* we need to copy the key list for RCU purposes */
David Howellsa4014d82005-07-07 17:57:03 -07001068 nklist = kmalloc(sizeof(*klist) +
1069 sizeof(struct key *) * klist->maxkeys,
David Howells76d8aea2005-06-23 22:00:49 -07001070 GFP_KERNEL);
1071 if (!nklist)
1072 goto nomem;
1073 nklist->maxkeys = klist->maxkeys;
1074 nklist->nkeys = klist->nkeys - 1;
1075
1076 if (loop > 0)
1077 memcpy(&nklist->keys[0],
1078 &klist->keys[0],
David Howellsa4014d82005-07-07 17:57:03 -07001079 loop * sizeof(struct key *));
David Howells76d8aea2005-06-23 22:00:49 -07001080
1081 if (loop < nklist->nkeys)
1082 memcpy(&nklist->keys[loop],
1083 &klist->keys[loop + 1],
David Howellsa4014d82005-07-07 17:57:03 -07001084 (nklist->nkeys - loop) * sizeof(struct key *));
David Howells76d8aea2005-06-23 22:00:49 -07001085
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 /* adjust the user's quota */
1087 key_payload_reserve(keyring,
1088 keyring->datalen - KEYQUOTA_LINK_BYTES);
1089
David Howells76d8aea2005-06-23 22:00:49 -07001090 rcu_assign_pointer(keyring->payload.subscriptions, nklist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091
1092 up_write(&keyring->sem);
David Howells76d8aea2005-06-23 22:00:49 -07001093
1094 /* schedule for later cleanup */
1095 klist->delkey = loop;
1096 call_rcu(&klist->rcu, keyring_unlink_rcu_disposal);
1097
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 ret = 0;
1099
David Howells76d8aea2005-06-23 22:00:49 -07001100error:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 return ret;
David Howells76d8aea2005-06-23 22:00:49 -07001102nomem:
1103 ret = -ENOMEM;
1104 up_write(&keyring->sem);
1105 goto error;
David Howellsa8b17ed2011-01-20 16:38:27 +00001106}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107EXPORT_SYMBOL(key_unlink);
1108
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109/*
David Howells973c9f42011-01-20 16:38:33 +00001110 * Dispose of a keyring list after the RCU grace period, releasing the keys it
1111 * links to.
David Howells76d8aea2005-06-23 22:00:49 -07001112 */
1113static void keyring_clear_rcu_disposal(struct rcu_head *rcu)
1114{
1115 struct keyring_list *klist;
1116 int loop;
1117
1118 klist = container_of(rcu, struct keyring_list, rcu);
1119
1120 for (loop = klist->nkeys - 1; loop >= 0; loop--)
David Howells233e4732012-05-11 10:56:56 +01001121 key_put(rcu_access_pointer(klist->keys[loop]));
David Howells76d8aea2005-06-23 22:00:49 -07001122
1123 kfree(klist);
David Howellsa8b17ed2011-01-20 16:38:27 +00001124}
David Howells76d8aea2005-06-23 22:00:49 -07001125
David Howells973c9f42011-01-20 16:38:33 +00001126/**
1127 * keyring_clear - Clear a keyring
1128 * @keyring: The keyring to clear.
1129 *
1130 * Clear the contents of the specified keyring.
1131 *
1132 * Returns 0 if successful or -ENOTDIR if the keyring isn't a keyring.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 */
1134int keyring_clear(struct key *keyring)
1135{
1136 struct keyring_list *klist;
David Howells76d8aea2005-06-23 22:00:49 -07001137 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
1139 ret = -ENOTDIR;
1140 if (keyring->type == &key_type_keyring) {
1141 /* detach the pointer block with the locks held */
1142 down_write(&keyring->sem);
1143
David Howellsf0641cb2010-04-30 14:32:18 +01001144 klist = rcu_dereference_locked_keyring(keyring);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 if (klist) {
1146 /* adjust the quota */
1147 key_payload_reserve(keyring,
1148 sizeof(struct keyring_list));
1149
David Howells76d8aea2005-06-23 22:00:49 -07001150 rcu_assign_pointer(keyring->payload.subscriptions,
1151 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 }
1153
1154 up_write(&keyring->sem);
1155
1156 /* free the keys after the locks have been dropped */
David Howells76d8aea2005-06-23 22:00:49 -07001157 if (klist)
1158 call_rcu(&klist->rcu, keyring_clear_rcu_disposal);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159
1160 ret = 0;
1161 }
1162
1163 return ret;
David Howellsa8b17ed2011-01-20 16:38:27 +00001164}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165EXPORT_SYMBOL(keyring_clear);
David Howells31204ed2006-06-26 00:24:51 -07001166
David Howells31204ed2006-06-26 00:24:51 -07001167/*
David Howells973c9f42011-01-20 16:38:33 +00001168 * Dispose of the links from a revoked keyring.
1169 *
1170 * This is called with the key sem write-locked.
David Howells31204ed2006-06-26 00:24:51 -07001171 */
1172static void keyring_revoke(struct key *keyring)
1173{
David Howellsf0641cb2010-04-30 14:32:18 +01001174 struct keyring_list *klist;
1175
1176 klist = rcu_dereference_locked_keyring(keyring);
David Howells31204ed2006-06-26 00:24:51 -07001177
1178 /* adjust the quota */
1179 key_payload_reserve(keyring, 0);
1180
1181 if (klist) {
1182 rcu_assign_pointer(keyring->payload.subscriptions, NULL);
1183 call_rcu(&klist->rcu, keyring_clear_rcu_disposal);
1184 }
David Howellsa8b17ed2011-01-20 16:38:27 +00001185}
David Howells5d135442009-09-02 09:14:00 +01001186
1187/*
David Howells973c9f42011-01-20 16:38:33 +00001188 * Collect garbage from the contents of a keyring, replacing the old list with
1189 * a new one with the pointers all shuffled down.
1190 *
1191 * Dead keys are classed as oned that are flagged as being dead or are revoked,
1192 * expired or negative keys that were revoked or expired before the specified
1193 * limit.
David Howells5d135442009-09-02 09:14:00 +01001194 */
1195void keyring_gc(struct key *keyring, time_t limit)
1196{
1197 struct keyring_list *klist, *new;
1198 struct key *key;
1199 int loop, keep, max;
1200
David Howellsc08ef802009-09-14 17:26:13 +01001201 kenter("{%x,%s}", key_serial(keyring), keyring->description);
David Howells5d135442009-09-02 09:14:00 +01001202
1203 down_write(&keyring->sem);
1204
David Howellsf0641cb2010-04-30 14:32:18 +01001205 klist = rcu_dereference_locked_keyring(keyring);
David Howells5d135442009-09-02 09:14:00 +01001206 if (!klist)
David Howellsc08ef802009-09-14 17:26:13 +01001207 goto no_klist;
David Howells5d135442009-09-02 09:14:00 +01001208
1209 /* work out how many subscriptions we're keeping */
1210 keep = 0;
1211 for (loop = klist->nkeys - 1; loop >= 0; loop--)
David Howells233e4732012-05-11 10:56:56 +01001212 if (!key_is_dead(rcu_deref_link_locked(klist, loop, keyring),
1213 limit))
David Howells5d135442009-09-02 09:14:00 +01001214 keep++;
1215
1216 if (keep == klist->nkeys)
1217 goto just_return;
1218
1219 /* allocate a new keyring payload */
1220 max = roundup(keep, 4);
1221 new = kmalloc(sizeof(struct keyring_list) + max * sizeof(struct key *),
1222 GFP_KERNEL);
1223 if (!new)
David Howellsc08ef802009-09-14 17:26:13 +01001224 goto nomem;
David Howells5d135442009-09-02 09:14:00 +01001225 new->maxkeys = max;
1226 new->nkeys = 0;
1227 new->delkey = 0;
1228
1229 /* install the live keys
1230 * - must take care as expired keys may be updated back to life
1231 */
1232 keep = 0;
1233 for (loop = klist->nkeys - 1; loop >= 0; loop--) {
David Howells233e4732012-05-11 10:56:56 +01001234 key = rcu_deref_link_locked(klist, loop, keyring);
David Howells5d135442009-09-02 09:14:00 +01001235 if (!key_is_dead(key, limit)) {
1236 if (keep >= max)
1237 goto discard_new;
David Howells233e4732012-05-11 10:56:56 +01001238 RCU_INIT_POINTER(new->keys[keep++], key_get(key));
David Howells5d135442009-09-02 09:14:00 +01001239 }
1240 }
1241 new->nkeys = keep;
1242
1243 /* adjust the quota */
1244 key_payload_reserve(keyring,
1245 sizeof(struct keyring_list) +
1246 KEYQUOTA_LINK_BYTES * keep);
1247
1248 if (keep == 0) {
1249 rcu_assign_pointer(keyring->payload.subscriptions, NULL);
1250 kfree(new);
1251 } else {
1252 rcu_assign_pointer(keyring->payload.subscriptions, new);
1253 }
1254
1255 up_write(&keyring->sem);
1256
1257 call_rcu(&klist->rcu, keyring_clear_rcu_disposal);
1258 kleave(" [yes]");
1259 return;
1260
1261discard_new:
1262 new->nkeys = keep;
1263 keyring_clear_rcu_disposal(&new->rcu);
David Howellsc08ef802009-09-14 17:26:13 +01001264 up_write(&keyring->sem);
1265 kleave(" [discard]");
1266 return;
1267
David Howells5d135442009-09-02 09:14:00 +01001268just_return:
1269 up_write(&keyring->sem);
David Howellsc08ef802009-09-14 17:26:13 +01001270 kleave(" [no dead]");
1271 return;
1272
1273no_klist:
1274 up_write(&keyring->sem);
1275 kleave(" [no_klist]");
1276 return;
1277
1278nomem:
1279 up_write(&keyring->sem);
1280 kleave(" [oom]");
David Howells5d135442009-09-02 09:14:00 +01001281}