[mirror_ubuntu-kernels.git] / security / integrity / ima / ima_queue.c

/*
 * Copyright (C) 2005,2006,2007,2008 IBM Corporation
 *
 * Authors:
 * Serge Hallyn <serue@us.ibm.com>
 * Reiner Sailer <sailer@watson.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_queue.c
 *       Implements queues that store template measurements and
 *       maintains aggregate over the stored measurements
 *       in the pre-configured TPM PCR (if available).
 *       The measurement list is append-only. No entry is
 *       ever removed or changed during the boot-cycle.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/rculist.h>
#include <linux/slab.h>
#include "ima.h"

#define AUDIT_CAUSE_LEN_MAX 32

/* pre-allocated array of tpm_digest structures to extend a PCR */
static struct tpm_digest *digests;

LIST_HEAD(ima_measurements);	/* list of all measurements */
#ifdef CONFIG_IMA_KEXEC
static unsigned long binary_runtime_size;
#else
static unsigned long binary_runtime_size = ULONG_MAX;
#endif

/* key: inode (before secure-hashing a file) */
struct ima_h_table ima_htable = {
	.len = ATOMIC_LONG_INIT(0),
	.violations = ATOMIC_LONG_INIT(0),
	.queue[0 ... IMA_MEASURE_HTABLE_SIZE - 1] = HLIST_HEAD_INIT
};

/* mutex protects atomicity of extending measurement list
 * and extending the TPM PCR aggregate. Since tpm_extend can take
 * long (and the tpm driver uses a mutex), we can't use the spinlock.
 */
static DEFINE_MUTEX(ima_extend_list_mutex);

/* lookup up the digest value in the hash table, and return the entry */
static struct ima_queue_entry *ima_lookup_digest_entry(u8 *digest_value,
						       int pcr)
{
	struct ima_queue_entry *qe, *ret = NULL;
	unsigned int key;
	int rc;

	key = ima_hash_key(digest_value);
	rcu_read_lock();
	hlist_for_each_entry_rcu(qe, &ima_htable.queue[key], hnext) {
		rc = memcmp(qe->entry->digest, digest_value, TPM_DIGEST_SIZE);
		if ((rc == 0) && (qe->entry->pcr == pcr)) {
			ret = qe;
			break;
		}
	}
	rcu_read_unlock();
	return ret;
}

/*
 * Calculate the memory required for serializing a single
 * binary_runtime_measurement list entry, which contains a
 * couple of variable length fields (e.g template name and data).
 */
static int get_binary_runtime_size(struct ima_template_entry *entry)
{
	int size = 0;

	size += sizeof(u32);	/* pcr */
	size += sizeof(entry->digest);
	size += sizeof(int);	/* template name size field */
	size += strlen(entry->template_desc->name);
	size += sizeof(entry->template_data_len);
	size += entry->template_data_len;
	return size;
}

/* ima_add_template_entry helper function:
 * - Add template entry to the measurement list and hash table, for
 *   all entries except those carried across kexec.
 *
 * (Called with ima_extend_list_mutex held.)
 */
static int ima_add_digest_entry(struct ima_template_entry *entry,
				bool update_htable)
{
	struct ima_queue_entry *qe;
	unsigned int key;

	qe = kmalloc(sizeof(*qe), GFP_KERNEL);
	if (qe == NULL) {
		pr_err("OUT OF MEMORY ERROR creating queue entry\n");
		return -ENOMEM;
	}
	qe->entry = entry;

	INIT_LIST_HEAD(&qe->later);
	list_add_tail_rcu(&qe->later, &ima_measurements);

	atomic_long_inc(&ima_htable.len);
	if (update_htable) {
		key = ima_hash_key(entry->digest);
		hlist_add_head_rcu(&qe->hnext, &ima_htable.queue[key]);
	}

	if (binary_runtime_size != ULONG_MAX) {
		int size;

		size = get_binary_runtime_size(entry);
		binary_runtime_size = (binary_runtime_size < ULONG_MAX - size) ?
		     binary_runtime_size + size : ULONG_MAX;
	}
	return 0;
}

/*
 * Return the amount of memory required for serializing the
 * entire binary_runtime_measurement list, including the ima_kexec_hdr
 * structure.
 */
unsigned long ima_get_binary_runtime_size(void)
{
	if (binary_runtime_size >= (ULONG_MAX - sizeof(struct ima_kexec_hdr)))
		return ULONG_MAX;
	else
		return binary_runtime_size + sizeof(struct ima_kexec_hdr);
};

