[linux-2.6-block.git] / security / keys / proc.c

/* procfs files for key database enumeration
 *
 * 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/init.h>
#include <linux/sched.h>
#include <linux/fs.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <asm/errno.h>
#include "internal.h"

static void *proc_keys_start(struct seq_file *p, loff_t *_pos);
static void *proc_keys_next(struct seq_file *p, void *v, loff_t *_pos);
static void proc_keys_stop(struct seq_file *p, void *v);
static int proc_keys_show(struct seq_file *m, void *v);

static const struct seq_operations proc_keys_ops = {
	.start	= proc_keys_start,
	.next	= proc_keys_next,
	.stop	= proc_keys_stop,
	.show	= proc_keys_show,
};

static void *proc_key_users_start(struct seq_file *p, loff_t *_pos);
static void *proc_key_users_next(struct seq_file *p, void *v, loff_t *_pos);
static void proc_key_users_stop(struct seq_file *p, void *v);
static int proc_key_users_show(struct seq_file *m, void *v);

static const struct seq_operations proc_key_users_ops = {
	.start	= proc_key_users_start,
	.next	= proc_key_users_next,
	.stop	= proc_key_users_stop,
	.show	= proc_key_users_show,
};

/*
 * Declare the /proc files.
 */
static int __init key_proc_init(void)
{
	struct proc_dir_entry *p;

	p = proc_create_seq("keys", 0, NULL, &proc_keys_ops);
	if (!p)
		panic("Cannot create /proc/keys\n");

	p = proc_create_seq("key-users", 0, NULL, &proc_key_users_ops);
	if (!p)
		panic("Cannot create /proc/key-users\n");

	return 0;
}

__initcall(key_proc_init);

/*
 * Implement "/proc/keys" to provide a list of the keys on the system that
 * grant View permission to the caller.
 */
static struct rb_node *key_serial_next(struct seq_file *p, struct rb_node *n)
{
	struct user_namespace *user_ns = seq_user_ns(p);

	n = rb_next(n);
	while (n) {
		struct key *key = rb_entry(n, struct key, serial_node);
		if (kuid_has_mapping(user_ns, key->user->uid))
			break;
		n = rb_next(n);
	}
	return n;
}

static struct key *find_ge_key(struct seq_file *p, key_serial_t id)
{
	struct user_namespace *user_ns = seq_user_ns(p);
	struct rb_node *n = key_serial_tree.rb_node;
	struct key *minkey = NULL;

	while (n) {
		struct key *key = rb_entry(n, struct key, serial_node);
		if (id < key->serial) {
			if (!minkey || minkey->serial > key->serial)
				minkey = key;
			n = n->rb_left;
		} else if (id > key->serial) {
			n = n->rb_right;
		} else {
			minkey = key;
			break;
		}
		key = NULL;
	}

	if (!minkey)
		return NULL;

	for (;;) {
		if (kuid_has_mapping(user_ns, minkey->user->uid))
			return minkey;
		n = rb_next(&minkey->serial_node);
		if (!n)
			return NULL;
		minkey = rb_entry(n, struct key, serial_node);
	}
}

static void *proc_keys_start(struct seq_file *p, loff_t *_pos)
	__acquires(key_serial_lock)
{
	key_serial_t pos = *_pos;
	struct key *key;

	spin_lock(&key_serial_lock);

	if (*_pos > INT_MAX)
		return NULL;
	key = find_ge_key(p, pos);
	if (!key)
		return NULL;
	*_pos = key->serial;
	return &key->serial_node;
}

static inline key_serial_t key_node_serial(struct rb_node *n)
{
	struct key *key = rb_entry(n, struct key, serial_node);
	return key->serial;
}

static void *proc_keys_next(struct seq_file *p, void *v, loff_t *_pos)
{
	struct rb_node *n;

	n = key_serial_next(p, v);
	if (n)
		*_pos = key_node_serial(n);
	return n;
}

static void proc_keys_stop(struct seq_file *p, void *v)
	__releases(key_serial_lock)
{
	spin_unlock(&key_serial_lock);
}

