1/*
  2 * key management facility for FS encryption support.
  3 *
  4 * Copyright (C) 2015, Google, Inc.
  5 *
  6 * This contains encryption key functions.
  7 *
  8 * Written by Michael Halcrow, Ildar Muslukhov, and Uday Savagaonkar, 2015.
  9 */
 10
 11#include <keys/encrypted-type.h>
 12#include <keys/user-type.h>
 13#include <linux/random.h>
 14#include <linux/scatterlist.h>
 15#include <uapi/linux/keyctl.h>
 16#include <linux/fscrypto.h>
 17
 18static void derive_crypt_complete(struct crypto_async_request *req, int rc)
 19{
 20	struct fscrypt_completion_result *ecr = req->data;
 21
 22	if (rc == -EINPROGRESS)
 23		return;
 24
 25	ecr->res = rc;
 26	complete(&ecr->completion);
 27}
 28
 29/**
 30 * derive_key_aes() - Derive a key using AES-128-ECB
 31 * @deriving_key: Encryption key used for derivation.
 32 * @source_key:   Source key to which to apply derivation.
 33 * @derived_key:  Derived key.
 34 *
 35 * Return: Zero on success; non-zero otherwise.
 36 */
 37static int derive_key_aes(u8 deriving_key[FS_AES_128_ECB_KEY_SIZE],
 38				u8 source_key[FS_AES_256_XTS_KEY_SIZE],
 39				u8 derived_key[FS_AES_256_XTS_KEY_SIZE])
 40{
 41	int res = 0;
 42	struct skcipher_request *req = NULL;
 43	DECLARE_FS_COMPLETION_RESULT(ecr);
 44	struct scatterlist src_sg, dst_sg;
 45	struct crypto_skcipher *tfm = crypto_alloc_skcipher("ecb(aes)", 0, 0);
 46
 47	if (IS_ERR(tfm)) {
 48		res = PTR_ERR(tfm);
 49		tfm = NULL;
 50		goto out;
 51	}
 52	crypto_skcipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 53	req = skcipher_request_alloc(tfm, GFP_NOFS);
 54	if (!req) {
 55		res = -ENOMEM;
 56		goto out;
 57	}
 58	skcipher_request_set_callback(req,
 59			CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,
 60			derive_crypt_complete, &ecr);
 61	res = crypto_skcipher_setkey(tfm, deriving_key,
 62					FS_AES_128_ECB_KEY_SIZE);
 63	if (res < 0)
 64		goto out;
 65
 66	sg_init_one(&src_sg, source_key, FS_AES_256_XTS_KEY_SIZE);
 67	sg_init_one(&dst_sg, derived_key, FS_AES_256_XTS_KEY_SIZE);
 68	skcipher_request_set_crypt(req, &src_sg, &dst_sg,
 69					FS_AES_256_XTS_KEY_SIZE, NULL);
 70	res = crypto_skcipher_encrypt(req);
 71	if (res == -EINPROGRESS || res == -EBUSY) {
 72		wait_for_completion(&ecr.completion);
 73		res = ecr.res;
 74	}
 75out:
 76	skcipher_request_free(req);
 77	crypto_free_skcipher(tfm);
 78	return res;
 79}
 80
 81static void put_crypt_info(struct fscrypt_info *ci)
 82{
 83	if (!ci)
 84		return;
 85
 86	key_put(ci->ci_keyring_key);
 87	crypto_free_skcipher(ci->ci_ctfm);
 88	kmem_cache_free(fscrypt_info_cachep, ci);
 89}
 90
 91int get_crypt_info(struct inode *inode)
 92{
 93	struct fscrypt_info *crypt_info;
 94	u8 full_key_descriptor[FS_KEY_DESC_PREFIX_SIZE +
 95				(FS_KEY_DESCRIPTOR_SIZE * 2) + 1];
 96	struct key *keyring_key = NULL;
 97	struct fscrypt_key *master_key;
 98	struct fscrypt_context ctx;
 99	const struct user_key_payload *ukp;
100	struct crypto_skcipher *ctfm;
101	const char *cipher_str;
102	u8 raw_key[FS_MAX_KEY_SIZE];
103	u8 mode;
104	int res;
105
106	res = fscrypt_initialize();
107	if (res)
108		return res;
109
110	if (!inode->i_sb->s_cop->get_context)
111		return -EOPNOTSUPP;
112retry:
113	crypt_info = ACCESS_ONCE(inode->i_crypt_info);
114	if (crypt_info) {
115		if (!crypt_info->ci_keyring_key ||
116				key_validate(crypt_info->ci_keyring_key) == 0)
117			return 0;
118		fscrypt_put_encryption_info(inode, crypt_info);
119		goto retry;
120	}
121
122	res = inode->i_sb->s_cop->get_context(inode, &ctx, sizeof(ctx));
123	if (res < 0) {
124		if (!fscrypt_dummy_context_enabled(inode))
125			return res;
126		ctx.contents_encryption_mode = FS_ENCRYPTION_MODE_AES_256_XTS;
127		ctx.filenames_encryption_mode = FS_ENCRYPTION_MODE_AES_256_CTS;
128		ctx.flags = 0;
129	} else if (res != sizeof(ctx)) {
130		return -EINVAL;
131	}
132	res = 0;
133
134	crypt_info = kmem_cache_alloc(fscrypt_info_cachep, GFP_NOFS);
135	if (!crypt_info)
136		return -ENOMEM;
137
138	crypt_info->ci_flags = ctx.flags;
139	crypt_info->ci_data_mode = ctx.contents_encryption_mode;
140	crypt_info->ci_filename_mode = ctx.filenames_encryption_mode;
141	crypt_info->ci_ctfm = NULL;
142	crypt_info->ci_keyring_key = NULL;
143	memcpy(crypt_info->ci_master_key, ctx.master_key_descriptor,
144				sizeof(crypt_info->ci_master_key));
145	if (S_ISREG(inode->i_mode))
146		mode = crypt_info->ci_data_mode;
147	else if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
148		mode = crypt_info->ci_filename_mode;
149	else
150		BUG();
151
152	switch (mode) {
153	case FS_ENCRYPTION_MODE_AES_256_XTS:
154		cipher_str = "xts(aes)";
155		break;
156	case FS_ENCRYPTION_MODE_AES_256_CTS:
157		cipher_str = "cts(cbc(aes))";
158		break;
159	default:
160		printk_once(KERN_WARNING
161			    "%s: unsupported key mode %d (ino %u)\n",
162			    __func__, mode, (unsigned) inode->i_ino);
163		res = -ENOKEY;
164		goto out;
165	}
166	if (fscrypt_dummy_context_enabled(inode)) {
167		memset(raw_key, 0x42, FS_AES_256_XTS_KEY_SIZE);
168		goto got_key;
169	}
170	memcpy(full_key_descriptor, FS_KEY_DESC_PREFIX,
171					FS_KEY_DESC_PREFIX_SIZE);
172	sprintf(full_key_descriptor + FS_KEY_DESC_PREFIX_SIZE,
173					"%*phN", FS_KEY_DESCRIPTOR_SIZE,
174					ctx.master_key_descriptor);
175	full_key_descriptor[FS_KEY_DESC_PREFIX_SIZE +
176					(2 * FS_KEY_DESCRIPTOR_SIZE)] = '\0';
177	keyring_key = request_key(&key_type_logon, full_key_descriptor, NULL);
178	if (IS_ERR(keyring_key)) {
179		res = PTR_ERR(keyring_key);
180		keyring_key = NULL;
181		goto out;
182	}
183	crypt_info->ci_keyring_key = keyring_key;
184	if (keyring_key->type != &key_type_logon) {
185		printk_once(KERN_WARNING
186				"%s: key type must be logon\n", __func__);
187		res = -ENOKEY;
188		goto out;
189	}
190	down_read(&keyring_key->sem);
191	ukp = user_key_payload(keyring_key);
192	if (ukp->datalen != sizeof(struct fscrypt_key)) {
193		res = -EINVAL;
194		up_read(&keyring_key->sem);
195		goto out;
196	}
197	master_key = (struct fscrypt_key *)ukp->data;
198	BUILD_BUG_ON(FS_AES_128_ECB_KEY_SIZE != FS_KEY_DERIVATION_NONCE_SIZE);
199
200	if (master_key->size != FS_AES_256_XTS_KEY_SIZE) {
201		printk_once(KERN_WARNING
202				"%s: key size incorrect: %d\n",
203				__func__, master_key->size);
204		res = -ENOKEY;
205		up_read(&keyring_key->sem);
206		goto out;
207	}
208	res = derive_key_aes(ctx.nonce, master_key->raw, raw_key);
209	up_read(&keyring_key->sem);
210	if (res)
211		goto out;
212got_key:
213	ctfm = crypto_alloc_skcipher(cipher_str, 0, 0);
214	if (!ctfm || IS_ERR(ctfm)) {
215		res = ctfm ? PTR_ERR(ctfm) : -ENOMEM;
216		printk(KERN_DEBUG
217		       "%s: error %d (inode %u) allocating crypto tfm\n",
218		       __func__, res, (unsigned) inode->i_ino);
219		goto out;
220	}
221	crypt_info->ci_ctfm = ctfm;
222	crypto_skcipher_clear_flags(ctfm, ~0);
223	crypto_skcipher_set_flags(ctfm, CRYPTO_TFM_REQ_WEAK_KEY);
224	res = crypto_skcipher_setkey(ctfm, raw_key, fscrypt_key_size(mode));
225	if (res)
226		goto out;
227
228	memzero_explicit(raw_key, sizeof(raw_key));
229	if (cmpxchg(&inode->i_crypt_info, NULL, crypt_info) != NULL) {
230		put_crypt_info(crypt_info);
231		goto retry;
232	}
233	return 0;
234
235out:
236	if (res == -ENOKEY)
237		res = 0;
238	put_crypt_info(crypt_info);
239	memzero_explicit(raw_key, sizeof(raw_key));
240	return res;
241}
242
243void fscrypt_put_encryption_info(struct inode *inode, struct fscrypt_info *ci)
244{
245	struct fscrypt_info *prev;
246
247	if (ci == NULL)
248		ci = ACCESS_ONCE(inode->i_crypt_info);
249	if (ci == NULL)
250		return;
251
252	prev = cmpxchg(&inode->i_crypt_info, ci, NULL);
253	if (prev != ci)
254		return;
255
256	put_crypt_info(ci);
257}
258EXPORT_SYMBOL(fscrypt_put_encryption_info);
259
260int fscrypt_get_encryption_info(struct inode *inode)
261{
262	struct fscrypt_info *ci = inode->i_crypt_info;
263
264	if (!ci ||
265		(ci->ci_keyring_key &&
266		 (ci->ci_keyring_key->flags & ((1 << KEY_FLAG_INVALIDATED) |
267					       (1 << KEY_FLAG_REVOKED) |
268					       (1 << KEY_FLAG_DEAD)))))
269		return get_crypt_info(inode);
270	return 0;
271}
272EXPORT_SYMBOL(fscrypt_get_encryption_info);