static int ima_pcr_extend(const u8 *hash, int pcr)
{
	int result = 0;
	int i;

	if (!ima_tpm_chip)
		return result;

	for (i = 0; i < ima_tpm_chip->nr_allocated_banks; i++)
		memcpy(digests[i].digest, hash, TPM_DIGEST_SIZE);

	result = tpm_pcr_extend(ima_tpm_chip, pcr, digests);
	if (result != 0)
		pr_err("Error Communicating to TPM chip, result: %d\n", result);
	return result;
}

/*
 * Add template entry to the measurement list and hash table, and
 * extend the pcr.
 *
 * On systems which support carrying the IMA measurement list across
 * kexec, maintain the total memory size required for serializing the
 * binary_runtime_measurements.
 */
int ima_add_template_entry(struct ima_template_entry *entry, int violation,
			   const char *op, struct inode *inode,
			   const unsigned char *filename)
{
	u8 digest[TPM_DIGEST_SIZE];
	const char *audit_cause = "hash_added";
	char tpm_audit_cause[AUDIT_CAUSE_LEN_MAX];
	int audit_info = 1;
	int result = 0, tpmresult = 0;

	mutex_lock(&ima_extend_list_mutex);
	if (!violation) {
		memcpy(digest, entry->digest, sizeof(digest));
		if (ima_lookup_digest_entry(digest, entry->pcr)) {
			audit_cause = "hash_exists";
			result = -EEXIST;
			goto out;
		}
	}

	result = ima_add_digest_entry(entry, 1);
	if (result < 0) {
		audit_cause = "ENOMEM";
		audit_info = 0;
		goto out;
	}

	if (violation)		/* invalidate pcr */
		memset(digest, 0xff, sizeof(digest));

	tpmresult = ima_pcr_extend(digest, entry->pcr);
	if (tpmresult != 0) {
		snprintf(tpm_audit_cause, AUDIT_CAUSE_LEN_MAX, "TPM_error(%d)",
			 tpmresult);
		audit_cause = tpm_audit_cause;
		audit_info = 0;
	}
out:
	mutex_unlock(&ima_extend_list_mutex);
	integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
			    op, audit_cause, result, audit_info);
	return result;
}

int ima_restore_measurement_entry(struct ima_template_entry *entry)
{
	int result = 0;

	mutex_lock(&ima_extend_list_mutex);
	result = ima_add_digest_entry(entry, 0);
	mutex_unlock(&ima_extend_list_mutex);
	return result;
}

int __init ima_init_digests(void)
{
	int i;

	if (!ima_tpm_chip)
		return 0;

	digests = kcalloc(ima_tpm_chip->nr_allocated_banks, sizeof(*digests),
			  GFP_NOFS);
	if (!digests)
		return -ENOMEM;

	for (i = 0; i < ima_tpm_chip->nr_allocated_banks; i++)
		digests[i].alg_id = ima_tpm_chip->allocated_banks[i].alg_id;

	return 0;
}
Commit	Line	Data
3323eec9 MZ	1	/*
	2	* Copyright (C) 2005,2006,2007,2008 IBM Corporation
	3	*
	4	* Authors:
	5	* Serge Hallyn <serue@us.ibm.com>
	6	* Reiner Sailer <sailer@watson.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_queue.c
	15	* Implements queues that store template measurements and
	16	* maintains aggregate over the stored measurements
	17	* in the pre-configured TPM PCR (if available).
	18	* The measurement list is append-only. No entry is
	19	* ever removed or changed during the boot-cycle.
	20	*/
20ee451f JP	21
	22	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	23
3323eec9	24	#include <linux/rculist.h>
5a0e3ad6	25	#include <linux/slab.h>
3323eec9 MZ	26	#include "ima.h"
3323eec9 MZ	27
7b7e5916 RS	28	#define AUDIT_CAUSE_LEN_MAX 32
7b7e5916 RS	29
0b6cf6b9 RS	30	/* pre-allocated array of tpm_digest structures to extend a PCR */
	31	static struct tpm_digest *digests;
	32
3323eec9	33	LIST_HEAD(ima_measurements); /* list of all measurements */
d158847a MZ	34	#ifdef CONFIG_IMA_KEXEC
	35	static unsigned long binary_runtime_size;
	36	#else
	37	static unsigned long binary_runtime_size = ULONG_MAX;
	38	#endif