static int proc_keys_show(struct seq_file *m, void *v)
{
	struct rb_node *_p = v;
	struct key *key = rb_entry(_p, struct key, serial_node);
	unsigned long flags;
	key_ref_t key_ref, skey_ref;
	time64_t now, expiry;
	char xbuf[16];
	short state;
	u64 timo;
	int rc;

	struct keyring_search_context ctx = {
		.index_key.type		= key->type,
		.index_key.description	= key->description,
		.cred			= m->file->f_cred,
		.match_data.cmp		= lookup_user_key_possessed,
		.match_data.raw_data	= key,
		.match_data.lookup_type	= KEYRING_SEARCH_LOOKUP_DIRECT,
		.flags			= KEYRING_SEARCH_NO_STATE_CHECK,
	};

	key_ref = make_key_ref(key, 0);

	/* determine if the key is possessed by this process (a test we can
	 * skip if the key does not indicate the possessor can view it
	 */
	if (key->perm & KEY_POS_VIEW) {
		skey_ref = search_my_process_keyrings(&ctx);
		if (!IS_ERR(skey_ref)) {
			key_ref_put(skey_ref);
			key_ref = make_key_ref(key, 1);
		}
	}

	/* check whether the current task is allowed to view the key */
	rc = key_task_permission(key_ref, ctx.cred, KEY_NEED_VIEW);
	if (rc < 0)
		return 0;

	now = ktime_get_real_seconds();

	rcu_read_lock();

	/* come up with a suitable timeout value */
	expiry = READ_ONCE(key->expiry);
	if (expiry == 0) {
		memcpy(xbuf, "perm", 5);
	} else if (now >= expiry) {
		memcpy(xbuf, "expd", 5);
	} else {
		timo = expiry - now;

		if (timo < 60)
			sprintf(xbuf, "%llus", timo);
		else if (timo < 60*60)
			sprintf(xbuf, "%llum", div_u64(timo, 60));
		else if (timo < 60*60*24)
			sprintf(xbuf, "%lluh", div_u64(timo, 60 * 60));
		else if (timo < 60*60*24*7)
			sprintf(xbuf, "%llud", div_u64(timo, 60 * 60 * 24));
		else
			sprintf(xbuf, "%lluw", div_u64(timo, 60 * 60 * 24 * 7));
	}

	state = key_read_state(key);

#define showflag(FLAGS, LETTER, FLAG) \
	((FLAGS & (1 << FLAG)) ? LETTER : '-')

	flags = READ_ONCE(key->flags);
	seq_printf(m, "%08x %c%c%c%c%c%c%c %5d %4s %08x %5d %5d %-9.9s ",
		   key->serial,
		   state != KEY_IS_UNINSTANTIATED ? 'I' : '-',
		   showflag(flags, 'R', KEY_FLAG_REVOKED),
		   showflag(flags, 'D', KEY_FLAG_DEAD),
		   showflag(flags, 'Q', KEY_FLAG_IN_QUOTA),
		   showflag(flags, 'U', KEY_FLAG_USER_CONSTRUCT),
		   state < 0 ? 'N' : '-',
		   showflag(flags, 'i', KEY_FLAG_INVALIDATED),
		   refcount_read(&key->usage),
		   xbuf,
		   key->perm,
		   from_kuid_munged(seq_user_ns(m), key->uid),
		   from_kgid_munged(seq_user_ns(m), key->gid),
		   key->type->name);

#undef showflag

	if (key->type->describe)
		key->type->describe(key, m);
	seq_putc(m, '\n');

	rcu_read_unlock();
	return 0;
}

static struct rb_node *__key_user_next(struct user_namespace *user_ns, struct rb_node *n)
{
	while (n) {
		struct key_user *user = rb_entry(n, struct key_user, node);
		if (kuid_has_mapping(user_ns, user->uid))
			break;
		n = rb_next(n);
	}
	return n;
}

static struct rb_node *key_user_next(struct user_namespace *user_ns, struct rb_node *n)
{
	return __key_user_next(user_ns, rb_next(n));
}

static struct rb_node *key_user_first(struct user_namespace *user_ns, struct rb_root *r)
{
	struct rb_node *n = rb_first(r);
	return __key_user_next(user_ns, n);
}

