[net-next-2.6.git] / security / integrity / ima / ima_fs.c

/*
 * Copyright (C) 2005,2006,2007,2008 IBM Corporation
 *
 * Authors:
 * Kylene Hall <kjhall@us.ibm.com>
 * Reiner Sailer <sailer@us.ibm.com>
 * Mimi Zohar <zohar@us.ibm.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, version 2 of the
 * License.
 *
 * File: ima_fs.c
 *	implemenents security file system for reporting
 *	current measurement list and IMA statistics
 */
#include <linux/fcntl.h>
#include <linux/module.h>
#include <linux/seq_file.h>
#include <linux/rculist.h>
#include <linux/rcupdate.h>
#include <linux/parser.h>

#include "ima.h"

static int valid_policy = 1;
#define TMPBUFLEN 12
static ssize_t ima_show_htable_value(char __user *buf, size_t count,
				     loff_t *ppos, atomic_long_t *val)
{
	char tmpbuf[TMPBUFLEN];
	ssize_t len;

	len = scnprintf(tmpbuf, TMPBUFLEN, "%li\n", atomic_long_read(val));
	return simple_read_from_buffer(buf, count, ppos, tmpbuf, len);
}

static ssize_t ima_show_htable_violations(struct file *filp,
					  char __user *buf,
					  size_t count, loff_t *ppos)
{
	return ima_show_htable_value(buf, count, ppos, &ima_htable.violations);
}

static struct file_operations ima_htable_violations_ops = {
	.read = ima_show_htable_violations
};

static ssize_t ima_show_measurements_count(struct file *filp,
					   char __user *buf,
					   size_t count, loff_t *ppos)
{
	return ima_show_htable_value(buf, count, ppos, &ima_htable.len);

}

static struct file_operations ima_measurements_count_ops = {
	.read = ima_show_measurements_count
};

/* returns pointer to hlist_node */
static void *ima_measurements_start(struct seq_file *m, loff_t *pos)
{
	loff_t l = *pos;
	struct ima_queue_entry *qe;

	/* we need a lock since pos could point beyond last element */
	rcu_read_lock();
	list_for_each_entry_rcu(qe, &ima_measurements, later) {
		if (!l--) {
			rcu_read_unlock();
			return qe;
		}
	}
	rcu_read_unlock();
	return NULL;
}

static void *ima_measurements_next(struct seq_file *m, void *v, loff_t *pos)
{
	struct ima_queue_entry *qe = v;

	/* lock protects when reading beyond last element
	 * against concurrent list-extension
	 */
	rcu_read_lock();
	qe = list_entry_rcu(qe->later.next,
			    struct ima_queue_entry, later);
	rcu_read_unlock();
	(*pos)++;

	return (&qe->later == &ima_measurements) ? NULL : qe;
}

static void ima_measurements_stop(struct seq_file *m, void *v)
{
}

static void ima_putc(struct seq_file *m, void *data, int datalen)
{
	while (datalen--)
		seq_putc(m, *(char *)data++);
}

/* print format:
 *       32bit-le=pcr#
 *       char[20]=template digest
 *       32bit-le=template name size
 *       char[n]=template name
 *       eventdata[n]=template specific data
 */
static int ima_measurements_show(struct seq_file *m, void *v)
{
	/* the list never shrinks, so we don't need a lock here */
	struct ima_queue_entry *qe = v;
	struct ima_template_entry *e;
	int namelen;
	u32 pcr = CONFIG_IMA_MEASURE_PCR_IDX;

	/* get entry */
	e = qe->entry;
	if (e == NULL)
		return -1;

	/*
	 * 1st: PCRIndex
	 * PCR used is always the same (config option) in
	 * little-endian format
	 */
	ima_putc(m, &pcr, sizeof pcr);

	/* 2nd: template digest */
	ima_putc(m, e->digest, IMA_DIGEST_SIZE);

	/* 3rd: template name size */
	namelen = strlen(e->template_name);
	ima_putc(m, &namelen, sizeof namelen);

	/* 4th:  template name */
	ima_putc(m, (void *)e->template_name, namelen);

	/* 5th:  template specific data */
	ima_template_show(m, (struct ima_template_data *)&e->template,
			  IMA_SHOW_BINARY);
	return 0;
}

