[net-next-2.6.git] / security / keys / request_key.c

/* request_key.c: request a key from userspace
 *
 * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kmod.h>
#include <linux/err.h>
#include "internal.h"

struct key_construction {
	struct list_head	link;	/* link in construction queue */
	struct key		*key;	/* key being constructed */
};

/* when waiting for someone else's keys, you get added to this */
DECLARE_WAIT_QUEUE_HEAD(request_key_conswq);

/*****************************************************************************/
/*
 * request userspace finish the construction of a key
 * - execute "/sbin/request-key <op> <key> <uid> <gid> <keyring> <keyring> <keyring> <info>"
 * - if callout_info is an empty string, it'll be rendered as a "-" instead
 */
static int call_request_key(struct key *key,
			    const char *op,
			    const char *callout_info)
{
	struct task_struct *tsk = current;
	unsigned long flags;
	key_serial_t prkey, sskey;
	char *argv[10], *envp[3], uid_str[12], gid_str[12];
	char key_str[12], keyring_str[3][12];
	int i;

	/* record the UID and GID */
	sprintf(uid_str, "%d", current->fsuid);
	sprintf(gid_str, "%d", current->fsgid);

	/* we say which key is under construction */
	sprintf(key_str, "%d", key->serial);

	/* we specify the process's default keyrings */
	sprintf(keyring_str[0], "%d",
		tsk->thread_keyring ? tsk->thread_keyring->serial : 0);

	prkey = 0;
	if (tsk->signal->process_keyring)
		prkey = tsk->signal->process_keyring->serial;

	sskey = 0;
	spin_lock_irqsave(&tsk->sighand->siglock, flags);
	if (tsk->signal->session_keyring)
		sskey = tsk->signal->session_keyring->serial;
	spin_unlock_irqrestore(&tsk->sighand->siglock, flags);


	if (!sskey)
		sskey = tsk->user->session_keyring->serial;

	sprintf(keyring_str[1], "%d", prkey);
	sprintf(keyring_str[2], "%d", sskey);

	/* set up a minimal environment */
	i = 0;
	envp[i++] = "HOME=/";
	envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
	envp[i] = NULL;

	/* set up the argument list */
	i = 0;
	argv[i++] = "/sbin/request-key";
	argv[i++] = (char *) op;
	argv[i++] = key_str;
	argv[i++] = uid_str;
	argv[i++] = gid_str;
	argv[i++] = keyring_str[0];
	argv[i++] = keyring_str[1];
	argv[i++] = keyring_str[2];
	argv[i++] = callout_info[0] ? (char *) callout_info : "-";
	argv[i] = NULL;

	/* do it */
	return call_usermodehelper_keys(argv[0], argv, envp, NULL, 1);

} /* end call_request_key() */

/*****************************************************************************/
/*
 * call out to userspace for the key
 * - called with the construction sem held, but the sem is dropped here
 * - we ignore program failure and go on key status instead
 */