static void *proc_key_users_start(struct seq_file *p, loff_t *_pos)
	__acquires(key_user_lock)
{
	struct rb_node *_p;
	loff_t pos = *_pos;

	spin_lock(&key_user_lock);

	_p = key_user_first(seq_user_ns(p), &key_user_tree);
	while (pos > 0 && _p) {
		pos--;
		_p = key_user_next(seq_user_ns(p), _p);
	}

	return _p;
}

static void *proc_key_users_next(struct seq_file *p, void *v, loff_t *_pos)
{
	(*_pos)++;
	return key_user_next(seq_user_ns(p), (struct rb_node *)v);
}

static void proc_key_users_stop(struct seq_file *p, void *v)
	__releases(key_user_lock)
{
	spin_unlock(&key_user_lock);
}

static int proc_key_users_show(struct seq_file *m, void *v)
{
	struct rb_node *_p = v;
	struct key_user *user = rb_entry(_p, struct key_user, node);
	unsigned maxkeys = uid_eq(user->uid, GLOBAL_ROOT_UID) ?
		key_quota_root_maxkeys : key_quota_maxkeys;
	unsigned maxbytes = uid_eq(user->uid, GLOBAL_ROOT_UID) ?
		key_quota_root_maxbytes : key_quota_maxbytes;

	seq_printf(m, "%5u: %5d %d/%d %d/%d %d/%d\n",
		   from_kuid_munged(seq_user_ns(m), user->uid),
		   refcount_read(&user->usage),
		   atomic_read(&user->nkeys),
		   atomic_read(&user->nikeys),
		   user->qnkeys,
		   maxkeys,
		   user->qnbytes,
		   maxbytes);

	return 0;
}
Commit	Line	Data
973c9f4f	1	/* procfs files for key database enumeration
1da177e4 LT	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
1da177e4 LT	12	#include <linux/init.h>
1da177e4 LT	13	#include <linux/sched.h>
1da177e4 LT	14	#include <linux/fs.h>
	15	#include <linux/proc_fs.h>
	16	#include <linux/seq_file.h>
	17	#include <asm/errno.h>
	18	#include "internal.h"
	19
1da177e4 LT	20	static void proc_keys_start(struct seq_file p, loff_t *_pos);
	21	static void proc_keys_next(struct seq_file p, void v, loff_t _pos);
	22	static void proc_keys_stop(struct seq_file p, void v);
	23	static int proc_keys_show(struct seq_file m, void v);
	24
1996a109	25	static const struct seq_operations proc_keys_ops = {
1da177e4 LT	26	.start = proc_keys_start,
	27	.next = proc_keys_next,
	28	.stop = proc_keys_stop,
	29	.show = proc_keys_show,
	30	};
	31
1da177e4 LT	32	static void proc_key_users_start(struct seq_file p, loff_t *_pos);
	33	static void proc_key_users_next(struct seq_file p, void v, loff_t _pos);
	34	static void proc_key_users_stop(struct seq_file p, void v);
	35	static int proc_key_users_show(struct seq_file m, void v);
	36
1996a109	37	static const struct seq_operations proc_key_users_ops = {
1da177e4 LT	38	.start = proc_key_users_start,
	39	.next = proc_key_users_next,
	40	.stop = proc_key_users_stop,
	41	.show = proc_key_users_show,
	42	};
	43
1da177e4	44	/*
973c9f4f	45	* Declare the /proc files.
1da177e4 LT	46	*/
	47	static int __init key_proc_init(void)
	48	{
	49	struct proc_dir_entry *p;
	50
fddda2b7	51	p = proc_create_seq("keys", 0, NULL, &proc_keys_ops);
1da177e4 LT	52	if (!p)
1da177e4 LT	53	panic("Cannot create /proc/keys\n");
1da177e4	54
fddda2b7	55	p = proc_create_seq("key-users", 0, NULL, &proc_key_users_ops);
1da177e4 LT	56	if (!p)
	57	panic("Cannot create /proc/key-users\n");
	58
1da177e4	59	return 0;
a8b17ed0	60	}
1da177e4 LT	61
	62	__initcall(key_proc_init);
	63
