1/*
  2 * Copyright (C) 2005-2010 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: evm_crypto.c
 13 *	 Using root's kernel master key (kmk), calculate the HMAC
 14 */
 15
 16#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 17
 18#include <linux/module.h>
 19#include <linux/crypto.h>
 20#include <linux/xattr.h>
 21#include <linux/evm.h>
 22#include <keys/encrypted-type.h>
 23#include <crypto/hash.h>
 24#include "evm.h"
 25
 26#define EVMKEY "evm-key"
 27#define MAX_KEY_SIZE 128
 28static unsigned char evmkey[MAX_KEY_SIZE];
 29static int evmkey_len = MAX_KEY_SIZE;
 30
 31struct crypto_shash *hmac_tfm;
 32struct crypto_shash *hash_tfm;
 33
 34static DEFINE_MUTEX(mutex);
 35
 36#define EVM_SET_KEY_BUSY 0
 37
 38static unsigned long evm_set_key_flags;
 39
 40static char * const evm_hmac = "hmac(sha1)";
 41static char * const evm_hash = "sha1";
 42
 43/**
 44 * evm_set_key() - set EVM HMAC key from the kernel
 45 * @key: pointer to a buffer with the key data
 46 * @size: length of the key data
 47 *
 48 * This function allows setting the EVM HMAC key from the kernel
 49 * without using the "encrypted" key subsystem keys. It can be used
 50 * by the crypto HW kernel module which has its own way of managing
 51 * keys.
 52 *
 53 * key length should be between 32 and 128 bytes long
 54 */
 55int evm_set_key(void *key, size_t keylen)
 56{
 57	int rc;
 58
 59	rc = -EBUSY;
 60	if (test_and_set_bit(EVM_SET_KEY_BUSY, &evm_set_key_flags))
 61		goto busy;
 62	rc = -EINVAL;
 63	if (keylen > MAX_KEY_SIZE)
 64		goto inval;
 65	memcpy(evmkey, key, keylen);
 66	evm_initialized |= EVM_INIT_HMAC;
 67	pr_info("key initialized\n");
 68	return 0;
 69inval:
 70	clear_bit(EVM_SET_KEY_BUSY, &evm_set_key_flags);
 71busy:
 72	pr_err("key initialization failed\n");
 73	return rc;
 74}
 75EXPORT_SYMBOL_GPL(evm_set_key);
 76
 77static struct shash_desc *init_desc(char type)
 78{
 79	long rc;
 80	char *algo;
 81	struct crypto_shash **tfm;
 82	struct shash_desc *desc;
 83
 84	if (type == EVM_XATTR_HMAC) {
 85		if (!(evm_initialized & EVM_INIT_HMAC)) {
 86			pr_err_once("HMAC key is not set\n");
 87			return ERR_PTR(-ENOKEY);
 88		}
 89		tfm = &hmac_tfm;
 90		algo = evm_hmac;
 91	} else {
 92		tfm = &hash_tfm;
 93		algo = evm_hash;
 94	}
 95
 96	if (*tfm == NULL) {
 97		mutex_lock(&mutex);
 98		if (*tfm)
 99			goto out;
100		*tfm = crypto_alloc_shash(algo, 0, CRYPTO_ALG_ASYNC);
101		if (IS_ERR(*tfm)) {
102			rc = PTR_ERR(*tfm);
103			pr_err("Can not allocate %s (reason: %ld)\n", algo, rc);
104			*tfm = NULL;
105			mutex_unlock(&mutex);
106			return ERR_PTR(rc);
107		}
108		if (type == EVM_XATTR_HMAC) {
109			rc = crypto_shash_setkey(*tfm, evmkey, evmkey_len);
110			if (rc) {
111				crypto_free_shash(*tfm);
112				*tfm = NULL;
113				mutex_unlock(&mutex);
114				return ERR_PTR(rc);
115			}
116		}
117out:
118		mutex_unlock(&mutex);
119	}
120
121	desc = kmalloc(sizeof(*desc) + crypto_shash_descsize(*tfm),
122			GFP_KERNEL);
123	if (!desc)
124		return ERR_PTR(-ENOMEM);
125
126	desc->tfm = *tfm;
127	desc->flags = CRYPTO_TFM_REQ_MAY_SLEEP;
128
129	rc = crypto_shash_init(desc);
130	if (rc) {
131		kfree(desc);
132		return ERR_PTR(rc);
133	}
134	return desc;
135}
136
137/* Protect against 'cutting & pasting' security.evm xattr, include inode
138 * specific info.
139 *
140 * (Additional directory/file metadata needs to be added for more complete
141 * protection.)
142 */
143static void hmac_add_misc(struct shash_desc *desc, struct inode *inode,
144			  char type, char *digest)
145{
146	struct h_misc {
147		unsigned long ino;
148		__u32 generation;
149		uid_t uid;
150		gid_t gid;
151		umode_t mode;
152	} hmac_misc;
153
154	memset(&hmac_misc, 0, sizeof(hmac_misc));
155	/* Don't include the inode or generation number in portable
156	 * signatures
157	 */
158	if (type != EVM_XATTR_PORTABLE_DIGSIG) {
159		hmac_misc.ino = inode->i_ino;
160		hmac_misc.generation = inode->i_generation;
161	}
162	/* The hmac uid and gid must be encoded in the initial user
163	 * namespace (not the filesystems user namespace) as encoding
164	 * them in the filesystems user namespace allows an attack
165	 * where first they are written in an unprivileged fuse mount
166	 * of a filesystem and then the system is tricked to mount the
167	 * filesystem for real on next boot and trust it because
168	 * everything is signed.
169	 */
170	hmac_misc.uid = from_kuid(&init_user_ns, inode->i_uid);
171	hmac_misc.gid = from_kgid(&init_user_ns, inode->i_gid);
172	hmac_misc.mode = inode->i_mode;
173	crypto_shash_update(desc, (const u8 *)&hmac_misc, sizeof(hmac_misc));
174	if ((evm_hmac_attrs & EVM_ATTR_FSUUID) &&
175	    type != EVM_XATTR_PORTABLE_DIGSIG)
176		crypto_shash_update(desc, &inode->i_sb->s_uuid.b[0],
177				    sizeof(inode->i_sb->s_uuid));
178	crypto_shash_final(desc, digest);
179}
180
181/*
182 * Calculate the HMAC value across the set of protected security xattrs.
183 *
184 * Instead of retrieving the requested xattr, for performance, calculate
185 * the hmac using the requested xattr value. Don't alloc/free memory for
186 * each xattr, but attempt to re-use the previously allocated memory.
187 */
188static int evm_calc_hmac_or_hash(struct dentry *dentry,
189				const char *req_xattr_name,
190				const char *req_xattr_value,
191				size_t req_xattr_value_len,
192				char type, char *digest)
193{
194	struct inode *inode = d_backing_inode(dentry);
195	struct shash_desc *desc;
196	char **xattrname;
197	size_t xattr_size = 0;
198	char *xattr_value = NULL;
199	int error;
200	int size;
201	bool ima_present = false;
202
203	if (!(inode->i_opflags & IOP_XATTR))
204		return -EOPNOTSUPP;
205
206	desc = init_desc(type);
207	if (IS_ERR(desc))
208		return PTR_ERR(desc);
209
210	error = -ENODATA;
211	for (xattrname = evm_config_xattrnames; *xattrname != NULL; xattrname++) {
212		bool is_ima = false;
213
214		if (strcmp(*xattrname, XATTR_NAME_IMA) == 0)
215			is_ima = true;
216
217		if ((req_xattr_name && req_xattr_value)
218		    && !strcmp(*xattrname, req_xattr_name)) {
219			error = 0;
220			crypto_shash_update(desc, (const u8 *)req_xattr_value,
221					     req_xattr_value_len);
222			if (is_ima)
223				ima_present = true;
224			continue;
225		}
226		size = vfs_getxattr_alloc(dentry, *xattrname,
227					  &xattr_value, xattr_size, GFP_NOFS);
228		if (size == -ENOMEM) {
229			error = -ENOMEM;
230			goto out;
231		}
232		if (size < 0)
233			continue;
234
235		error = 0;
236		xattr_size = size;
237		crypto_shash_update(desc, (const u8 *)xattr_value, xattr_size);
238		if (is_ima)
239			ima_present = true;
240	}
241	hmac_add_misc(desc, inode, type, digest);
242
243	/* Portable EVM signatures must include an IMA hash */
244	if (type == EVM_XATTR_PORTABLE_DIGSIG && !ima_present)
245		return -EPERM;
246out:
247	kfree(xattr_value);
248	kfree(desc);
249	return error;
250}
251
252int evm_calc_hmac(struct dentry *dentry, const char *req_xattr_name,
253		  const char *req_xattr_value, size_t req_xattr_value_len,
254		  char *digest)
255{
256	return evm_calc_hmac_or_hash(dentry, req_xattr_name, req_xattr_value,
257			       req_xattr_value_len, EVM_XATTR_HMAC, digest);
258}
259
260int evm_calc_hash(struct dentry *dentry, const char *req_xattr_name,
261		  const char *req_xattr_value, size_t req_xattr_value_len,
262		  char type, char *digest)
263{
264	return evm_calc_hmac_or_hash(dentry, req_xattr_name, req_xattr_value,
265				     req_xattr_value_len, type, digest);
266}
267
268static int evm_is_immutable(struct dentry *dentry, struct inode *inode)
269{
270	const struct evm_ima_xattr_data *xattr_data = NULL;
271	struct integrity_iint_cache *iint;
272	int rc = 0;
273
274	iint = integrity_iint_find(inode);
275	if (iint && (iint->flags & EVM_IMMUTABLE_DIGSIG))
276		return 1;
277
278	/* Do this the hard way */
279	rc = vfs_getxattr_alloc(dentry, XATTR_NAME_EVM, (char **)&xattr_data, 0,
280				GFP_NOFS);
281	if (rc <= 0) {
282		if (rc == -ENODATA)
283			return 0;
284		return rc;
285	}
286	if (xattr_data->type == EVM_XATTR_PORTABLE_DIGSIG)
287		rc = 1;
288	else
289		rc = 0;
290
291	kfree(xattr_data);
292	return rc;
293}
294
295
296/*
297 * Calculate the hmac and update security.evm xattr
298 *
299 * Expects to be called with i_mutex locked.
300 */
301int evm_update_evmxattr(struct dentry *dentry, const char *xattr_name,
302			const char *xattr_value, size_t xattr_value_len)
303{
304	struct inode *inode = d_backing_inode(dentry);
305	struct evm_ima_xattr_data xattr_data;
306	int rc = 0;
307
308	/*
309	 * Don't permit any transformation of the EVM xattr if the signature
310	 * is of an immutable type
311	 */
312	rc = evm_is_immutable(dentry, inode);
313	if (rc < 0)
314		return rc;
315	if (rc)
316		return -EPERM;
317
318	rc = evm_calc_hmac(dentry, xattr_name, xattr_value,
319			   xattr_value_len, xattr_data.digest);
320	if (rc == 0) {
321		xattr_data.type = EVM_XATTR_HMAC;
322		rc = __vfs_setxattr_noperm(dentry, XATTR_NAME_EVM,
323					   &xattr_data,
324					   sizeof(xattr_data), 0);
325	} else if (rc == -ENODATA && (inode->i_opflags & IOP_XATTR)) {
326		rc = __vfs_removexattr(dentry, XATTR_NAME_EVM);
327	}
328	return rc;
329}
330
331int evm_init_hmac(struct inode *inode, const struct xattr *lsm_xattr,
332		  char *hmac_val)
333{
334	struct shash_desc *desc;
335
336	desc = init_desc(EVM_XATTR_HMAC);
337	if (IS_ERR(desc)) {
338		pr_info("init_desc failed\n");
339		return PTR_ERR(desc);
340	}
341
342	crypto_shash_update(desc, lsm_xattr->value, lsm_xattr->value_len);
343	hmac_add_misc(desc, inode, EVM_XATTR_HMAC, hmac_val);
344	kfree(desc);
345	return 0;
346}
347
348/*
349 * Get the key from the TPM for the SHA1-HMAC
350 */
351int evm_init_key(void)
352{
353	struct key *evm_key;
354	struct encrypted_key_payload *ekp;
355	int rc;
356
357	evm_key = request_key(&key_type_encrypted, EVMKEY, NULL);
358	if (IS_ERR(evm_key))
359		return -ENOENT;
360
361	down_read(&evm_key->sem);
362	ekp = evm_key->payload.data[0];
363
364	rc = evm_set_key(ekp->decrypted_data, ekp->decrypted_datalen);
365
366	/* burn the original key contents */
367	memset(ekp->decrypted_data, 0, ekp->decrypted_datalen);
368	up_read(&evm_key->sem);
369	key_put(evm_key);
370	return rc;
371}