static struct key *__request_key_construction(struct key_type *type,
					      const char *description,
					      const char *callout_info)
{
	struct key_construction cons;
	struct timespec now;
	struct key *key;
	int ret, negated;

	/* create a key and add it to the queue */
	key = key_alloc(type, description,
			current->fsuid, current->fsgid, KEY_USR_ALL, 0);
	if (IS_ERR(key))
		goto alloc_failed;

	set_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags);

	cons.key = key;
	list_add_tail(&cons.link, &key->user->consq);

	/* we drop the construction sem here on behalf of the caller */
	up_write(&key_construction_sem);

	/* make the call */
	ret = call_request_key(key, "create", callout_info);
	if (ret < 0)
		goto request_failed;

	/* if the key wasn't instantiated, then we want to give an error */
	ret = -ENOKEY;
	if (!test_bit(KEY_FLAG_INSTANTIATED, &key->flags))
		goto request_failed;

	down_write(&key_construction_sem);
	list_del(&cons.link);
	up_write(&key_construction_sem);

	/* also give an error if the key was negatively instantiated */
 check_not_negative:
	if (test_bit(KEY_FLAG_NEGATIVE, &key->flags)) {
		key_put(key);
		key = ERR_PTR(-ENOKEY);
	}

 out:
	return key;

 request_failed:
	/* it wasn't instantiated
	 * - remove from construction queue
	 * - mark the key as dead
	 */
	negated = 0;
	down_write(&key_construction_sem);

	list_del(&cons.link);

	/* check it didn't get instantiated between the check and the down */
	if (!test_bit(KEY_FLAG_INSTANTIATED, &key->flags)) {
		set_bit(KEY_FLAG_NEGATIVE, &key->flags);
		set_bit(KEY_FLAG_INSTANTIATED, &key->flags);
		negated = 1;
	}

	clear_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags);

	up_write(&key_construction_sem);

	if (!negated)
		goto check_not_negative; /* surprisingly, the key got
					  * instantiated */

	/* set the timeout and store in the session keyring if we can */
	now = current_kernel_time();
	key->expiry = now.tv_sec + key_negative_timeout;

	if (current->signal->session_keyring) {
		struct key *keyring;

		rcu_read_lock();
		keyring = rcu_dereference(current->signal->session_keyring);
		atomic_inc(&keyring->usage);
		rcu_read_unlock();

		key_link(keyring, key);
		key_put(keyring);
	}

	key_put(key);

	/* notify anyone who was waiting */
	wake_up_all(&request_key_conswq);

	key = ERR_PTR(ret);
	goto out;

 alloc_failed:
	up_write(&key_construction_sem);
	goto out;

} /* end __request_key_construction() */

/*****************************************************************************/
/*
 * call out to userspace to request the key
 * - we check the construction queue first to see if an appropriate key is
 *   already being constructed by userspace
 */
static struct key *request_key_construction(struct key_type *type,
					    const char *description,
					    struct key_user *user,
					    const char *callout_info)
{
	struct key_construction *pcons;
	struct key *key, *ckey;

	DECLARE_WAITQUEUE(myself, current);

	/* see if there's such a key under construction already */
	down_write(&key_construction_sem);

	list_for_each_entry(pcons, &user->consq, link) {
		ckey = pcons->key;

		if (ckey->type != type)
			continue;

		if (type->match(ckey, description))
			goto found_key_under_construction;
	}

	/* see about getting userspace to construct the key */
	key = __request_key_construction(type, description, callout_info);
 error:
	return key;

	/* someone else has the same key under construction
	 * - we want to keep an eye on their key
	 */
 found_key_under_construction:
	atomic_inc(&ckey->usage);
	up_write(&key_construction_sem);

	/* wait for the key to be completed one way or another */
	add_wait_queue(&request_key_conswq, &myself);

	for (;;) {
		set_current_state(TASK_UNINTERRUPTIBLE);
		if (!test_bit(KEY_FLAG_USER_CONSTRUCT, &ckey->flags))
			break;
		schedule();
	}

	set_current_state(TASK_RUNNING);
	remove_wait_queue(&request_key_conswq, &myself);

	/* we'll need to search this process's keyrings to see if the key is
	 * now there since we can't automatically assume it's also available
	 * there */
	key_put(ckey);
	ckey = NULL;

	key = NULL; /* request a retry */
	goto error;

} /* end request_key_construction() */

/*****************************************************************************/
/*
 * request a key
 * - search the process's keyrings
 * - check the list of keys being created or updated
 * - call out to userspace for a key if requested (supplementary info can be
 *   passed)
 */
struct key *request_key(struct key_type *type,
			const char *description,
			const char *callout_info)
{
	struct key_user *user;
	struct key *key;

	/* search all the process keyrings for a key */
	key = search_process_keyrings_aux(type, description, type->match);

	if (PTR_ERR(key) == -EAGAIN) {
		/* the search failed, but the keyrings were searchable, so we
		 * should consult userspace if we can */
		key = ERR_PTR(-ENOKEY);
		if (!callout_info)
			goto error;

		/* - get hold of the user's construction queue */
		user = key_user_lookup(current->fsuid);
		if (!user) {
			key = ERR_PTR(-ENOMEM);
			goto error;
		}

		for (;;) {
			/* ask userspace (returns NULL if it waited on a key
			 * being constructed) */
			key = request_key_construction(type, description,
						       user, callout_info);
			if (key)
				break;

			/* someone else made the key we want, so we need to
			 * search again as it might now be available to us */
			key = search_process_keyrings_aux(type, description,
							  type->match);
			if (PTR_ERR(key) != -EAGAIN)
				break;
		}

		key_user_put(user);
	}

 error:
	return key;

} /* end request_key() */