1da177e4	64	/*
973c9f4f DH	65	* Implement "/proc/keys" to provide a list of the keys on the system that
973c9f4f DH	66	* grant View permission to the caller.
1da177e4	67	*/
9a56c2db	68	static struct rb_node key_serial_next(struct seq_file p, struct rb_node *n)
454804ab	69	{
9a56c2db	70	struct user_namespace *user_ns = seq_user_ns(p);
ad73a717 SH	71
ad73a717 SH	72	n = rb_next(n);
454804ab SH	73	while (n) {
454804ab SH	74	struct key *key = rb_entry(n, struct key, serial_node);
9a56c2db	75	if (kuid_has_mapping(user_ns, key->user->uid))
454804ab SH	76	break;
	77	n = rb_next(n);
	78	}
	79	return n;
	80	}
	81
9a56c2db	82	static struct key find_ge_key(struct seq_file p, key_serial_t id)
454804ab	83	{
9a56c2db	84	struct user_namespace *user_ns = seq_user_ns(p);
ad73a717 SH	85	struct rb_node *n = key_serial_tree.rb_node;
ad73a717 SH	86	struct key *minkey = NULL;
454804ab	87
ad73a717 SH	88	while (n) {
	89	struct key *key = rb_entry(n, struct key, serial_node);
	90	if (id < key->serial) {
	91	if (!minkey \|\| minkey->serial > key->serial)
	92	minkey = key;
	93	n = n->rb_left;
	94	} else if (id > key->serial) {
	95	n = n->rb_right;
	96	} else {
	97	minkey = key;
	98	break;
	99	}
	100	key = NULL;
	101	}
1da177e4	102
ad73a717 SH	103	if (!minkey)
	104	return NULL;
	105
	106	for (;;) {
9a56c2db	107	if (kuid_has_mapping(user_ns, minkey->user->uid))
ad73a717 SH	108	return minkey;
	109	n = rb_next(&minkey->serial_node);
	110	if (!n)
	111	return NULL;
	112	minkey = rb_entry(n, struct key, serial_node);
	113	}
1da177e4 LT	114	}
	115
	116	static void proc_keys_start(struct seq_file p, loff_t *_pos)
86abcf9c	117	__acquires(key_serial_lock)
1da177e4	118	{
ad73a717 SH	119	key_serial_t pos = *_pos;
ad73a717 SH	120	struct key *key;
1da177e4 LT	121
	122	spin_lock(&key_serial_lock);
	123
ad73a717 SH	124	if (*_pos > INT_MAX)
ad73a717 SH	125	return NULL;
9a56c2db	126	key = find_ge_key(p, pos);
ad73a717 SH	127	if (!key)
	128	return NULL;
	129	*_pos = key->serial;
	130	return &key->serial_node;
	131	}
1da177e4	132
ad73a717 SH	133	static inline key_serial_t key_node_serial(struct rb_node *n)
	134	{
	135	struct key *key = rb_entry(n, struct key, serial_node);
	136	return key->serial;
1da177e4 LT	137	}
	138
	139	static void proc_keys_next(struct seq_file p, void v, loff_t _pos)
	140	{
ad73a717	141	struct rb_node *n;
1da177e4	142
9a56c2db	143	n = key_serial_next(p, v);
ad73a717 SH	144	if (n)
	145	*_pos = key_node_serial(n);
	146	return n;
1da177e4 LT	147	}
	148
	149	static void proc_keys_stop(struct seq_file p, void v)