3323eec9 MZ	39
	40	/* key: inode (before secure-hashing a file) */
	41	struct ima_h_table ima_htable = {
	42	.len = ATOMIC_LONG_INIT(0),
	43	.violations = ATOMIC_LONG_INIT(0),
	44	.queue[0 ... IMA_MEASURE_HTABLE_SIZE - 1] = HLIST_HEAD_INIT
	45	};
	46
	47	/* mutex protects atomicity of extending measurement list
	48	* and extending the TPM PCR aggregate. Since tpm_extend can take
	49	* long (and the tpm driver uses a mutex), we can't use the spinlock.
	50	*/
	51	static DEFINE_MUTEX(ima_extend_list_mutex);
	52
	53	/* lookup up the digest value in the hash table, and return the entry */
67696f6d ER	54	static struct ima_queue_entry ima_lookup_digest_entry(u8 digest_value,
67696f6d ER	55	int pcr)
3323eec9 MZ	56	{
	57	struct ima_queue_entry qe, ret = NULL;
	58	unsigned int key;
3323eec9 MZ	59	int rc;
	60
	61	key = ima_hash_key(digest_value);
	62	rcu_read_lock();
b67bfe0d	63	hlist_for_each_entry_rcu(qe, &ima_htable.queue[key], hnext) {
140d8022	64	rc = memcmp(qe->entry->digest, digest_value, TPM_DIGEST_SIZE);
67696f6d	65	if ((rc == 0) && (qe->entry->pcr == pcr)) {
3323eec9 MZ	66	ret = qe;
	67	break;
	68	}
	69	}
	70	rcu_read_unlock();
	71	return ret;
	72	}
	73
d158847a MZ	74	/*
	75	* Calculate the memory required for serializing a single
	76	* binary_runtime_measurement list entry, which contains a
	77	* couple of variable length fields (e.g template name and data).
	78	*/
	79	static int get_binary_runtime_size(struct ima_template_entry *entry)
	80	{
	81	int size = 0;
	82
	83	size += sizeof(u32); /* pcr */
	84	size += sizeof(entry->digest);
	85	size += sizeof(int); /* template name size field */
e4586c79	86	size += strlen(entry->template_desc->name);
d158847a MZ	87	size += sizeof(entry->template_data_len);
	88	size += entry->template_data_len;
	89	return size;
	90	}
	91
3323eec9	92	/* ima_add_template_entry helper function:
dcfc5693 MZ	93	* - Add template entry to the measurement list and hash table, for
dcfc5693 MZ	94	* all entries except those carried across kexec.
3323eec9 MZ	95	*
	96	* (Called with ima_extend_list_mutex held.)
	97	*/
dcfc5693 MZ	98	static int ima_add_digest_entry(struct ima_template_entry *entry,
dcfc5693 MZ	99	bool update_htable)
3323eec9 MZ	100	{
	101	struct ima_queue_entry *qe;
	102	unsigned int key;
	103
	104	qe = kmalloc(sizeof(*qe), GFP_KERNEL);
	105	if (qe == NULL) {
20ee451f	106	pr_err("OUT OF MEMORY ERROR creating queue entry\n");
3323eec9 MZ	107	return -ENOMEM;
	108	}
	109	qe->entry = entry;
	110
	111	INIT_LIST_HEAD(&qe->later);
	112	list_add_tail_rcu(&qe->later, &ima_measurements);
	113
	114	atomic_long_inc(&ima_htable.len);
dcfc5693 MZ	115	if (update_htable) {
	116	key = ima_hash_key(entry->digest);
	117	hlist_add_head_rcu(&qe->hnext, &ima_htable.queue[key]);
	118	}
d158847a MZ	119
	120	if (binary_runtime_size != ULONG_MAX) {
	121	int size;
	122
	123	size = get_binary_runtime_size(entry);
	124	binary_runtime_size = (binary_runtime_size < ULONG_MAX - size) ?
	125	binary_runtime_size + size : ULONG_MAX;
	126	}
3323eec9 MZ	127	return 0;
	128	}
	129
d158847a MZ	130	/*
	131	* Return the amount of memory required for serializing the
	132	* entire binary_runtime_measurement list, including the ima_kexec_hdr
	133	* structure.
	134	*/
	135	unsigned long ima_get_binary_runtime_size(void)
	136	{
	137	if (binary_runtime_size >= (ULONG_MAX - sizeof(struct ima_kexec_hdr)))
	138	return ULONG_MAX;
	139	else
	140	return binary_runtime_size + sizeof(struct ima_kexec_hdr);
	141	};
	142
