blob: d37f713e73ce7ef7937ef8bfe23a96960202c187 [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070028/*
29 * when plumbing the depths of the key tree, this sets a hard limit set on how
30 * deep we're willing to go
31 */
32#define KEYRING_SEARCH_MAX_DEPTH 6
33
34/*
35 * we keep all named keyrings in a hash to speed looking them up
36 */
37#define KEYRING_NAME_HASH_SIZE (1 << 5)
38
39static struct list_head keyring_name_hash[KEYRING_NAME_HASH_SIZE];
40static DEFINE_RWLOCK(keyring_name_lock);
41
42static inline unsigned keyring_hash(const char *desc)
43{
44 unsigned bucket = 0;
45
46 for (; *desc; desc++)
Justin P. Mattockc5b60b52010-04-21 00:02:11 -070047 bucket += (unsigned char)*desc;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
49 return bucket & (KEYRING_NAME_HASH_SIZE - 1);
50}
51
52/*
53 * the keyring type definition
54 */
55static int keyring_instantiate(struct key *keyring,
56 const void *data, size_t datalen);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057static int keyring_match(const struct key *keyring, const void *criterion);
David Howells31204ed2006-06-26 00:24:51 -070058static void keyring_revoke(struct key *keyring);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059static void keyring_destroy(struct key *keyring);
60static void keyring_describe(const struct key *keyring, struct seq_file *m);
61static long keyring_read(const struct key *keyring,
62 char __user *buffer, size_t buflen);
63
64struct key_type key_type_keyring = {
65 .name = "keyring",
66 .def_datalen = sizeof(struct keyring_list),
67 .instantiate = keyring_instantiate,
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 .match = keyring_match,
David Howells31204ed2006-06-26 00:24:51 -070069 .revoke = keyring_revoke,
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 .destroy = keyring_destroy,
71 .describe = keyring_describe,
72 .read = keyring_read,
73};
74
David Howells73182262007-04-26 15:46:23 -070075EXPORT_SYMBOL(key_type_keyring);
76
Linus Torvalds1da177e2005-04-16 15:20:36 -070077/*
78 * semaphore to serialise link/link calls to prevent two link calls in parallel
79 * introducing a cycle
80 */
Adrian Bunk1ae8f402006-01-06 00:11:25 -080081static DECLARE_RWSEM(keyring_serialise_link_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
83/*****************************************************************************/
84/*
85 * publish the name of a keyring so that it can be found by name (if it has
86 * one)
87 */
David Howells69664cf2008-04-29 01:01:31 -070088static void keyring_publish_name(struct key *keyring)
Linus Torvalds1da177e2005-04-16 15:20:36 -070089{
90 int bucket;
91
92 if (keyring->description) {
93 bucket = keyring_hash(keyring->description);
94
95 write_lock(&keyring_name_lock);
96
97 if (!keyring_name_hash[bucket].next)
98 INIT_LIST_HEAD(&keyring_name_hash[bucket]);
99
100 list_add_tail(&keyring->type_data.link,
101 &keyring_name_hash[bucket]);
102
103 write_unlock(&keyring_name_lock);
104 }
105
106} /* end keyring_publish_name() */
107
108/*****************************************************************************/
109/*
110 * initialise a keyring
111 * - we object if we were given any data
112 */
113static int keyring_instantiate(struct key *keyring,
114 const void *data, size_t datalen)
115{
116 int ret;
117
118 ret = -EINVAL;
119 if (datalen == 0) {
120 /* make the keyring available by name if it has one */
121 keyring_publish_name(keyring);
122 ret = 0;
123 }
124
125 return ret;
126
127} /* end keyring_instantiate() */
128
129/*****************************************************************************/
130/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 * match keyrings on their name
132 */
133static int keyring_match(const struct key *keyring, const void *description)
134{
135 return keyring->description &&
136 strcmp(keyring->description, description) == 0;
137
138} /* end keyring_match() */
139
140/*****************************************************************************/
141/*
142 * dispose of the data dangling from the corpse of a keyring
143 */
144static void keyring_destroy(struct key *keyring)
145{
146 struct keyring_list *klist;
147 int loop;
148
149 if (keyring->description) {
150 write_lock(&keyring_name_lock);
David Howells94efe722005-08-04 13:07:07 -0700151
152 if (keyring->type_data.link.next != NULL &&
153 !list_empty(&keyring->type_data.link))
154 list_del(&keyring->type_data.link);
155
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 write_unlock(&keyring_name_lock);
157 }
158
Paul E. McKenneye7b0a612010-02-22 17:04:56 -0800159 klist = rcu_dereference_check(keyring->payload.subscriptions,
160 rcu_read_lock_held() ||
161 atomic_read(&keyring->usage) == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 if (klist) {
163 for (loop = klist->nkeys - 1; loop >= 0; loop--)
164 key_put(klist->keys[loop]);
165 kfree(klist);
166 }
167
168} /* end keyring_destroy() */
169
170/*****************************************************************************/
171/*
172 * describe the keyring
173 */
174static void keyring_describe(const struct key *keyring, struct seq_file *m)
175{
176 struct keyring_list *klist;
177
wzt.wzt@gmail.comc8563472010-03-04 21:26:23 +0800178 if (keyring->description)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 seq_puts(m, keyring->description);
wzt.wzt@gmail.comc8563472010-03-04 21:26:23 +0800180 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 seq_puts(m, "[anon]");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182
David Howells76d8aea2005-06-23 22:00:49 -0700183 rcu_read_lock();
184 klist = rcu_dereference(keyring->payload.subscriptions);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 if (klist)
186 seq_printf(m, ": %u/%u", klist->nkeys, klist->maxkeys);
187 else
188 seq_puts(m, ": empty");
David Howells76d8aea2005-06-23 22:00:49 -0700189 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
191} /* end keyring_describe() */
192
193/*****************************************************************************/
194/*
195 * read a list of key IDs from the keyring's contents
David Howells76d8aea2005-06-23 22:00:49 -0700196 * - the keyring's semaphore is read-locked
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 */
198static long keyring_read(const struct key *keyring,
199 char __user *buffer, size_t buflen)
200{
201 struct keyring_list *klist;
202 struct key *key;
203 size_t qty, tmp;
204 int loop, ret;
205
206 ret = 0;
David Howellsf0641cb2010-04-30 14:32:18 +0100207 klist = rcu_dereference_locked_keyring(keyring);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 if (klist) {
209 /* calculate how much data we could return */
210 qty = klist->nkeys * sizeof(key_serial_t);
211
212 if (buffer && buflen > 0) {
213 if (buflen > qty)
214 buflen = qty;
215
216 /* copy the IDs of the subscribed keys into the
217 * buffer */
218 ret = -EFAULT;
219
220 for (loop = 0; loop < klist->nkeys; loop++) {
221 key = klist->keys[loop];
222
223 tmp = sizeof(key_serial_t);
224 if (tmp > buflen)
225 tmp = buflen;
226
227 if (copy_to_user(buffer,
228 &key->serial,
229 tmp) != 0)
230 goto error;
231
232 buflen -= tmp;
233 if (buflen == 0)
234 break;
235 buffer += tmp;
236 }
237 }
238
239 ret = qty;
240 }
241
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700242error:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 return ret;
244
245} /* end keyring_read() */
246
247/*****************************************************************************/
248/*
249 * allocate a keyring and link into the destination keyring
250 */
251struct key *keyring_alloc(const char *description, uid_t uid, gid_t gid,
David Howellsd84f4f92008-11-14 10:39:23 +1100252 const struct cred *cred, unsigned long flags,
Michael LeMayd7200242006-06-22 14:47:17 -0700253 struct key *dest)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254{
255 struct key *keyring;
256 int ret;
257
258 keyring = key_alloc(&key_type_keyring, description,
David Howellsd84f4f92008-11-14 10:39:23 +1100259 uid, gid, cred,
David Howells29db9192005-10-30 15:02:44 -0800260 (KEY_POS_ALL & ~KEY_POS_SETATTR) | KEY_USR_ALL,
David Howells7e047ef2006-06-26 00:24:50 -0700261 flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
263 if (!IS_ERR(keyring)) {
David Howells3e301482005-06-23 22:00:56 -0700264 ret = key_instantiate_and_link(keyring, NULL, 0, dest, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 if (ret < 0) {
266 key_put(keyring);
267 keyring = ERR_PTR(ret);
268 }
269 }
270
271 return keyring;
272
273} /* end keyring_alloc() */
274
275/*****************************************************************************/
276/*
277 * search the supplied keyring tree for a key that matches the criterion
278 * - perform a breadth-then-depth search up to the prescribed limit
279 * - we only find keys on which we have search permission
280 * - we use the supplied match function to see if the description (or other
281 * feature of interest) matches
David Howells3e301482005-06-23 22:00:56 -0700282 * - we rely on RCU to prevent the keyring lists from disappearing on us
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 * - we return -EAGAIN if we didn't find any matching key
284 * - we return -ENOKEY if we only found negative matching keys
David Howells664cceb2005-09-28 17:03:15 +0100285 * - we propagate the possession attribute from the keyring ref to the key ref
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 */
David Howells664cceb2005-09-28 17:03:15 +0100287key_ref_t keyring_search_aux(key_ref_t keyring_ref,
David Howellsd84f4f92008-11-14 10:39:23 +1100288 const struct cred *cred,
David Howells664cceb2005-09-28 17:03:15 +0100289 struct key_type *type,
290 const void *description,
291 key_match_func_t match)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292{
293 struct {
David Howells76d8aea2005-06-23 22:00:49 -0700294 struct keyring_list *keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 int kix;
296 } stack[KEYRING_SEARCH_MAX_DEPTH];
297
298 struct keyring_list *keylist;
299 struct timespec now;
Kevin Coffmandceba992008-04-29 01:01:22 -0700300 unsigned long possessed, kflags;
David Howells664cceb2005-09-28 17:03:15 +0100301 struct key *keyring, *key;
302 key_ref_t key_ref;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 long err;
David Howells76d8aea2005-06-23 22:00:49 -0700304 int sp, kix;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
David Howells664cceb2005-09-28 17:03:15 +0100306 keyring = key_ref_to_ptr(keyring_ref);
307 possessed = is_key_possessed(keyring_ref);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 key_check(keyring);
309
310 /* top keyring must have search permission to begin the search */
Chihau Chau512ea3b2010-03-08 20:11:34 -0300311 err = key_task_permission(keyring_ref, cred, KEY_SEARCH);
David Howells29db9192005-10-30 15:02:44 -0800312 if (err < 0) {
313 key_ref = ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 goto error;
David Howells29db9192005-10-30 15:02:44 -0800315 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
David Howells664cceb2005-09-28 17:03:15 +0100317 key_ref = ERR_PTR(-ENOTDIR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 if (keyring->type != &key_type_keyring)
319 goto error;
320
David Howells664cceb2005-09-28 17:03:15 +0100321 rcu_read_lock();
322
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 now = current_kernel_time();
324 err = -EAGAIN;
325 sp = 0;
326
Kevin Coffmandceba992008-04-29 01:01:22 -0700327 /* firstly we should check to see if this top-level keyring is what we
328 * are looking for */
329 key_ref = ERR_PTR(-EAGAIN);
330 kflags = keyring->flags;
331 if (keyring->type == type && match(keyring, description)) {
332 key = keyring;
333
334 /* check it isn't negative and hasn't expired or been
335 * revoked */
336 if (kflags & (1 << KEY_FLAG_REVOKED))
337 goto error_2;
338 if (key->expiry && now.tv_sec >= key->expiry)
339 goto error_2;
340 key_ref = ERR_PTR(-ENOKEY);
341 if (kflags & (1 << KEY_FLAG_NEGATIVE))
342 goto error_2;
343 goto found;
344 }
345
346 /* otherwise, the top keyring must not be revoked, expired, or
347 * negatively instantiated if we are to search it */
348 key_ref = ERR_PTR(-EAGAIN);
349 if (kflags & ((1 << KEY_FLAG_REVOKED) | (1 << KEY_FLAG_NEGATIVE)) ||
350 (keyring->expiry && now.tv_sec >= keyring->expiry))
351 goto error_2;
352
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 /* start processing a new keyring */
David Howells664cceb2005-09-28 17:03:15 +0100354descend:
David Howells76d8aea2005-06-23 22:00:49 -0700355 if (test_bit(KEY_FLAG_REVOKED, &keyring->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 goto not_this_keyring;
357
David Howells76d8aea2005-06-23 22:00:49 -0700358 keylist = rcu_dereference(keyring->payload.subscriptions);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 if (!keylist)
360 goto not_this_keyring;
361
362 /* iterate through the keys in this keyring first */
363 for (kix = 0; kix < keylist->nkeys; kix++) {
364 key = keylist->keys[kix];
Kevin Coffmandceba992008-04-29 01:01:22 -0700365 kflags = key->flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
367 /* ignore keys not of this type */
368 if (key->type != type)
369 continue;
370
371 /* skip revoked keys and expired keys */
Kevin Coffmandceba992008-04-29 01:01:22 -0700372 if (kflags & (1 << KEY_FLAG_REVOKED))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 continue;
374
375 if (key->expiry && now.tv_sec >= key->expiry)
376 continue;
377
378 /* keys that don't match */
379 if (!match(key, description))
380 continue;
381
382 /* key must have search permissions */
David Howells29db9192005-10-30 15:02:44 -0800383 if (key_task_permission(make_key_ref(key, possessed),
David Howellsd84f4f92008-11-14 10:39:23 +1100384 cred, KEY_SEARCH) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 continue;
386
Kevin Coffmandceba992008-04-29 01:01:22 -0700387 /* we set a different error code if we pass a negative key */
388 if (kflags & (1 << KEY_FLAG_NEGATIVE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 err = -ENOKEY;
390 continue;
391 }
392
393 goto found;
394 }
395
396 /* search through the keyrings nested in this one */
397 kix = 0;
David Howells664cceb2005-09-28 17:03:15 +0100398ascend:
David Howells76d8aea2005-06-23 22:00:49 -0700399 for (; kix < keylist->nkeys; kix++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 key = keylist->keys[kix];
401 if (key->type != &key_type_keyring)
David Howells76d8aea2005-06-23 22:00:49 -0700402 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
404 /* recursively search nested keyrings
405 * - only search keyrings for which we have search permission
406 */
407 if (sp >= KEYRING_SEARCH_MAX_DEPTH)
David Howells76d8aea2005-06-23 22:00:49 -0700408 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
David Howells0f6ed7c2005-11-07 00:59:30 -0800410 if (key_task_permission(make_key_ref(key, possessed),
David Howellsd84f4f92008-11-14 10:39:23 +1100411 cred, KEY_SEARCH) < 0)
David Howells76d8aea2005-06-23 22:00:49 -0700412 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
414 /* stack the current position */
David Howells76d8aea2005-06-23 22:00:49 -0700415 stack[sp].keylist = keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 stack[sp].kix = kix;
417 sp++;
418
419 /* begin again with the new keyring */
420 keyring = key;
421 goto descend;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 }
423
424 /* the keyring we're looking at was disqualified or didn't contain a
425 * matching key */
David Howells664cceb2005-09-28 17:03:15 +0100426not_this_keyring:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 if (sp > 0) {
428 /* resume the processing of a keyring higher up in the tree */
429 sp--;
David Howells76d8aea2005-06-23 22:00:49 -0700430 keylist = stack[sp].keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 kix = stack[sp].kix + 1;
432 goto ascend;
433 }
434
David Howells664cceb2005-09-28 17:03:15 +0100435 key_ref = ERR_PTR(err);
436 goto error_2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437
438 /* we found a viable match */
David Howells664cceb2005-09-28 17:03:15 +0100439found:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 atomic_inc(&key->usage);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 key_check(key);
David Howells664cceb2005-09-28 17:03:15 +0100442 key_ref = make_key_ref(key, possessed);
443error_2:
David Howells76d8aea2005-06-23 22:00:49 -0700444 rcu_read_unlock();
David Howells664cceb2005-09-28 17:03:15 +0100445error:
446 return key_ref;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447
448} /* end keyring_search_aux() */
449
450/*****************************************************************************/
451/*
452 * search the supplied keyring tree for a key that matches the criterion
453 * - perform a breadth-then-depth search up to the prescribed limit
454 * - we only find keys on which we have search permission
455 * - we readlock the keyrings as we search down the tree
456 * - we return -EAGAIN if we didn't find any matching key
457 * - we return -ENOKEY if we only found negative matching keys
458 */
David Howells664cceb2005-09-28 17:03:15 +0100459key_ref_t keyring_search(key_ref_t keyring,
460 struct key_type *type,
461 const char *description)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462{
David Howells3e301482005-06-23 22:00:56 -0700463 if (!type->match)
464 return ERR_PTR(-ENOKEY);
465
David Howellsd84f4f92008-11-14 10:39:23 +1100466 return keyring_search_aux(keyring, current->cred,
David Howells3e301482005-06-23 22:00:56 -0700467 type, description, type->match);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
469} /* end keyring_search() */
470
471EXPORT_SYMBOL(keyring_search);
472
473/*****************************************************************************/
474/*
475 * search the given keyring only (no recursion)
476 * - keyring must be locked by caller
David Howellsc3a9d652006-04-10 15:15:21 +0100477 * - caller must guarantee that the keyring is a keyring
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 */
David Howells664cceb2005-09-28 17:03:15 +0100479key_ref_t __keyring_search_one(key_ref_t keyring_ref,
480 const struct key_type *ktype,
481 const char *description,
482 key_perm_t perm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483{
484 struct keyring_list *klist;
David Howells664cceb2005-09-28 17:03:15 +0100485 unsigned long possessed;
486 struct key *keyring, *key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 int loop;
488
David Howells664cceb2005-09-28 17:03:15 +0100489 keyring = key_ref_to_ptr(keyring_ref);
490 possessed = is_key_possessed(keyring_ref);
491
David Howells76d8aea2005-06-23 22:00:49 -0700492 rcu_read_lock();
493
494 klist = rcu_dereference(keyring->payload.subscriptions);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 if (klist) {
496 for (loop = 0; loop < klist->nkeys; loop++) {
497 key = klist->keys[loop];
498
499 if (key->type == ktype &&
David Howells3e301482005-06-23 22:00:56 -0700500 (!key->type->match ||
501 key->type->match(key, description)) &&
David Howells664cceb2005-09-28 17:03:15 +0100502 key_permission(make_key_ref(key, possessed),
David Howellsdb1d1d52005-12-01 00:51:18 -0800503 perm) == 0 &&
David Howells76d8aea2005-06-23 22:00:49 -0700504 !test_bit(KEY_FLAG_REVOKED, &key->flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 )
506 goto found;
507 }
508 }
509
David Howells664cceb2005-09-28 17:03:15 +0100510 rcu_read_unlock();
511 return ERR_PTR(-ENOKEY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700513found:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 atomic_inc(&key->usage);
David Howells76d8aea2005-06-23 22:00:49 -0700515 rcu_read_unlock();
David Howells664cceb2005-09-28 17:03:15 +0100516 return make_key_ref(key, possessed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517
518} /* end __keyring_search_one() */
519
520/*****************************************************************************/
521/*
522 * find a keyring with the specified name
523 * - all named keyrings are searched
David Howells69664cf2008-04-29 01:01:31 -0700524 * - normally only finds keyrings with search permission for the current process
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 */
David Howells69664cf2008-04-29 01:01:31 -0700526struct key *find_keyring_by_name(const char *name, bool skip_perm_check)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527{
528 struct key *keyring;
529 int bucket;
530
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 if (!name)
Toshiyuki Okajimacea7daa2010-04-30 14:32:13 +0100532 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533
534 bucket = keyring_hash(name);
535
536 read_lock(&keyring_name_lock);
537
538 if (keyring_name_hash[bucket].next) {
539 /* search this hash bucket for a keyring with a matching name
540 * that's readable and that hasn't been revoked */
541 list_for_each_entry(keyring,
542 &keyring_name_hash[bucket],
543 type_data.link
544 ) {
Serge E. Hallyn2ea190d2009-02-26 18:27:55 -0600545 if (keyring->user->user_ns != current_user_ns())
546 continue;
547
David Howells76d8aea2005-06-23 22:00:49 -0700548 if (test_bit(KEY_FLAG_REVOKED, &keyring->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 continue;
550
551 if (strcmp(keyring->description, name) != 0)
552 continue;
553
David Howells69664cf2008-04-29 01:01:31 -0700554 if (!skip_perm_check &&
555 key_permission(make_key_ref(keyring, 0),
David Howells0f6ed7c2005-11-07 00:59:30 -0800556 KEY_SEARCH) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 continue;
558
Toshiyuki Okajimacea7daa2010-04-30 14:32:13 +0100559 /* we've got a match but we might end up racing with
560 * key_cleanup() if the keyring is currently 'dead'
561 * (ie. it has a zero usage count) */
562 if (!atomic_inc_not_zero(&keyring->usage))
563 continue;
564 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 }
566 }
567
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 keyring = ERR_PTR(-ENOKEY);
Toshiyuki Okajimacea7daa2010-04-30 14:32:13 +0100569out:
570 read_unlock(&keyring_name_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 return keyring;
572
573} /* end find_keyring_by_name() */
574
575/*****************************************************************************/
576/*
577 * see if a cycle will will be created by inserting acyclic tree B in acyclic
578 * tree A at the topmost level (ie: as a direct child of A)
579 * - since we are adding B to A at the top level, checking for cycles should
580 * just be a matter of seeing if node A is somewhere in tree B
581 */
582static int keyring_detect_cycle(struct key *A, struct key *B)
583{
584 struct {
David Howells76d8aea2005-06-23 22:00:49 -0700585 struct keyring_list *keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 int kix;
587 } stack[KEYRING_SEARCH_MAX_DEPTH];
588
589 struct keyring_list *keylist;
590 struct key *subtree, *key;
591 int sp, kix, ret;
592
David Howells76d8aea2005-06-23 22:00:49 -0700593 rcu_read_lock();
594
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 ret = -EDEADLK;
596 if (A == B)
David Howells76d8aea2005-06-23 22:00:49 -0700597 goto cycle_detected;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
599 subtree = B;
600 sp = 0;
601
602 /* start processing a new keyring */
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700603descend:
David Howells76d8aea2005-06-23 22:00:49 -0700604 if (test_bit(KEY_FLAG_REVOKED, &subtree->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 goto not_this_keyring;
606
David Howells76d8aea2005-06-23 22:00:49 -0700607 keylist = rcu_dereference(subtree->payload.subscriptions);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 if (!keylist)
609 goto not_this_keyring;
610 kix = 0;
611
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700612ascend:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 /* iterate through the remaining keys in this keyring */
614 for (; kix < keylist->nkeys; kix++) {
615 key = keylist->keys[kix];
616
617 if (key == A)
618 goto cycle_detected;
619
620 /* recursively check nested keyrings */
621 if (key->type == &key_type_keyring) {
622 if (sp >= KEYRING_SEARCH_MAX_DEPTH)
623 goto too_deep;
624
625 /* stack the current position */
David Howells76d8aea2005-06-23 22:00:49 -0700626 stack[sp].keylist = keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 stack[sp].kix = kix;
628 sp++;
629
630 /* begin again with the new keyring */
631 subtree = key;
632 goto descend;
633 }
634 }
635
636 /* the keyring we're looking at was disqualified or didn't contain a
637 * matching key */
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700638not_this_keyring:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 if (sp > 0) {
640 /* resume the checking of a keyring higher up in the tree */
641 sp--;
David Howells76d8aea2005-06-23 22:00:49 -0700642 keylist = stack[sp].keylist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 kix = stack[sp].kix + 1;
644 goto ascend;
645 }
646
647 ret = 0; /* no cycles detected */
648
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700649error:
David Howells76d8aea2005-06-23 22:00:49 -0700650 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 return ret;
652
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700653too_deep:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 ret = -ELOOP;
David Howells76d8aea2005-06-23 22:00:49 -0700655 goto error;
656
Justin P. Mattockc5b60b52010-04-21 00:02:11 -0700657cycle_detected:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 ret = -EDEADLK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 goto error;
660
661} /* end keyring_detect_cycle() */
662
David Howells76d8aea2005-06-23 22:00:49 -0700663/*
David Howellscab8eb52006-01-08 01:02:45 -0800664 * dispose of a keyring list after the RCU grace period, freeing the unlinked
665 * key
666 */
667static void keyring_unlink_rcu_disposal(struct rcu_head *rcu)
668{
669 struct keyring_list *klist =
670 container_of(rcu, struct keyring_list, rcu);
671
Alexey Dobriyan4be929b2010-05-24 14:33:03 -0700672 if (klist->delkey != USHRT_MAX)
David Howellsf70e2e02010-04-30 14:32:39 +0100673 key_put(klist->keys[klist->delkey]);
David Howellscab8eb52006-01-08 01:02:45 -0800674 kfree(klist);
David Howellsf70e2e02010-04-30 14:32:39 +0100675}
David Howellscab8eb52006-01-08 01:02:45 -0800676
David Howellscab8eb52006-01-08 01:02:45 -0800677/*
David Howellsf70e2e02010-04-30 14:32:39 +0100678 * preallocate memory so that a key can be linked into to a keyring
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 */
David Howellsf70e2e02010-04-30 14:32:39 +0100680int __key_link_begin(struct key *keyring, const struct key_type *type,
681 const char *description,
682 struct keyring_list **_prealloc)
683 __acquires(&keyring->sem)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684{
685 struct keyring_list *klist, *nklist;
686 unsigned max;
687 size_t size;
David Howellscab8eb52006-01-08 01:02:45 -0800688 int loop, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
David Howellsf70e2e02010-04-30 14:32:39 +0100690 kenter("%d,%s,%s,", key_serial(keyring), type->name, description);
691
692 if (keyring->type != &key_type_keyring)
693 return -ENOTDIR;
694
695 down_write(&keyring->sem);
696
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 ret = -EKEYREVOKED;
David Howells76d8aea2005-06-23 22:00:49 -0700698 if (test_bit(KEY_FLAG_REVOKED, &keyring->flags))
David Howellsf70e2e02010-04-30 14:32:39 +0100699 goto error_krsem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700
David Howellsf70e2e02010-04-30 14:32:39 +0100701 /* serialise link/link calls to prevent parallel calls causing a cycle
702 * when linking two keyring in opposite orders */
703 if (type == &key_type_keyring)
David Howells553d6032010-04-30 14:32:28 +0100704 down_write(&keyring_serialise_link_sem);
705
David Howellsf70e2e02010-04-30 14:32:39 +0100706 klist = rcu_dereference_locked_keyring(keyring);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
David Howellscab8eb52006-01-08 01:02:45 -0800708 /* see if there's a matching key we can displace */
David Howellscab8eb52006-01-08 01:02:45 -0800709 if (klist && klist->nkeys > 0) {
David Howellscab8eb52006-01-08 01:02:45 -0800710 for (loop = klist->nkeys - 1; loop >= 0; loop--) {
711 if (klist->keys[loop]->type == type &&
712 strcmp(klist->keys[loop]->description,
David Howellsf70e2e02010-04-30 14:32:39 +0100713 description) == 0
David Howellscab8eb52006-01-08 01:02:45 -0800714 ) {
David Howellsf70e2e02010-04-30 14:32:39 +0100715 /* found a match - we'll replace this one with
716 * the new key */
David Howellscab8eb52006-01-08 01:02:45 -0800717 size = sizeof(struct key *) * klist->maxkeys;
718 size += sizeof(*klist);
719 BUG_ON(size > PAGE_SIZE);
720
721 ret = -ENOMEM;
Eric Sesterhenn48ad5042006-12-06 20:33:47 -0800722 nklist = kmemdup(klist, size, GFP_KERNEL);
David Howellscab8eb52006-01-08 01:02:45 -0800723 if (!nklist)
David Howellsf70e2e02010-04-30 14:32:39 +0100724 goto error_sem;
David Howellscab8eb52006-01-08 01:02:45 -0800725
David Howellsf70e2e02010-04-30 14:32:39 +0100726 /* note replacement slot */
727 klist->delkey = nklist->delkey = loop;
David Howellscab8eb52006-01-08 01:02:45 -0800728 goto done;
729 }
730 }
731 }
732
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 /* check that we aren't going to overrun the user's quota */
734 ret = key_payload_reserve(keyring,
735 keyring->datalen + KEYQUOTA_LINK_BYTES);
736 if (ret < 0)
David Howellsf70e2e02010-04-30 14:32:39 +0100737 goto error_sem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 if (klist && klist->nkeys < klist->maxkeys) {
David Howellsf70e2e02010-04-30 14:32:39 +0100740 /* there's sufficient slack space to append directly */
741 nklist = NULL;
Chihau Chau512ea3b2010-03-08 20:11:34 -0300742 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 /* grow the key list */
744 max = 4;
745 if (klist)
746 max += klist->maxkeys;
747
748 ret = -ENFILE;
Alexey Dobriyan4be929b2010-05-24 14:33:03 -0700749 if (max > USHRT_MAX - 1)
David Howellsf70e2e02010-04-30 14:32:39 +0100750 goto error_quota;
David Howellsa4014d82005-07-07 17:57:03 -0700751 size = sizeof(*klist) + sizeof(struct key *) * max;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 if (size > PAGE_SIZE)
David Howellsf70e2e02010-04-30 14:32:39 +0100753 goto error_quota;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754
755 ret = -ENOMEM;
756 nklist = kmalloc(size, GFP_KERNEL);
757 if (!nklist)
David Howellsf70e2e02010-04-30 14:32:39 +0100758 goto error_quota;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
David Howellsf70e2e02010-04-30 14:32:39 +0100760 nklist->maxkeys = max;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 if (klist) {
David Howellsf70e2e02010-04-30 14:32:39 +0100762 memcpy(nklist->keys, klist->keys,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 sizeof(struct key *) * klist->nkeys);
David Howellsf70e2e02010-04-30 14:32:39 +0100764 nklist->delkey = klist->nkeys;
765 nklist->nkeys = klist->nkeys + 1;
Alexey Dobriyan4be929b2010-05-24 14:33:03 -0700766 klist->delkey = USHRT_MAX;
David Howellsf70e2e02010-04-30 14:32:39 +0100767 } else {
768 nklist->nkeys = 1;
769 nklist->delkey = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 }
771
772 /* add the key into the new space */
David Howellsf70e2e02010-04-30 14:32:39 +0100773 nklist->keys[nklist->delkey] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 }
775
David Howellscab8eb52006-01-08 01:02:45 -0800776done:
David Howellsf70e2e02010-04-30 14:32:39 +0100777 *_prealloc = nklist;
778 kleave(" = 0");
779 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
David Howellsf70e2e02010-04-30 14:32:39 +0100781error_quota:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 /* undo the quota changes */
783 key_payload_reserve(keyring,
784 keyring->datalen - KEYQUOTA_LINK_BYTES);
David Howellsf70e2e02010-04-30 14:32:39 +0100785error_sem:
786 if (type == &key_type_keyring)
787 up_write(&keyring_serialise_link_sem);
788error_krsem:
789 up_write(&keyring->sem);
790 kleave(" = %d", ret);
791 return ret;
792}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
David Howellsf70e2e02010-04-30 14:32:39 +0100794/*
795 * check already instantiated keys aren't going to be a problem
796 * - the caller must have called __key_link_begin()
797 * - don't need to call this for keys that were created since __key_link_begin()
798 * was called
799 */
800int __key_link_check_live_key(struct key *keyring, struct key *key)
801{
802 if (key->type == &key_type_keyring)
803 /* check that we aren't going to create a cycle by linking one
804 * keyring to another */
805 return keyring_detect_cycle(keyring, key);
806 return 0;
807}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808
David Howellsf70e2e02010-04-30 14:32:39 +0100809/*
810 * link a key into to a keyring
811 * - must be called with __key_link_begin() having being called
812 * - discard already extant link to matching key if there is one
813 */
814void __key_link(struct key *keyring, struct key *key,
815 struct keyring_list **_prealloc)
816{
817 struct keyring_list *klist, *nklist;
818
819 nklist = *_prealloc;
820 *_prealloc = NULL;
821
822 kenter("%d,%d,%p", keyring->serial, key->serial, nklist);
823
824 klist = rcu_dereference_protected(keyring->payload.subscriptions,
825 rwsem_is_locked(&keyring->sem));
826
827 atomic_inc(&key->usage);
828
829 /* there's a matching key we can displace or an empty slot in a newly
830 * allocated list we can fill */
831 if (nklist) {
832 kdebug("replace %hu/%hu/%hu",
833 nklist->delkey, nklist->nkeys, nklist->maxkeys);
834
835 nklist->keys[nklist->delkey] = key;
836
837 rcu_assign_pointer(keyring->payload.subscriptions, nklist);
838
839 /* dispose of the old keyring list and, if there was one, the
840 * displaced key */
841 if (klist) {
842 kdebug("dispose %hu/%hu/%hu",
843 klist->delkey, klist->nkeys, klist->maxkeys);
844 call_rcu(&klist->rcu, keyring_unlink_rcu_disposal);
845 }
846 } else {
847 /* there's sufficient slack space to append directly */
848 klist->keys[klist->nkeys] = key;
849 smp_wmb();
850 klist->nkeys++;
851 }
852}
853
854/*
855 * finish linking a key into to a keyring
856 * - must be called with __key_link_begin() having being called
857 */
858void __key_link_end(struct key *keyring, struct key_type *type,
859 struct keyring_list *prealloc)
860 __releases(&keyring->sem)
861{
862 BUG_ON(type == NULL);
863 BUG_ON(type->name == NULL);
864 kenter("%d,%s,%p", keyring->serial, type->name, prealloc);
865
866 if (type == &key_type_keyring)
867 up_write(&keyring_serialise_link_sem);
868
869 if (prealloc) {
870 kfree(prealloc);
871 key_payload_reserve(keyring,
872 keyring->datalen - KEYQUOTA_LINK_BYTES);
873 }
874 up_write(&keyring->sem);
875}
876
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877/*
878 * link a key to a keyring
879 */
880int key_link(struct key *keyring, struct key *key)
881{
David Howellsf70e2e02010-04-30 14:32:39 +0100882 struct keyring_list *prealloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 int ret;
884
885 key_check(keyring);
886 key_check(key);
887
David Howellsf70e2e02010-04-30 14:32:39 +0100888 ret = __key_link_begin(keyring, key->type, key->description, &prealloc);
889 if (ret == 0) {
890 ret = __key_link_check_live_key(keyring, key);
891 if (ret == 0)
892 __key_link(keyring, key, &prealloc);
893 __key_link_end(keyring, key->type, prealloc);
894 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895
896 return ret;
David Howellsf70e2e02010-04-30 14:32:39 +0100897}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898
899EXPORT_SYMBOL(key_link);
900
901/*****************************************************************************/
902/*
903 * unlink the first link to a key from a keyring
904 */
905int key_unlink(struct key *keyring, struct key *key)
906{
David Howells76d8aea2005-06-23 22:00:49 -0700907 struct keyring_list *klist, *nklist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 int loop, ret;
909
910 key_check(keyring);
911 key_check(key);
912
913 ret = -ENOTDIR;
914 if (keyring->type != &key_type_keyring)
915 goto error;
916
917 down_write(&keyring->sem);
918
David Howellsf0641cb2010-04-30 14:32:18 +0100919 klist = rcu_dereference_locked_keyring(keyring);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 if (klist) {
921 /* search the keyring for the key */
922 for (loop = 0; loop < klist->nkeys; loop++)
923 if (klist->keys[loop] == key)
924 goto key_is_present;
925 }
926
927 up_write(&keyring->sem);
928 ret = -ENOENT;
929 goto error;
930
David Howells76d8aea2005-06-23 22:00:49 -0700931key_is_present:
932 /* we need to copy the key list for RCU purposes */
David Howellsa4014d82005-07-07 17:57:03 -0700933 nklist = kmalloc(sizeof(*klist) +
934 sizeof(struct key *) * klist->maxkeys,
David Howells76d8aea2005-06-23 22:00:49 -0700935 GFP_KERNEL);
936 if (!nklist)
937 goto nomem;
938 nklist->maxkeys = klist->maxkeys;
939 nklist->nkeys = klist->nkeys - 1;
940
941 if (loop > 0)
942 memcpy(&nklist->keys[0],
943 &klist->keys[0],
David Howellsa4014d82005-07-07 17:57:03 -0700944 loop * sizeof(struct key *));
David Howells76d8aea2005-06-23 22:00:49 -0700945
946 if (loop < nklist->nkeys)
947 memcpy(&nklist->keys[loop],
948 &klist->keys[loop + 1],
David Howellsa4014d82005-07-07 17:57:03 -0700949 (nklist->nkeys - loop) * sizeof(struct key *));
David Howells76d8aea2005-06-23 22:00:49 -0700950
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 /* adjust the user's quota */
952 key_payload_reserve(keyring,
953 keyring->datalen - KEYQUOTA_LINK_BYTES);
954
David Howells76d8aea2005-06-23 22:00:49 -0700955 rcu_assign_pointer(keyring->payload.subscriptions, nklist);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956
957 up_write(&keyring->sem);
David Howells76d8aea2005-06-23 22:00:49 -0700958
959 /* schedule for later cleanup */
960 klist->delkey = loop;
961 call_rcu(&klist->rcu, keyring_unlink_rcu_disposal);
962
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 ret = 0;
964
David Howells76d8aea2005-06-23 22:00:49 -0700965error:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 return ret;
David Howells76d8aea2005-06-23 22:00:49 -0700967nomem:
968 ret = -ENOMEM;
969 up_write(&keyring->sem);
970 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971
972} /* end key_unlink() */
973
974EXPORT_SYMBOL(key_unlink);
975
976/*****************************************************************************/
977/*
David Howells76d8aea2005-06-23 22:00:49 -0700978 * dispose of a keyring list after the RCU grace period, releasing the keys it
979 * links to
980 */
981static void keyring_clear_rcu_disposal(struct rcu_head *rcu)
982{
983 struct keyring_list *klist;
984 int loop;
985
986 klist = container_of(rcu, struct keyring_list, rcu);
987
988 for (loop = klist->nkeys - 1; loop >= 0; loop--)
989 key_put(klist->keys[loop]);
990
991 kfree(klist);
992
993} /* end keyring_clear_rcu_disposal() */
994
995/*****************************************************************************/
996/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 * clear the specified process keyring
998 * - implements keyctl(KEYCTL_CLEAR)
999 */
1000int keyring_clear(struct key *keyring)
1001{
1002 struct keyring_list *klist;
David Howells76d8aea2005-06-23 22:00:49 -07001003 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004
1005 ret = -ENOTDIR;
1006 if (keyring->type == &key_type_keyring) {
1007 /* detach the pointer block with the locks held */
1008 down_write(&keyring->sem);
1009
David Howellsf0641cb2010-04-30 14:32:18 +01001010 klist = rcu_dereference_locked_keyring(keyring);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 if (klist) {
1012 /* adjust the quota */
1013 key_payload_reserve(keyring,
1014 sizeof(struct keyring_list));
1015
David Howells76d8aea2005-06-23 22:00:49 -07001016 rcu_assign_pointer(keyring->payload.subscriptions,
1017 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 }
1019
1020 up_write(&keyring->sem);
1021
1022 /* free the keys after the locks have been dropped */
David Howells76d8aea2005-06-23 22:00:49 -07001023 if (klist)
1024 call_rcu(&klist->rcu, keyring_clear_rcu_disposal);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025
1026 ret = 0;
1027 }
1028
1029 return ret;
1030
1031} /* end keyring_clear() */
1032
1033EXPORT_SYMBOL(keyring_clear);
David Howells31204ed2006-06-26 00:24:51 -07001034
1035/*****************************************************************************/
1036/*
1037 * dispose of the links from a revoked keyring
1038 * - called with the key sem write-locked
1039 */
1040static void keyring_revoke(struct key *keyring)
1041{
David Howellsf0641cb2010-04-30 14:32:18 +01001042 struct keyring_list *klist;
1043
1044 klist = rcu_dereference_locked_keyring(keyring);
David Howells31204ed2006-06-26 00:24:51 -07001045
1046 /* adjust the quota */
1047 key_payload_reserve(keyring, 0);
1048
1049 if (klist) {
1050 rcu_assign_pointer(keyring->payload.subscriptions, NULL);
1051 call_rcu(&klist->rcu, keyring_clear_rcu_disposal);
1052 }
1053
1054} /* end keyring_revoke() */
David Howells5d135442009-09-02 09:14:00 +01001055
1056/*
1057 * Determine whether a key is dead
1058 */
1059static bool key_is_dead(struct key *key, time_t limit)
1060{
1061 return test_bit(KEY_FLAG_DEAD, &key->flags) ||
1062 (key->expiry > 0 && key->expiry <= limit);
1063}
1064
1065/*
1066 * Collect garbage from the contents of a keyring
1067 */
1068void keyring_gc(struct key *keyring, time_t limit)
1069{
1070 struct keyring_list *klist, *new;
1071 struct key *key;
1072 int loop, keep, max;
1073
David Howellsc08ef802009-09-14 17:26:13 +01001074 kenter("{%x,%s}", key_serial(keyring), keyring->description);
David Howells5d135442009-09-02 09:14:00 +01001075
1076 down_write(&keyring->sem);
1077
David Howellsf0641cb2010-04-30 14:32:18 +01001078 klist = rcu_dereference_locked_keyring(keyring);
David Howells5d135442009-09-02 09:14:00 +01001079 if (!klist)
David Howellsc08ef802009-09-14 17:26:13 +01001080 goto no_klist;
David Howells5d135442009-09-02 09:14:00 +01001081
1082 /* work out how many subscriptions we're keeping */
1083 keep = 0;
1084 for (loop = klist->nkeys - 1; loop >= 0; loop--)
David Howellsc08ef802009-09-14 17:26:13 +01001085 if (!key_is_dead(klist->keys[loop], limit))
David Howells5d135442009-09-02 09:14:00 +01001086 keep++;
1087
1088 if (keep == klist->nkeys)
1089 goto just_return;
1090
1091 /* allocate a new keyring payload */
1092 max = roundup(keep, 4);
1093 new = kmalloc(sizeof(struct keyring_list) + max * sizeof(struct key *),
1094 GFP_KERNEL);
1095 if (!new)
David Howellsc08ef802009-09-14 17:26:13 +01001096 goto nomem;
David Howells5d135442009-09-02 09:14:00 +01001097 new->maxkeys = max;
1098 new->nkeys = 0;
1099 new->delkey = 0;
1100
1101 /* install the live keys
1102 * - must take care as expired keys may be updated back to life
1103 */
1104 keep = 0;
1105 for (loop = klist->nkeys - 1; loop >= 0; loop--) {
1106 key = klist->keys[loop];
1107 if (!key_is_dead(key, limit)) {
1108 if (keep >= max)
1109 goto discard_new;
1110 new->keys[keep++] = key_get(key);
1111 }
1112 }
1113 new->nkeys = keep;
1114
1115 /* adjust the quota */
1116 key_payload_reserve(keyring,
1117 sizeof(struct keyring_list) +
1118 KEYQUOTA_LINK_BYTES * keep);
1119
1120 if (keep == 0) {
1121 rcu_assign_pointer(keyring->payload.subscriptions, NULL);
1122 kfree(new);
1123 } else {
1124 rcu_assign_pointer(keyring->payload.subscriptions, new);
1125 }
1126
1127 up_write(&keyring->sem);
1128
1129 call_rcu(&klist->rcu, keyring_clear_rcu_disposal);
1130 kleave(" [yes]");
1131 return;
1132
1133discard_new:
1134 new->nkeys = keep;
1135 keyring_clear_rcu_disposal(&new->rcu);
David Howellsc08ef802009-09-14 17:26:13 +01001136 up_write(&keyring->sem);
1137 kleave(" [discard]");
1138 return;
1139
David Howells5d135442009-09-02 09:14:00 +01001140just_return:
1141 up_write(&keyring->sem);
David Howellsc08ef802009-09-14 17:26:13 +01001142 kleave(" [no dead]");
1143 return;
1144
1145no_klist:
1146 up_write(&keyring->sem);
1147 kleave(" [no_klist]");
1148 return;
1149
1150nomem:
1151 up_write(&keyring->sem);
1152 kleave(" [oom]");
David Howells5d135442009-09-02 09:14:00 +01001153}