86abcf9c	150	__releases(key_serial_lock)
1da177e4 LT	151	{
	152	spin_unlock(&key_serial_lock);
	153	}
	154
	155	static int proc_keys_show(struct seq_file m, void v)
	156	{
	157	struct rb_node *_p = v;
	158	struct key *key = rb_entry(_p, struct key, serial_node);
ab5c69f0	159	unsigned long flags;
927942aa	160	key_ref_t key_ref, skey_ref;
074d5898	161	time64_t now, expiry;
03dab869	162	char xbuf[16];
363b02da	163	short state;
074d5898	164	u64 timo;
06ec7be5 ML	165	int rc;
06ec7be5 ML	166
4bdf0bc3 DH	167	struct keyring_search_context ctx = {
	168	.index_key.type = key->type,
	169	.index_key.description = key->description,
4aa68e07	170	.cred = m->file->f_cred,
46291959 DH	171	.match_data.cmp = lookup_user_key_possessed,
	172	.match_data.raw_data = key,
	173	.match_data.lookup_type = KEYRING_SEARCH_LOOKUP_DIRECT,
	174	.flags = KEYRING_SEARCH_NO_STATE_CHECK,
4bdf0bc3 DH	175	};
4bdf0bc3 DH	176
927942aa DH	177	key_ref = make_key_ref(key, 0);
	178
	179	/* determine if the key is possessed by this process (a test we can
	180	* skip if the key does not indicate the possessor can view it
	181	*/
	182	if (key->perm & KEY_POS_VIEW) {
4bdf0bc3	183	skey_ref = search_my_process_keyrings(&ctx);
927942aa DH	184	if (!IS_ERR(skey_ref)) {
	185	key_ref_put(skey_ref);
	186	key_ref = make_key_ref(key, 1);
	187	}
	188	}
	189
4aa68e07	190	/* check whether the current task is allowed to view the key */
f5895943	191	rc = key_task_permission(key_ref, ctx.cred, KEY_NEED_VIEW);
06ec7be5 ML	192	if (rc < 0)
06ec7be5 ML	193	return 0;
1da177e4	194
074d5898	195	now = ktime_get_real_seconds();
1da177e4	196
76d8aeab	197	rcu_read_lock();
1da177e4 LT	198
1da177e4 LT	199	/* come up with a suitable timeout value */
ab5c69f0 EB	200	expiry = READ_ONCE(key->expiry);
ab5c69f0 EB	201	if (expiry == 0) {
1da177e4	202	memcpy(xbuf, "perm", 5);
074d5898	203	} else if (now >= expiry) {
1da177e4	204	memcpy(xbuf, "expd", 5);
7b1b9164	205	} else {
074d5898	206	timo = expiry - now;
1da177e4 LT	207
1da177e4 LT	208	if (timo < 60)
074d5898	209	sprintf(xbuf, "%llus", timo);
1da177e4	210	else if (timo < 60*60)
074d5898	211	sprintf(xbuf, "%llum", div_u64(timo, 60));
1da177e4	212	else if (timo < 606024)
074d5898	213	sprintf(xbuf, "%lluh", div_u64(timo, 60 * 60));
1da177e4	214	else if (timo < 606024*7)
074d5898	215	sprintf(xbuf, "%llud", div_u64(timo, 60 * 60 * 24));
1da177e4	216	else
074d5898	217	sprintf(xbuf, "%lluw", div_u64(timo, 60 * 60 * 24 * 7));
1da177e4 LT	218	}
1da177e4 LT	219
363b02da DH	220	state = key_read_state(key);
363b02da DH	221
ab5c69f0 EB	222	#define showflag(FLAGS, LETTER, FLAG) \
ab5c69f0 EB	223	((FLAGS & (1 << FLAG)) ? LETTER : '-')
76d8aeab	224
ab5c69f0	225	flags = READ_ONCE(key->flags);
fd75815f	226	seq_printf(m, "%08x %c%c%c%c%c%c%c %5d %4s %08x %5d %5d %-9.9s ",
1da177e4	227	key->serial,
363b02da	228	state != KEY_IS_UNINSTANTIATED ? 'I' : '-',
ab5c69f0 EB	229	showflag(flags, 'R', KEY_FLAG_REVOKED),
	230	showflag(flags, 'D', KEY_FLAG_DEAD),
	231	showflag(flags, 'Q', KEY_FLAG_IN_QUOTA),
	232	showflag(flags, 'U', KEY_FLAG_USER_CONSTRUCT),
363b02da	233	state < 0 ? 'N' : '-',
ab5c69f0	234	showflag(flags, 'i', KEY_FLAG_INVALIDATED),
fff29291	235	refcount_read(&key->usage),
1da177e4 LT	236	xbuf,
1da177e4 LT	237	key->perm,
9a56c2db EB	238	from_kuid_munged(seq_user_ns(m), key->uid),
9a56c2db EB	239	from_kgid_munged(seq_user_ns(m), key->gid),
1da177e4 LT	240	key->type->name);
1da177e4 LT	241
76d8aeab DH	242	#undef showflag
76d8aeab DH	243
1da177e4 LT	244	if (key->type->describe)
	245	key->type->describe(key, m);
	246	seq_putc(m, '\n');
	247
76d8aeab	248	rcu_read_unlock();
1da177e4	249	return 0;
1da177e4 LT	250	}
1da177e4 LT	251
9a56c2db	252	static struct rb_node __key_user_next(struct user_namespace user_ns, struct rb_node *n)
454804ab SH	253	{
	254	while (n) {
	255	struct key_user *user = rb_entry(n, struct key_user, node);
9a56c2db	256	if (kuid_has_mapping(user_ns, user->uid))
454804ab SH	257	break;
	258	n = rb_next(n);
	259	}
	260	return n;
	261	}
	262