544e1cea	143	static int ima_pcr_extend(const u8 *hash, int pcr)
3323eec9 MZ	144	{
3323eec9 MZ	145	int result = 0;
0b6cf6b9	146	int i;
3323eec9	147
ec403d8e	148	if (!ima_tpm_chip)
3323eec9 MZ	149	return result;
3323eec9 MZ	150
0b6cf6b9 RS	151	for (i = 0; i < ima_tpm_chip->nr_allocated_banks; i++)
	152	memcpy(digests[i].digest, hash, TPM_DIGEST_SIZE);
	153
	154	result = tpm_pcr_extend(ima_tpm_chip, pcr, digests);
3323eec9	155	if (result != 0)
20ee451f	156	pr_err("Error Communicating to TPM chip, result: %d\n", result);
3323eec9 MZ	157	return result;
	158	}
	159
d158847a MZ	160	/*
	161	* Add template entry to the measurement list and hash table, and
	162	* extend the pcr.
	163	*
	164	* On systems which support carrying the IMA measurement list across
	165	* kexec, maintain the total memory size required for serializing the
	166	* binary_runtime_measurements.
3323eec9 MZ	167	*/
3323eec9 MZ	168	int ima_add_template_entry(struct ima_template_entry *entry, int violation,
9803d413 RS	169	const char op, struct inode inode,
9803d413 RS	170	const unsigned char *filename)
3323eec9	171	{
140d8022	172	u8 digest[TPM_DIGEST_SIZE];
3323eec9	173	const char *audit_cause = "hash_added";
7b7e5916	174	char tpm_audit_cause[AUDIT_CAUSE_LEN_MAX];
3323eec9	175	int audit_info = 1;
7b7e5916	176	int result = 0, tpmresult = 0;
3323eec9 MZ	177
	178	mutex_lock(&ima_extend_list_mutex);
	179	if (!violation) {
2bb930ab	180	memcpy(digest, entry->digest, sizeof(digest));
67696f6d	181	if (ima_lookup_digest_entry(digest, entry->pcr)) {
3323eec9	182	audit_cause = "hash_exists";
45fae749	183	result = -EEXIST;
3323eec9 MZ	184	goto out;
	185	}
	186	}
	187
dcfc5693	188	result = ima_add_digest_entry(entry, 1);
3323eec9 MZ	189	if (result < 0) {
	190	audit_cause = "ENOMEM";
	191	audit_info = 0;
	192	goto out;
	193	}
	194
	195	if (violation) /* invalidate pcr */
2bb930ab	196	memset(digest, 0xff, sizeof(digest));
3323eec9	197
544e1cea	198	tpmresult = ima_pcr_extend(digest, entry->pcr);
7b7e5916 RS	199	if (tpmresult != 0) {
	200	snprintf(tpm_audit_cause, AUDIT_CAUSE_LEN_MAX, "TPM_error(%d)",
	201	tpmresult);
	202	audit_cause = tpm_audit_cause;
3323eec9 MZ	203	audit_info = 0;
	204	}
	205	out:
	206	mutex_unlock(&ima_extend_list_mutex);
9803d413	207	integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
3323eec9 MZ	208	op, audit_cause, result, audit_info);
	209	return result;
	210	}
94c3aac5 MZ	211
	212	int ima_restore_measurement_entry(struct ima_template_entry *entry)
	213	{
	214	int result = 0;
	215
	216	mutex_lock(&ima_extend_list_mutex);
dcfc5693	217	result = ima_add_digest_entry(entry, 0);
94c3aac5 MZ	218	mutex_unlock(&ima_extend_list_mutex);
	219	return result;
	220	}
0b6cf6b9 RS	221
	222	int __init ima_init_digests(void)
	223	{
	224	int i;
	225
	226	if (!ima_tpm_chip)
	227	return 0;
	228
	229	digests = kcalloc(ima_tpm_chip->nr_allocated_banks, sizeof(*digests),
	230	GFP_NOFS);
	231	if (!digests)
	232	return -ENOMEM;
	233
	234	for (i = 0; i < ima_tpm_chip->nr_allocated_banks; i++)
	235	digests[i].alg_id = ima_tpm_chip->allocated_banks[i].alg_id;
	236
	237	return 0;
	238	}