[linux-block.git] / security / integrity / ima / ima_crypto.c

/*
 * Copyright (C) 2005,2006,2007,2008 IBM Corporation
 *
 * Authors:
 * Mimi Zohar <zohar@us.ibm.com>
 * Kylene Hall <kjhall@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_crypto.c
 * 	Calculates md5/sha1 file hash, template hash, boot-aggreate hash
 */

#include <linux/kernel.h>
#include <linux/file.h>
#include <linux/crypto.h>
#include <linux/scatterlist.h>
#include <linux/err.h>
#include <linux/slab.h>
#include "ima.h"

static int init_desc(struct hash_desc *desc)
{
	int rc;

	desc->tfm = crypto_alloc_hash(ima_hash, 0, CRYPTO_ALG_ASYNC);
	if (IS_ERR(desc->tfm)) {
		pr_info("IMA: failed to load %s transform: %ld\n",
			ima_hash, PTR_ERR(desc->tfm));
		rc = PTR_ERR(desc->tfm);
		return rc;
	}
	desc->flags = 0;
	rc = crypto_hash_init(desc);
	if (rc)
		crypto_free_hash(desc->tfm);
	return rc;
}

/*
 * Calculate the MD5/SHA1 file digest
 */
int ima_calc_hash(struct file *file, char *digest)
{
	struct hash_desc desc;
	struct scatterlist sg[1];
	loff_t i_size, offset = 0;
	char *rbuf;
	int rc, read = 0;

	rc = init_desc(&desc);
	if (rc != 0)
		return rc;

	rbuf = kzalloc(PAGE_SIZE, GFP_KERNEL);
	if (!rbuf) {
		rc = -ENOMEM;
		goto out;
	}
	if (!(file->f_mode & FMODE_READ)) {
		file->f_mode |= FMODE_READ;
		read = 1;
	}
	i_size = i_size_read(file_inode(file));
	while (offset < i_size) {
		int rbuf_len;

		rbuf_len = kernel_read(file, offset, rbuf, PAGE_SIZE);
		if (rbuf_len < 0) {
			rc = rbuf_len;
			break;
		}
		if (rbuf_len == 0)
			break;
		offset += rbuf_len;
		sg_init_one(sg, rbuf, rbuf_len);

		rc = crypto_hash_update(&desc, sg, rbuf_len);
		if (rc)
			break;
	}
	kfree(rbuf);
	if (!rc)
		rc = crypto_hash_final(&desc, digest);
	if (read)
		file->f_mode &= ~FMODE_READ;
out:
	crypto_free_hash(desc.tfm);
	return rc;
}

/*
 * Calculate the hash of a given template
 */
int ima_calc_template_hash(int template_len, void *template, char *digest)
{
	struct hash_desc desc;
	struct scatterlist sg[1];
	int rc;

	rc = init_desc(&desc);
	if (rc != 0)
		return rc;

	sg_init_one(sg, template, template_len);
	rc = crypto_hash_update(&desc, sg, template_len);
	if (!rc)
		rc = crypto_hash_final(&desc, digest);
	crypto_free_hash(desc.tfm);
	return rc;
}

static void __init ima_pcrread(int idx, u8 *pcr)
{
	if (!ima_used_chip)
		return;

	if (tpm_pcr_read(TPM_ANY_NUM, idx, pcr) != 0)
		pr_err("IMA: Error Communicating to TPM chip\n");
}

/*
 * Calculate the boot aggregate hash
 */
int __init ima_calc_boot_aggregate(char *digest)
{
	struct hash_desc desc;
	struct scatterlist sg;
	u8 pcr_i[IMA_DIGEST_SIZE];
	int rc, i;

	rc = init_desc(&desc);
	if (rc != 0)
		return rc;

	/* cumulative sha1 over tpm registers 0-7 */
	for (i = TPM_PCR0; i < TPM_PCR8; i++) {
		ima_pcrread(i, pcr_i);
		/* now accumulate with current aggregate */
		sg_init_one(&sg, pcr_i, IMA_DIGEST_SIZE);
		rc = crypto_hash_update(&desc, &sg, IMA_DIGEST_SIZE);
	}
	if (!rc)
		crypto_hash_final(&desc, digest);
	crypto_free_hash(desc.tfm);
	return rc;
}
Commit	Line	Data
3323eec9 MZ	1	/*
	2	* Copyright (C) 2005,2006,2007,2008 IBM Corporation
	3	*
	4	* Authors:
	5	* Mimi Zohar <zohar@us.ibm.com>
	6	* Kylene Hall <kjhall@us.ibm.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation, version 2 of the License.
	11	*
	12	* File: ima_crypto.c
	13	* Calculates md5/sha1 file hash, template hash, boot-aggreate hash
	14	*/
	15
	16	#include <linux/kernel.h>
	17	#include <linux/file.h>
	18	#include <linux/crypto.h>
	19	#include <linux/scatterlist.h>
	20	#include <linux/err.h>