EXPORT_SYMBOL(request_key);

/*****************************************************************************/
/*
 * validate a key
 */
int key_validate(struct key *key)
{
	struct timespec now;
	int ret = 0;

	if (key) {
		/* check it's still accessible */
		ret = -EKEYREVOKED;
		if (test_bit(KEY_FLAG_REVOKED, &key->flags) ||
		    test_bit(KEY_FLAG_DEAD, &key->flags))
			goto error;

		/* check it hasn't expired */
		ret = 0;
		if (key->expiry) {
			now = current_kernel_time();
			if (now.tv_sec >= key->expiry)
				ret = -EKEYEXPIRED;
		}
	}

 error:
	return ret;

} /* end key_validate() */

EXPORT_SYMBOL(key_validate);
Commit	Line	Data
1da177e4 LT	1	/* request_key.c: request a key from userspace
	2	*
	3	* Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells (dhowells@redhat.com)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/sched.h>
	14	#include <linux/kmod.h>
	15	#include <linux/err.h>
	16	#include "internal.h"
	17
	18	struct key_construction {
	19	struct list_head link; /* link in construction queue */
	20	struct key key; / key being constructed */
	21	};
	22
	23	/* when waiting for someone else's keys, you get added to this */
	24	DECLARE_WAIT_QUEUE_HEAD(request_key_conswq);
	25
	26	/*****************************************************************************/
	27	/*
	28	* request userspace finish the construction of a key
	29	* - execute "/sbin/request-key <op> <key> <uid> <gid> <keyring> <keyring> <keyring> <info>"
	30	* - if callout_info is an empty string, it'll be rendered as a "-" instead
	31	*/
	32	static int call_request_key(struct key *key,
	33	const char *op,
	34	const char *callout_info)
	35	{
	36	struct task_struct *tsk = current;
	37	unsigned long flags;
	38	key_serial_t prkey, sskey;
	39	char argv[10], envp[3], uid_str[12], gid_str[12];
	40	char key_str[12], keyring_str[3][12];
	41	int i;
	42
	43	/* record the UID and GID */
	44	sprintf(uid_str, "%d", current->fsuid);
	45	sprintf(gid_str, "%d", current->fsgid);
	46
	47	/* we say which key is under construction */
	48	sprintf(key_str, "%d", key->serial);
	49
	50	/* we specify the process's default keyrings */
	51	sprintf(keyring_str[0], "%d",
	52	tsk->thread_keyring ? tsk->thread_keyring->serial : 0);
	53
	54	prkey = 0;
	55	if (tsk->signal->process_keyring)
	56	prkey = tsk->signal->process_keyring->serial;
	57
	58	sskey = 0;
	59	spin_lock_irqsave(&tsk->sighand->siglock, flags);
	60	if (tsk->signal->session_keyring)
	61	sskey = tsk->signal->session_keyring->serial;
	62	spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
	63
	64
65	if (!sskey)
66	sskey = tsk->user->session_keyring->serial;
67
68	sprintf(keyring_str[1], "%d", prkey);
69	sprintf(keyring_str[2], "%d", sskey);
70
71	/* set up a minimal environment */
72	i = 0;
73	envp[i++] = "HOME=/";
74	envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
75	envp[i] = NULL;
76
77	/* set up the argument list */
78	i = 0;
79	argv[i++] = "/sbin/request-key";
80	argv[i++] = (char *) op;
81	argv[i++] = key_str;
82	argv[i++] = uid_str;
83	argv[i++] = gid_str;
84	argv[i++] = keyring_str[0];
85	argv[i++] = keyring_str[1];
86	argv[i++] = keyring_str[2];
87	argv[i++] = callout_info[0] ? (char *) callout_info : "-";
88	argv[i] = NULL;
89
90	/* do it */
7888e7ff	91	return call_usermodehelper_keys(argv[0], argv, envp, NULL, 1);
1da177e4 LT	92
	93	} /* end call_request_key() */
	94
	95	/*****************************************************************************/
	96	/*
	97	* call out to userspace for the key
	98	* - called with the construction sem held, but the sem is dropped here
	99	* - we ignore program failure and go on key status instead
	100	*/
	101	static struct key __request_key_construction(struct key_type type,
	102	const char *description,
	103	const char *callout_info)
	104	{
	105	struct key_construction cons;
	106	struct timespec now;
	107	struct key *key;
76d8aeab	108	int ret, negated;
1da177e4 LT	109
	110	/* create a key and add it to the queue */
	111	key = key_alloc(type, description,
	112	current->fsuid, current->fsgid, KEY_USR_ALL, 0);
	113	if (IS_ERR(key))
	114	goto alloc_failed;
	115
76d8aeab	116	set_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags);
1da177e4 LT	117
	118	cons.key = key;
	119	list_add_tail(&cons.link, &key->user->consq);
	120
	121	/* we drop the construction sem here on behalf of the caller */
	122	up_write(&key_construction_sem);
	123
	124	/* make the call */
	125	ret = call_request_key(key, "create", callout_info);
	126	if (ret < 0)
	127	goto request_failed;
	128
	129	/* if the key wasn't instantiated, then we want to give an error */
	130	ret = -ENOKEY;
