1 /* Large capacity key type
3 * Copyright (C) 2013 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public Licence
8 * as published by the Free Software Foundation; either version
9 * 2 of the Licence, or (at your option) any later version.
12 #include <linux/init.h>
13 #include <linux/seq_file.h>
14 #include <linux/file.h>
15 #include <linux/shmem_fs.h>
16 #include <linux/err.h>
17 #include <linux/scatterlist.h>
18 #include <keys/user-type.h>
19 #include <keys/big_key-type.h>
20 #include <crypto/rng.h>
21 #include <crypto/skcipher.h>
24 * Layout of key payload words.
29 big_key_path_2nd_part,
34 * Crypto operation with big_key data
42 * If the data is under this limit, there's no point creating a shm file to
43 * hold it as the permanently resident metadata for the shmem fs will be at
44 * least as large as the data.
46 #define BIG_KEY_FILE_THRESHOLD (sizeof(struct inode) + sizeof(struct dentry))
49 * Key size for big_key data encryption
51 #define ENC_KEY_SIZE 16
54 * big_key defined keys take an arbitrary string as the description and an
55 * arbitrary blob of data as the payload
57 struct key_type key_type_big_key = {
59 .preparse = big_key_preparse,
60 .free_preparse = big_key_free_preparse,
61 .instantiate = generic_key_instantiate,
62 .revoke = big_key_revoke,
63 .destroy = big_key_destroy,
64 .describe = big_key_describe,
69 * Crypto names for big_key data encryption
71 static const char big_key_rng_name[] = "stdrng";
72 static const char big_key_alg_name[] = "ecb(aes)";
75 * Crypto algorithms for big_key data encryption
77 static struct crypto_rng *big_key_rng;
78 static struct crypto_skcipher *big_key_skcipher;
81 * Generate random key to encrypt big_key data
83 static inline int big_key_gen_enckey(u8 *key)
85 return crypto_rng_get_bytes(big_key_rng, key, ENC_KEY_SIZE);
89 * Encrypt/decrypt big_key data
91 static int big_key_crypt(enum big_key_op op, u8 *data, size_t datalen, u8 *key)
94 struct scatterlist sgio;
95 SKCIPHER_REQUEST_ON_STACK(req, big_key_skcipher);
97 if (crypto_skcipher_setkey(big_key_skcipher, key, ENC_KEY_SIZE)) {
102 skcipher_request_set_tfm(req, big_key_skcipher);
103 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_SLEEP,
106 sg_init_one(&sgio, data, datalen);
107 skcipher_request_set_crypt(req, &sgio, &sgio, datalen, NULL);
109 if (op == BIG_KEY_ENC)
110 ret = crypto_skcipher_encrypt(req);
112 ret = crypto_skcipher_decrypt(req);
114 skcipher_request_zero(req);
123 int big_key_preparse(struct key_preparsed_payload *prep)
125 struct path *path = (struct path *)&prep->payload.data[big_key_path];
130 size_t datalen = prep->datalen;
134 if (datalen <= 0 || datalen > 1024 * 1024 || !prep->data)
137 /* Set an arbitrary quota */
140 prep->payload.data[big_key_len] = (void *)(unsigned long)datalen;
142 if (datalen > BIG_KEY_FILE_THRESHOLD) {
143 /* Create a shmem file to store the data in. This will permit the data
144 * to be swapped out if needed.
146 * File content is stored encrypted with randomly generated key.
148 size_t enclen = ALIGN(datalen, crypto_skcipher_blocksize(big_key_skcipher));
150 /* prepare aligned data to encrypt */
151 data = kmalloc(enclen, GFP_KERNEL);
155 memcpy(data, prep->data, datalen);
156 memset(data + datalen, 0x00, enclen - datalen);
158 /* generate random key */
159 enckey = kmalloc(ENC_KEY_SIZE, GFP_KERNEL);
165 ret = big_key_gen_enckey(enckey);
169 /* encrypt aligned data */
170 ret = big_key_crypt(BIG_KEY_ENC, data, enclen, enckey);
174 /* save aligned data to file */
175 file = shmem_kernel_file_setup("", enclen, 0);
181 written = kernel_write(file, data, enclen, 0);
182 if (written != enclen) {
189 /* Pin the mount and dentry to the key so that we can open it again
192 prep->payload.data[big_key_data] = enckey;
193 *path = file->f_path;
198 /* Just store the data in a buffer */
199 void *data = kmalloc(datalen, GFP_KERNEL);
204 prep->payload.data[big_key_data] = data;
205 memcpy(data, prep->data, prep->datalen);
219 * Clear preparsement.
221 void big_key_free_preparse(struct key_preparsed_payload *prep)
223 if (prep->datalen > BIG_KEY_FILE_THRESHOLD) {
224 struct path *path = (struct path *)&prep->payload.data[big_key_path];
228 kfree(prep->payload.data[big_key_data]);
232 * dispose of the links from a revoked keyring
233 * - called with the key sem write-locked
235 void big_key_revoke(struct key *key)
237 struct path *path = (struct path *)&key->payload.data[big_key_path];
239 /* clear the quota */
240 key_payload_reserve(key, 0);
241 if (key_is_instantiated(key) &&
242 (size_t)key->payload.data[big_key_len] > BIG_KEY_FILE_THRESHOLD)
243 vfs_truncate(path, 0);
247 * dispose of the data dangling from the corpse of a big_key key
249 void big_key_destroy(struct key *key)
251 size_t datalen = (size_t)key->payload.data[big_key_len];
253 if (datalen > BIG_KEY_FILE_THRESHOLD) {
254 struct path *path = (struct path *)&key->payload.data[big_key_path];
260 kfree(key->payload.data[big_key_data]);
261 key->payload.data[big_key_data] = NULL;
265 * describe the big_key key
267 void big_key_describe(const struct key *key, struct seq_file *m)
269 size_t datalen = (size_t)key->payload.data[big_key_len];
271 seq_puts(m, key->description);
273 if (key_is_instantiated(key))
274 seq_printf(m, ": %zu [%s]",
276 datalen > BIG_KEY_FILE_THRESHOLD ? "file" : "buff");
281 * - the key's semaphore is read-locked
283 long big_key_read(const struct key *key, char __user *buffer, size_t buflen)
285 size_t datalen = (size_t)key->payload.data[big_key_len];
288 if (!buffer || buflen < datalen)
291 if (datalen > BIG_KEY_FILE_THRESHOLD) {
292 struct path *path = (struct path *)&key->payload.data[big_key_path];
295 u8 *enckey = (u8 *)key->payload.data[big_key_data];
296 size_t enclen = ALIGN(datalen, crypto_skcipher_blocksize(big_key_skcipher));
298 data = kmalloc(enclen, GFP_KERNEL);
302 file = dentry_open(path, O_RDONLY, current_cred());
308 /* read file to kernel and decrypt */
309 ret = kernel_read(file, 0, data, enclen);
310 if (ret >= 0 && ret != enclen) {
315 ret = big_key_crypt(BIG_KEY_DEC, data, enclen, enckey);
321 /* copy decrypted data to user */
322 if (copy_to_user(buffer, data, datalen) != 0)
331 if (copy_to_user(buffer, key->payload.data[big_key_data],
342 static int __init big_key_init(void)
344 return register_key_type(&key_type_big_key);
348 * Initialize big_key crypto and RNG algorithms
350 static int __init big_key_crypto_init(void)
355 big_key_rng = crypto_alloc_rng(big_key_rng_name, 0, 0);
356 if (IS_ERR(big_key_rng)) {
362 ret = crypto_rng_reset(big_key_rng, NULL, crypto_rng_seedsize(big_key_rng));
366 /* init block cipher */
367 big_key_skcipher = crypto_alloc_skcipher(big_key_alg_name,
368 0, CRYPTO_ALG_ASYNC);
369 if (IS_ERR(big_key_skcipher)) {
370 big_key_skcipher = NULL;
378 crypto_free_rng(big_key_rng);
383 device_initcall(big_key_init);
384 late_initcall(big_key_crypto_init);