static const struct seq_operations ima_measurments_seqops = {
	.start = ima_measurements_start,
	.next = ima_measurements_next,
	.stop = ima_measurements_stop,
	.show = ima_measurements_show
};

static int ima_measurements_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &ima_measurments_seqops);
}

static struct file_operations ima_measurements_ops = {
	.open = ima_measurements_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = seq_release,
};

static void ima_print_digest(struct seq_file *m, u8 *digest)
{
	int i;

	for (i = 0; i < IMA_DIGEST_SIZE; i++)
		seq_printf(m, "%02x", *(digest + i));
}

void ima_template_show(struct seq_file *m, void *e, enum ima_show_type show)
{
	struct ima_template_data *entry = e;
	int namelen;

	switch (show) {
	case IMA_SHOW_ASCII:
		ima_print_digest(m, entry->digest);
		seq_printf(m, " %s\n", entry->file_name);
		break;
	case IMA_SHOW_BINARY:
		ima_putc(m, entry->digest, IMA_DIGEST_SIZE);

		namelen = strlen(entry->file_name);
		ima_putc(m, &namelen, sizeof namelen);
		ima_putc(m, entry->file_name, namelen);
	default:
		break;
	}
}

/* print in ascii */
static int ima_ascii_measurements_show(struct seq_file *m, void *v)
{
	/* the list never shrinks, so we don't need a lock here */
	struct ima_queue_entry *qe = v;
	struct ima_template_entry *e;

	/* get entry */
	e = qe->entry;
	if (e == NULL)
		return -1;

	/* 1st: PCR used (config option) */
	seq_printf(m, "%2d ", CONFIG_IMA_MEASURE_PCR_IDX);

	/* 2nd: SHA1 template hash */
	ima_print_digest(m, e->digest);

	/* 3th:  template name */
	seq_printf(m, " %s ", e->template_name);

	/* 4th:  template specific data */
	ima_template_show(m, (struct ima_template_data *)&e->template,
			  IMA_SHOW_ASCII);
	return 0;
}

static const struct seq_operations ima_ascii_measurements_seqops = {
	.start = ima_measurements_start,
	.next = ima_measurements_next,
	.stop = ima_measurements_stop,
	.show = ima_ascii_measurements_show
};

static int ima_ascii_measurements_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &ima_ascii_measurements_seqops);
}

static struct file_operations ima_ascii_measurements_ops = {
	.open = ima_ascii_measurements_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = seq_release,
};