5a0e3ad6	21	#include <linux/slab.h>
3323eec9 MZ	22	#include "ima.h"
	23
	24	static int init_desc(struct hash_desc *desc)
	25	{
	26	int rc;
	27
	28	desc->tfm = crypto_alloc_hash(ima_hash, 0, CRYPTO_ALG_ASYNC);
	29	if (IS_ERR(desc->tfm)) {
eb8dae96	30	pr_info("IMA: failed to load %s transform: %ld\n",
3323eec9 MZ	31	ima_hash, PTR_ERR(desc->tfm));
	32	rc = PTR_ERR(desc->tfm);
	33	return rc;
	34	}
	35	desc->flags = 0;
	36	rc = crypto_hash_init(desc);
	37	if (rc)
	38	crypto_free_hash(desc->tfm);
	39	return rc;
	40	}
	41
	42	/*
	43	* Calculate the MD5/SHA1 file digest
	44	*/
	45	int ima_calc_hash(struct file file, char digest)
	46	{
	47	struct hash_desc desc;
	48	struct scatterlist sg[1];
16bfa38b	49	loff_t i_size, offset = 0;
3323eec9	50	char *rbuf;
2fe5d6de	51	int rc, read = 0;
3323eec9 MZ	52
	53	rc = init_desc(&desc);
	54	if (rc != 0)
	55	return rc;
	56
	57	rbuf = kzalloc(PAGE_SIZE, GFP_KERNEL);
	58	if (!rbuf) {
	59	rc = -ENOMEM;
	60	goto out;
	61	}
2fe5d6de MZ	62	if (!(file->f_mode & FMODE_READ)) {
	63	file->f_mode \|= FMODE_READ;
	64	read = 1;
	65	}
496ad9aa	66	i_size = i_size_read(file_inode(file));
3323eec9 MZ	67	while (offset < i_size) {
	68	int rbuf_len;
	69
	70	rbuf_len = kernel_read(file, offset, rbuf, PAGE_SIZE);
	71	if (rbuf_len < 0) {
	72	rc = rbuf_len;
	73	break;
	74	}
16bfa38b MZ	75	if (rbuf_len == 0)
16bfa38b MZ	76	break;
3323eec9	77	offset += rbuf_len;
0da0a420	78	sg_init_one(sg, rbuf, rbuf_len);
3323eec9 MZ	79
	80	rc = crypto_hash_update(&desc, sg, rbuf_len);
	81	if (rc)
	82	break;
	83	}
	84	kfree(rbuf);
	85	if (!rc)
	86	rc = crypto_hash_final(&desc, digest);
2fe5d6de MZ	87	if (read)
2fe5d6de MZ	88	file->f_mode &= ~FMODE_READ;
3323eec9 MZ	89	out:
	90	crypto_free_hash(desc.tfm);
	91	return rc;
	92	}
	93
	94	/*
	95	* Calculate the hash of a given template
	96	*/
	97	int ima_calc_template_hash(int template_len, void template, char digest)
	98	{
	99	struct hash_desc desc;
	100	struct scatterlist sg[1];
	101	int rc;
	102
	103	rc = init_desc(&desc);
	104	if (rc != 0)
	105	return rc;
	106
0da0a420	107	sg_init_one(sg, template, template_len);
3323eec9 MZ	108	rc = crypto_hash_update(&desc, sg, template_len);
	109	if (!rc)
	110	rc = crypto_hash_final(&desc, digest);
	111	crypto_free_hash(desc.tfm);
	112	return rc;
	113	}
	114
932995f0	115	static void __init ima_pcrread(int idx, u8 *pcr)
3323eec9 MZ	116	{
	117	if (!ima_used_chip)
	118	return;
	119
	120	if (tpm_pcr_read(TPM_ANY_NUM, idx, pcr) != 0)
eb8dae96	121	pr_err("IMA: Error Communicating to TPM chip\n");
3323eec9 MZ	122	}
	123
	124	/*
	125	* Calculate the boot aggregate hash
	126	*/
932995f0	127	int __init ima_calc_boot_aggregate(char *digest)
3323eec9 MZ	128	{
	129	struct hash_desc desc;
	130	struct scatterlist sg;
	131	u8 pcr_i[IMA_DIGEST_SIZE];
	132	int rc, i;
	133
	134	rc = init_desc(&desc);
	135	if (rc != 0)
	136	return rc;
	137
	138	/* cumulative sha1 over tpm registers 0-7 */
	139	for (i = TPM_PCR0; i < TPM_PCR8; i++) {
	140	ima_pcrread(i, pcr_i);
	141	/* now accumulate with current aggregate */
	142	sg_init_one(&sg, pcr_i, IMA_DIGEST_SIZE);
	143	rc = crypto_hash_update(&desc, &sg, IMA_DIGEST_SIZE);
	144	}
	145	if (!rc)
	146	crypto_hash_final(&desc, digest);
	147	crypto_free_hash(desc.tfm);
	148	return rc;
	149	}