9a56c2db	263	static struct rb_node key_user_next(struct user_namespace user_ns, struct rb_node *n)
454804ab	264	{
9a56c2db	265	return __key_user_next(user_ns, rb_next(n));
454804ab SH	266	}
454804ab SH	267
9a56c2db	268	static struct rb_node key_user_first(struct user_namespace user_ns, struct rb_root *r)
454804ab SH	269	{
454804ab SH	270	struct rb_node *n = rb_first(r);
9a56c2db	271	return __key_user_next(user_ns, n);
454804ab	272	}
7b1b9164	273
1da177e4	274	static void proc_key_users_start(struct seq_file p, loff_t *_pos)
86abcf9c	275	__acquires(key_user_lock)
1da177e4 LT	276	{
	277	struct rb_node *_p;
	278	loff_t pos = *_pos;
	279
	280	spin_lock(&key_user_lock);
	281
9a56c2db	282	_p = key_user_first(seq_user_ns(p), &key_user_tree);
1da177e4 LT	283	while (pos > 0 && _p) {
1da177e4 LT	284	pos--;
9a56c2db	285	_p = key_user_next(seq_user_ns(p), _p);
1da177e4 LT	286	}
	287
	288	return _p;
1da177e4 LT	289	}
	290
	291	static void proc_key_users_next(struct seq_file p, void v, loff_t _pos)
	292	{
	293	(*_pos)++;
9a56c2db	294	return key_user_next(seq_user_ns(p), (struct rb_node *)v);
1da177e4 LT	295	}
	296
	297	static void proc_key_users_stop(struct seq_file p, void v)
86abcf9c	298	__releases(key_user_lock)
1da177e4 LT	299	{
	300	spin_unlock(&key_user_lock);
	301	}
	302
	303	static int proc_key_users_show(struct seq_file m, void v)
	304	{
	305	struct rb_node *_p = v;
	306	struct key_user *user = rb_entry(_p, struct key_user, node);
9a56c2db	307	unsigned maxkeys = uid_eq(user->uid, GLOBAL_ROOT_UID) ?
0b77f5bf	308	key_quota_root_maxkeys : key_quota_maxkeys;
9a56c2db	309	unsigned maxbytes = uid_eq(user->uid, GLOBAL_ROOT_UID) ?
0b77f5bf	310	key_quota_root_maxbytes : key_quota_maxbytes;
1da177e4 LT	311
1da177e4 LT	312	seq_printf(m, "%5u: %5d %d/%d %d/%d %d/%d\n",
9a56c2db	313	from_kuid_munged(seq_user_ns(m), user->uid),
ddb99e11	314	refcount_read(&user->usage),
1da177e4 LT	315	atomic_read(&user->nkeys),
	316	atomic_read(&user->nikeys),
	317	user->qnkeys,
0b77f5bf	318	maxkeys,
1da177e4	319	user->qnbytes,
0b77f5bf	320	maxbytes);
1da177e4 LT	321
1da177e4 LT	322	return 0;
1da177e4	323	}