static ssize_t ima_write_policy(struct file *file, const char __user *buf,
				size_t datalen, loff_t *ppos)
{
	char *data;
	int rc;

	if (datalen >= PAGE_SIZE)
		return -ENOMEM;
	if (*ppos != 0) {
		/* No partial writes. */
		return -EINVAL;
	}
	data = kmalloc(datalen + 1, GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	if (copy_from_user(data, buf, datalen)) {
		kfree(data);
		return -EFAULT;
	}
	*(data + datalen) = '\0';
	rc = ima_parse_add_rule(data);
	if (rc < 0) {
		datalen = -EINVAL;
		valid_policy = 0;
	}

	kfree(data);
	return datalen;
}

static struct dentry *ima_dir;
static struct dentry *binary_runtime_measurements;
static struct dentry *ascii_runtime_measurements;
static struct dentry *runtime_measurements_count;
static struct dentry *violations;
static struct dentry *ima_policy;

static atomic_t policy_opencount = ATOMIC_INIT(1);
/*
 * ima_open_policy: sequentialize access to the policy file
 */
int ima_open_policy(struct inode * inode, struct file * filp)
{
	/* No point in being allowed to open it if you aren't going to write */
	if (!(filp->f_flags & O_WRONLY))
		return -EACCES;
	if (atomic_dec_and_test(&policy_opencount))
		return 0;
	return -EBUSY;
}

/*
 * ima_release_policy - start using the new measure policy rules.
 *
 * Initially, ima_measure points to the default policy rules, now
 * point to the new policy rules, and remove the securityfs policy file,
 * assuming a valid policy.
 */
static int ima_release_policy(struct inode *inode, struct file *file)
{
	if (!valid_policy) {
		ima_delete_rules();
		valid_policy = 1;
		atomic_set(&policy_opencount, 1);
		return 0;
	}
	ima_update_policy();
	securityfs_remove(ima_policy);
	ima_policy = NULL;
	return 0;
}

static struct file_operations ima_measure_policy_ops = {
	.open = ima_open_policy,
	.write = ima_write_policy,
	.release = ima_release_policy
};

int __init ima_fs_init(void)
{
	ima_dir = securityfs_create_dir("ima", NULL);
	if (IS_ERR(ima_dir))
		return -1;

	binary_runtime_measurements =
	    securityfs_create_file("binary_runtime_measurements",
				   S_IRUSR | S_IRGRP, ima_dir, NULL,
				   &ima_measurements_ops);
	if (IS_ERR(binary_runtime_measurements))
		goto out;

	ascii_runtime_measurements =
	    securityfs_create_file("ascii_runtime_measurements",
				   S_IRUSR | S_IRGRP, ima_dir, NULL,
				   &ima_ascii_measurements_ops);
	if (IS_ERR(ascii_runtime_measurements))
		goto out;

	runtime_measurements_count =
	    securityfs_create_file("runtime_measurements_count",
				   S_IRUSR | S_IRGRP, ima_dir, NULL,
				   &ima_measurements_count_ops);
	if (IS_ERR(runtime_measurements_count))
		goto out;

	violations =
	    securityfs_create_file("violations", S_IRUSR | S_IRGRP,
				   ima_dir, NULL, &ima_htable_violations_ops);
	if (IS_ERR(violations))
		goto out;

	ima_policy = securityfs_create_file("policy",
					    S_IWUSR,
					    ima_dir, NULL,
					    &ima_measure_policy_ops);
	if (IS_ERR(ima_policy))
		goto out;

	return 0;
out:
	securityfs_remove(runtime_measurements_count);
	securityfs_remove(ascii_runtime_measurements);
	securityfs_remove(binary_runtime_measurements);
	securityfs_remove(ima_dir);
	securityfs_remove(ima_policy);
	return -1;
}

void __exit ima_fs_cleanup(void)
{
	securityfs_remove(violations);
	securityfs_remove(runtime_measurements_count);
	securityfs_remove(ascii_runtime_measurements);
	securityfs_remove(binary_runtime_measurements);
	securityfs_remove(ima_dir);
	securityfs_remove(ima_policy);
}
Commit	Line	Data
bab73937 MZ	1	/*
	2	* Copyright (C) 2005,2006,2007,2008 IBM Corporation
	3	*
	4	* Authors:
	5	* Kylene Hall <kjhall@us.ibm.com>
	6	* Reiner Sailer <sailer@us.ibm.com>
	7	* Mimi Zohar <zohar@us.ibm.com>
	8	*
	9	* This program is free software; you can redistribute it and/or
	10	* modify it under the terms of the GNU General Public License as
	11	* published by the Free Software Foundation, version 2 of the
	12	* License.
	13	*
	14	* File: ima_fs.c
	15	* implemenents security file system for reporting
	16	* current measurement list and IMA statistics
	17	*/
f850a7c0	18	#include <linux/fcntl.h>
bab73937 MZ	19	#include <linux/module.h>
	20	#include <linux/seq_file.h>
	21	#include <linux/rculist.h>
	22	#include <linux/rcupdate.h>
4af4662f	23	#include <linux/parser.h>
bab73937 MZ	24
	25	#include "ima.h"
	26
4af4662f	27	static int valid_policy = 1;
bab73937 MZ	28	#define TMPBUFLEN 12
	29	static ssize_t ima_show_htable_value(char __user *buf, size_t count,
	30	loff_t ppos, atomic_long_t val)
	31	{
	32	char tmpbuf[TMPBUFLEN];
	33	ssize_t len;
	34
	35	len = scnprintf(tmpbuf, TMPBUFLEN, "%li\n", atomic_long_read(val));
	36	return simple_read_from_buffer(buf, count, ppos, tmpbuf, len);
	37	}
	38
	39	static ssize_t ima_show_htable_violations(struct file *filp,
	40	char __user *buf,
	41	size_t count, loff_t *ppos)
	42	{
	43	return ima_show_htable_value(buf, count, ppos, &ima_htable.violations);
	44	}
	45
	46	static struct file_operations ima_htable_violations_ops = {
	47	.read = ima_show_htable_violations
	48	};
	49
	50	static ssize_t ima_show_measurements_count(struct file *filp,
	51	char __user *buf,
	52	size_t count, loff_t *ppos)
	53	{
	54	return ima_show_htable_value(buf, count, ppos, &ima_htable.len);
	55
	56	}
	57
	58	static struct file_operations ima_measurements_count_ops = {
	59	.read = ima_show_measurements_count
	60	};
	61
	62	/* returns pointer to hlist_node */
	63	static void ima_measurements_start(struct seq_file m, loff_t *pos)
	64	{
	65	loff_t l = *pos;
	66	struct ima_queue_entry *qe;
	67
	68	/* we need a lock since pos could point beyond last element */
	69	rcu_read_lock();
	70	list_for_each_entry_rcu(qe, &ima_measurements, later) {
	71	if (!l--) {
	72	rcu_read_unlock();
	73	return qe;
	74	}
	75	}
	76	rcu_read_unlock();
	77	return NULL;
	78	}
	79
	80	static void ima_measurements_next(struct seq_file m, void v, loff_t pos)
	81	{
	82	struct ima_queue_entry *qe = v;
	83
	84	/* lock protects when reading beyond last element
	85	* against concurrent list-extension
	86	*/
	87	rcu_read_lock();
05725f7e JP	88	qe = list_entry_rcu(qe->later.next,
05725f7e JP	89	struct ima_queue_entry, later);
bab73937 MZ	90	rcu_read_unlock();
	91	(*pos)++;
	92
	93	return (&qe->later == &ima_measurements) ? NULL : qe;
	94	}
	95
	96	static void ima_measurements_stop(struct seq_file m, void v)
	97	{
	98	}
	99
	100	static void ima_putc(struct seq_file m, void data, int datalen)
	101	{
	102	while (datalen--)
	103	seq_putc(m, (char )data++);
	104	}
	105
	106	/* print format:
	107	* 32bit-le=pcr#
	108	* char[20]=template digest
	109	* 32bit-le=template name size
	110	* char[n]=template name
	111	* eventdata[n]=template specific data
	112	*/
	113	static int ima_measurements_show(struct seq_file m, void v)
	114	{
	115	/* the list never shrinks, so we don't need a lock here */
	116	struct ima_queue_entry *qe = v;
	117	struct ima_template_entry *e;
	118	int namelen;
	119	u32 pcr = CONFIG_IMA_MEASURE_PCR_IDX;
	120
	121	/* get entry */
	122	e = qe->entry;
	123	if (e == NULL)
	124	return -1;
	125
	126	/*
	127	* 1st: PCRIndex
	128	* PCR used is always the same (config option) in
	129	* little-endian format
	130	*/
	131	ima_putc(m, &pcr, sizeof pcr);
	132
	133	/* 2nd: template digest */
	134	ima_putc(m, e->digest, IMA_DIGEST_SIZE);
	135
	136	/* 3rd: template name size */
	137	namelen = strlen(e->template_name);
	138	ima_putc(m, &namelen, sizeof namelen);
	139
	140	/* 4th: template name */
523979ad	141	ima_putc(m, (void *)e->template_name, namelen);
bab73937 MZ	142
	143	/* 5th: template specific data */
	144	ima_template_show(m, (struct ima_template_data *)&e->template,
	145	IMA_SHOW_BINARY);
	146	return 0;
	147	}
	148
88e9d34c	149	static const struct seq_operations ima_measurments_seqops = {
bab73937 MZ	150	.start = ima_measurements_start,
	151	.next = ima_measurements_next,
	152	.stop = ima_measurements_stop,
	153	.show = ima_measurements_show
	154	};
	155
	156	static int ima_measurements_open(struct inode inode, struct file file)
	157	{
	158	return seq_open(file, &ima_measurments_seqops);
	159	}
	160
	161	static struct file_operations ima_measurements_ops = {
	162	.open = ima_measurements_open,
	163	.read = seq_read,
	164	.llseek = seq_lseek,
	165	.release = seq_release,
	166	};
	167
	168	static void ima_print_digest(struct seq_file m, u8 digest)
	169	{
	170	int i;
	171
	172	for (i = 0; i < IMA_DIGEST_SIZE; i++)
	173	seq_printf(m, "%02x", *(digest + i));
	174	}
	175
	176	void ima_template_show(struct seq_file m, void e, enum ima_show_type show)
	177	{
	178	struct ima_template_data *entry = e;
	179	int namelen;
	180
	181	switch (show) {
	182	case IMA_SHOW_ASCII:
	183	ima_print_digest(m, entry->digest);
	184	seq_printf(m, " %s\n", entry->file_name);
	185	break;
	186	case IMA_SHOW_BINARY:
	187	ima_putc(m, entry->digest, IMA_DIGEST_SIZE);
	188
	189	namelen = strlen(entry->file_name);
	190	ima_putc(m, &namelen, sizeof namelen);
	191	ima_putc(m, entry->file_name, namelen);
	192	default:
	193	break;
	194	}
	195	}
	196
	197	/* print in ascii */
	198	static int ima_ascii_measurements_show(struct seq_file m, void v)
	199	{
	200	/* the list never shrinks, so we don't need a lock here */
	201	struct ima_queue_entry *qe = v;
	202	struct ima_template_entry *e;
	203
	204	/* get entry */
	205	e = qe->entry;
	206	if (e == NULL)
	207	return -1;
	208
	209	/* 1st: PCR used (config option) */
	210	seq_printf(m, "%2d ", CONFIG_IMA_MEASURE_PCR_IDX);
	211
	212	/* 2nd: SHA1 template hash */
	213	ima_print_digest(m, e->digest);
214
215	/* 3th: template name */
216	seq_printf(m, " %s ", e->template_name);
217
218	/* 4th: template specific data */
219	ima_template_show(m, (struct ima_template_data *)&e->template,
220	IMA_SHOW_ASCII);
221	return 0;
222	}
223
88e9d34c	224	static const struct seq_operations ima_ascii_measurements_seqops = {
bab73937 MZ	225	.start = ima_measurements_start,
	226	.next = ima_measurements_next,
	227	.stop = ima_measurements_stop,
	228	.show = ima_ascii_measurements_show
	229	};
	230
	231	static int ima_ascii_measurements_open(struct inode inode, struct file file)
	232	{
	233	return seq_open(file, &ima_ascii_measurements_seqops);
	234	}
	235
	236	static struct file_operations ima_ascii_measurements_ops = {
	237	.open = ima_ascii_measurements_open,
	238	.read = seq_read,
	239	.llseek = seq_lseek,
	240	.release = seq_release,
	241	};
	242
4af4662f MZ	243	static ssize_t ima_write_policy(struct file file, const char __user buf,
	244	size_t datalen, loff_t *ppos)
	245	{
	246	char *data;
	247	int rc;
	248
	249	if (datalen >= PAGE_SIZE)
	250	return -ENOMEM;
	251	if (*ppos != 0) {
	252	/* No partial writes. */
	253	return -EINVAL;
	254	}
	255	data = kmalloc(datalen + 1, GFP_KERNEL);
	256	if (!data)
	257	return -ENOMEM;
	258
	259	if (copy_from_user(data, buf, datalen)) {
	260	kfree(data);
	261	return -EFAULT;
	262	}
	263	*(data + datalen) = '\0';
	264	rc = ima_parse_add_rule(data);
	265	if (rc < 0) {
	266	datalen = -EINVAL;
	267	valid_policy = 0;
	268	}
	269
	270	kfree(data);
	271	return datalen;
	272	}
	273
bab73937 MZ	274	static struct dentry *ima_dir;
	275	static struct dentry *binary_runtime_measurements;
	276	static struct dentry *ascii_runtime_measurements;
	277	static struct dentry *runtime_measurements_count;
	278	static struct dentry *violations;
4af4662f MZ	279	static struct dentry *ima_policy;
4af4662f MZ	280
f4bd857b MZ	281	static atomic_t policy_opencount = ATOMIC_INIT(1);
	282	/*
	283	* ima_open_policy: sequentialize access to the policy file
	284	*/
	285	int ima_open_policy(struct inode * inode, struct file * filp)
	286	{
f850a7c0 EP	287	/* No point in being allowed to open it if you aren't going to write */
	288	if (!(filp->f_flags & O_WRONLY))
	289	return -EACCES;
f4bd857b MZ	290	if (atomic_dec_and_test(&policy_opencount))
	291	return 0;
	292	return -EBUSY;
	293	}
	294
4af4662f MZ	295	/*
	296	* ima_release_policy - start using the new measure policy rules.
	297	*
	298	* Initially, ima_measure points to the default policy rules, now
f4bd857b MZ	299	* point to the new policy rules, and remove the securityfs policy file,
f4bd857b MZ	300	* assuming a valid policy.
4af4662f MZ	301	*/
	302	static int ima_release_policy(struct inode inode, struct file file)
	303	{
	304	if (!valid_policy) {
	305	ima_delete_rules();
f4bd857b MZ	306	valid_policy = 1;
f4bd857b MZ	307	atomic_set(&policy_opencount, 1);
4af4662f MZ	308	return 0;
	309	}
	310	ima_update_policy();
	311	securityfs_remove(ima_policy);
	312	ima_policy = NULL;
	313	return 0;
	314	}
	315
	316	static struct file_operations ima_measure_policy_ops = {
f4bd857b	317	.open = ima_open_policy,
4af4662f MZ	318	.write = ima_write_policy,
	319	.release = ima_release_policy
	320	};
bab73937	321
932995f0	322	int __init ima_fs_init(void)
bab73937 MZ	323	{
	324	ima_dir = securityfs_create_dir("ima", NULL);
	325	if (IS_ERR(ima_dir))
	326	return -1;
	327
	328	binary_runtime_measurements =
	329	securityfs_create_file("binary_runtime_measurements",
	330	S_IRUSR \| S_IRGRP, ima_dir, NULL,
	331	&ima_measurements_ops);
	332	if (IS_ERR(binary_runtime_measurements))
	333	goto out;
	334
	335	ascii_runtime_measurements =
	336	securityfs_create_file("ascii_runtime_measurements",
	337	S_IRUSR \| S_IRGRP, ima_dir, NULL,
	338	&ima_ascii_measurements_ops);
	339	if (IS_ERR(ascii_runtime_measurements))
	340	goto out;
	341
	342	runtime_measurements_count =
	343	securityfs_create_file("runtime_measurements_count",
	344	S_IRUSR \| S_IRGRP, ima_dir, NULL,
	345	&ima_measurements_count_ops);
	346	if (IS_ERR(runtime_measurements_count))
	347	goto out;
	348
	349	violations =
	350	securityfs_create_file("violations", S_IRUSR \| S_IRGRP,
	351	ima_dir, NULL, &ima_htable_violations_ops);
	352	if (IS_ERR(violations))
	353	goto out;
	354
4af4662f	355	ima_policy = securityfs_create_file("policy",
f850a7c0	356	S_IWUSR,
4af4662f MZ	357	ima_dir, NULL,
	358	&ima_measure_policy_ops);
	359	if (IS_ERR(ima_policy))
	360	goto out;
bab73937	361
4af4662f	362	return 0;
bab73937 MZ	363	out:
	364	securityfs_remove(runtime_measurements_count);
	365	securityfs_remove(ascii_runtime_measurements);
	366	securityfs_remove(binary_runtime_measurements);
	367	securityfs_remove(ima_dir);
4af4662f	368	securityfs_remove(ima_policy);
bab73937 MZ	369	return -1;
	370	}
	371
	372	void __exit ima_fs_cleanup(void)
	373	{
	374	securityfs_remove(violations);
	375	securityfs_remove(runtime_measurements_count);
	376	securityfs_remove(ascii_runtime_measurements);
	377	securityfs_remove(binary_runtime_measurements);
	378	securityfs_remove(ima_dir);
4af4662f	379	securityfs_remove(ima_policy);
bab73937	380	}