76d8aeab	131	if (!test_bit(KEY_FLAG_INSTANTIATED, &key->flags))
1da177e4 LT	132	goto request_failed;
	133
	134	down_write(&key_construction_sem);
	135	list_del(&cons.link);
	136	up_write(&key_construction_sem);
	137
	138	/* also give an error if the key was negatively instantiated */
	139	check_not_negative:
76d8aeab	140	if (test_bit(KEY_FLAG_NEGATIVE, &key->flags)) {
1da177e4 LT	141	key_put(key);
	142	key = ERR_PTR(-ENOKEY);
	143	}
	144
	145	out:
	146	return key;
	147
	148	request_failed:
	149	/* it wasn't instantiated
	150	* - remove from construction queue
	151	* - mark the key as dead
	152	*/
76d8aeab	153	negated = 0;
1da177e4 LT	154	down_write(&key_construction_sem);
	155
	156	list_del(&cons.link);
	157
1da177e4	158	/* check it didn't get instantiated between the check and the down */
76d8aeab DH	159	if (!test_bit(KEY_FLAG_INSTANTIATED, &key->flags)) {
	160	set_bit(KEY_FLAG_NEGATIVE, &key->flags);
	161	set_bit(KEY_FLAG_INSTANTIATED, &key->flags);
	162	negated = 1;
1da177e4 LT	163	}
1da177e4 LT	164
76d8aeab DH	165	clear_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags);
76d8aeab DH	166
1da177e4 LT	167	up_write(&key_construction_sem);
1da177e4 LT	168
76d8aeab	169	if (!negated)
1da177e4 LT	170	goto check_not_negative; /* surprisingly, the key got
	171	* instantiated */
	172
	173	/* set the timeout and store in the session keyring if we can */
	174	now = current_kernel_time();
	175	key->expiry = now.tv_sec + key_negative_timeout;
	176
	177	if (current->signal->session_keyring) {
1da177e4 LT	178	struct key *keyring;
1da177e4 LT	179
8589b4e0 DH	180	rcu_read_lock();
8589b4e0 DH	181	keyring = rcu_dereference(current->signal->session_keyring);
1da177e4	182	atomic_inc(&keyring->usage);
8589b4e0	183	rcu_read_unlock();
1da177e4 LT	184
	185	key_link(keyring, key);
	186	key_put(keyring);
	187	}
	188
	189	key_put(key);
	190
	191	/* notify anyone who was waiting */
	192	wake_up_all(&request_key_conswq);
	193
	194	key = ERR_PTR(ret);
	195	goto out;
	196
	197	alloc_failed:
	198	up_write(&key_construction_sem);
	199	goto out;
	200
	201	} /* end __request_key_construction() */
	202
	203	/*****************************************************************************/
	204	/*
	205	* call out to userspace to request the key
	206	* - we check the construction queue first to see if an appropriate key is
	207	* already being constructed by userspace
	208	*/
	209	static struct key request_key_construction(struct key_type type,
	210	const char *description,
	211	struct key_user *user,
	212	const char *callout_info)
	213	{
	214	struct key_construction *pcons;
	215	struct key key, ckey;
	216
	217	DECLARE_WAITQUEUE(myself, current);
	218
	219	/* see if there's such a key under construction already */
	220	down_write(&key_construction_sem);
	221
	222	list_for_each_entry(pcons, &user->consq, link) {
	223	ckey = pcons->key;
	224
	225	if (ckey->type != type)
	226	continue;
	227
	228	if (type->match(ckey, description))
	229	goto found_key_under_construction;
	230	}
	231
	232	/* see about getting userspace to construct the key */
	233	key = __request_key_construction(type, description, callout_info);
	234	error:
	235	return key;
	236
	237	/* someone else has the same key under construction
	238	* - we want to keep an eye on their key
	239	*/
	240	found_key_under_construction:
	241	atomic_inc(&ckey->usage);
	242	up_write(&key_construction_sem);
	243
	244	/* wait for the key to be completed one way or another */
	245	add_wait_queue(&request_key_conswq, &myself);
	246
	247	for (;;) {
248	set_current_state(TASK_UNINTERRUPTIBLE);
76d8aeab	249	if (!test_bit(KEY_FLAG_USER_CONSTRUCT, &ckey->flags))
1da177e4 LT	250	break;
	251	schedule();
	252	}
	253
	254	set_current_state(TASK_RUNNING);
	255	remove_wait_queue(&request_key_conswq, &myself);
	256
	257	/* we'll need to search this process's keyrings to see if the key is
	258	* now there since we can't automatically assume it's also available
	259	* there */
	260	key_put(ckey);
	261	ckey = NULL;
	262
	263	key = NULL; /* request a retry */
	264	goto error;
	265
	266	} /* end request_key_construction() */
	267
	268	/*****************************************************************************/
	269	/*
	270	* request a key
	271	* - search the process's keyrings
	272	* - check the list of keys being created or updated
	273	* - call out to userspace for a key if requested (supplementary info can be
	274	* passed)
	275	*/
	276	struct key request_key(struct key_type type,
	277	const char *description,
	278	const char *callout_info)
	279	{
	280	struct key_user *user;
	281	struct key *key;
	282
	283	/* search all the process keyrings for a key */
	284	key = search_process_keyrings_aux(type, description, type->match);
	285
	286	if (PTR_ERR(key) == -EAGAIN) {
	287	/* the search failed, but the keyrings were searchable, so we
	288	* should consult userspace if we can */
	289	key = ERR_PTR(-ENOKEY);
	290	if (!callout_info)
	291	goto error;
	292
	293	/* - get hold of the user's construction queue */
	294	user = key_user_lookup(current->fsuid);
	295	if (!user) {
	296	key = ERR_PTR(-ENOMEM);
	297	goto error;
	298	}
	299
	300	for (;;) {
	301	/* ask userspace (returns NULL if it waited on a key
	302	* being constructed) */
	303	key = request_key_construction(type, description,
	304	user, callout_info);
	305	if (key)
	306	break;
	307
	308	/* someone else made the key we want, so we need to
	309	* search again as it might now be available to us */
	310	key = search_process_keyrings_aux(type, description,
	311	type->match);
	312	if (PTR_ERR(key) != -EAGAIN)
	313	break;
314	}
315
316	key_user_put(user);
317	}
318
319	error:
320	return key;
321
322	} /* end request_key() */
323
324	EXPORT_SYMBOL(request_key);
325
326	/*****************************************************************************/
327	/*
328	* validate a key
329	*/
330	int key_validate(struct key *key)
331	{
332	struct timespec now;
333	int ret = 0;
334
335	if (key) {
336	/* check it's still accessible */
337	ret = -EKEYREVOKED;
76d8aeab DH	338	if (test_bit(KEY_FLAG_REVOKED, &key->flags) \|\|
76d8aeab DH	339	test_bit(KEY_FLAG_DEAD, &key->flags))
1da177e4 LT	340	goto error;
	341
	342	/* check it hasn't expired */
	343	ret = 0;
	344	if (key->expiry) {
	345	now = current_kernel_time();
	346	if (now.tv_sec >= key->expiry)
	347	ret = -EKEYEXPIRED;
	348	}
	349	}
	350
	351	error:
	352	return ret;
	353
	354	} /* end key_validate() */
	355
	356	EXPORT_SYMBOL(key_validate);