1 /* Large capacity key type 2 * 3 * Copyright (C) 2013 Red Hat, Inc. All Rights Reserved. 4 * Written by David Howells (dhowells@redhat.com) 5 * 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. 10 */ 11 12 #define pr_fmt(fmt) "big_key: "fmt 13 #include <linux/init.h> 14 #include <linux/seq_file.h> 15 #include <linux/file.h> 16 #include <linux/shmem_fs.h> 17 #include <linux/err.h> 18 #include <linux/scatterlist.h> 19 #include <keys/user-type.h> 20 #include <keys/big_key-type.h> 21 #include <crypto/rng.h> 22 #include <crypto/skcipher.h> 23 24 /* 25 * Layout of key payload words. 26 */ 27 enum { 28 big_key_data, 29 big_key_path, 30 big_key_path_2nd_part, 31 big_key_len, 32 }; 33 34 /* 35 * Crypto operation with big_key data 36 */ 37 enum big_key_op { 38 BIG_KEY_ENC, 39 BIG_KEY_DEC, 40 }; 41 42 /* 43 * If the data is under this limit, there's no point creating a shm file to 44 * hold it as the permanently resident metadata for the shmem fs will be at 45 * least as large as the data. 46 */ 47 #define BIG_KEY_FILE_THRESHOLD (sizeof(struct inode) + sizeof(struct dentry)) 48 49 /* 50 * Key size for big_key data encryption 51 */ 52 #define ENC_KEY_SIZE 16 53 54 /* 55 * big_key defined keys take an arbitrary string as the description and an 56 * arbitrary blob of data as the payload 57 */ 58 struct key_type key_type_big_key = { 59 .name = "big_key", 60 .preparse = big_key_preparse, 61 .free_preparse = big_key_free_preparse, 62 .instantiate = generic_key_instantiate, 63 .revoke = big_key_revoke, 64 .destroy = big_key_destroy, 65 .describe = big_key_describe, 66 .read = big_key_read, 67 }; 68 69 /* 70 * Crypto names for big_key data encryption 71 */ 72 static const char big_key_rng_name[] = "stdrng"; 73 static const char big_key_alg_name[] = "ecb(aes)"; 74 75 /* 76 * Crypto algorithms for big_key data encryption 77 */ 78 static struct crypto_rng *big_key_rng; 79 static struct crypto_skcipher *big_key_skcipher; 80 81 /* 82 * Generate random key to encrypt big_key data 83 */ 84 static inline int big_key_gen_enckey(u8 *key) 85 { 86 return crypto_rng_get_bytes(big_key_rng, key, ENC_KEY_SIZE); 87 } 88 89 /* 90 * Encrypt/decrypt big_key data 91 */ 92 static int big_key_crypt(enum big_key_op op, u8 *data, size_t datalen, u8 *key) 93 { 94 int ret = -EINVAL; 95 struct scatterlist sgio; 96 SKCIPHER_REQUEST_ON_STACK(req, big_key_skcipher); 97 98 if (crypto_skcipher_setkey(big_key_skcipher, key, ENC_KEY_SIZE)) { 99 ret = -EAGAIN; 100 goto error; 101 } 102 103 skcipher_request_set_tfm(req, big_key_skcipher); 104 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_SLEEP, 105 NULL, NULL); 106 107 sg_init_one(&sgio, data, datalen); 108 skcipher_request_set_crypt(req, &sgio, &sgio, datalen, NULL); 109 110 if (op == BIG_KEY_ENC) 111 ret = crypto_skcipher_encrypt(req); 112 else 113 ret = crypto_skcipher_decrypt(req); 114 115 skcipher_request_zero(req); 116 117 error: 118 return ret; 119 } 120 121 /* 122 * Preparse a big key 123 */ 124 int big_key_preparse(struct key_preparsed_payload *prep) 125 { 126 struct path *path = (struct path *)&prep->payload.data[big_key_path]; 127 struct file *file; 128 u8 *enckey; 129 u8 *data = NULL; 130 ssize_t written; 131 size_t datalen = prep->datalen; 132 int ret; 133 134 ret = -EINVAL; 135 if (datalen <= 0 || datalen > 1024 * 1024 || !prep->data) 136 goto error; 137 138 /* Set an arbitrary quota */ 139 prep->quotalen = 16; 140 141 prep->payload.data[big_key_len] = (void *)(unsigned long)datalen; 142 143 if (datalen > BIG_KEY_FILE_THRESHOLD) { 144 /* Create a shmem file to store the data in. This will permit the data 145 * to be swapped out if needed. 146 * 147 * File content is stored encrypted with randomly generated key. 148 */ 149 size_t enclen = ALIGN(datalen, crypto_skcipher_blocksize(big_key_skcipher)); 150 loff_t pos = 0; 151 152 /* prepare aligned data to encrypt */ 153 data = kmalloc(enclen, GFP_KERNEL); 154 if (!data) 155 return -ENOMEM; 156 157 memcpy(data, prep->data, datalen); 158 memset(data + datalen, 0x00, enclen - datalen); 159 160 /* generate random key */ 161 enckey = kmalloc(ENC_KEY_SIZE, GFP_KERNEL); 162 if (!enckey) { 163 ret = -ENOMEM; 164 goto error; 165 } 166 167 ret = big_key_gen_enckey(enckey); 168 if (ret) 169 goto err_enckey; 170 171 /* encrypt aligned data */ 172 ret = big_key_crypt(BIG_KEY_ENC, data, enclen, enckey); 173 if (ret) 174 goto err_enckey; 175 176 /* save aligned data to file */ 177 file = shmem_kernel_file_setup("", enclen, 0); 178 if (IS_ERR(file)) { 179 ret = PTR_ERR(file); 180 goto err_enckey; 181 } 182 183 written = kernel_write(file, data, enclen, &pos); 184 if (written != enclen) { 185 ret = written; 186 if (written >= 0) 187 ret = -ENOMEM; 188 goto err_fput; 189 } 190 191 /* Pin the mount and dentry to the key so that we can open it again 192 * later 193 */ 194 prep->payload.data[big_key_data] = enckey; 195 *path = file->f_path; 196 path_get(path); 197 fput(file); 198 kfree(data); 199 } else { 200 /* Just store the data in a buffer */ 201 void *data = kmalloc(datalen, GFP_KERNEL); 202 203 if (!data) 204 return -ENOMEM; 205 206 prep->payload.data[big_key_data] = data; 207 memcpy(data, prep->data, prep->datalen); 208 } 209 return 0; 210 211 err_fput: 212 fput(file); 213 err_enckey: 214 kfree(enckey); 215 error: 216 kfree(data); 217 return ret; 218 } 219 220 /* 221 * Clear preparsement. 222 */ 223 void big_key_free_preparse(struct key_preparsed_payload *prep) 224 { 225 if (prep->datalen > BIG_KEY_FILE_THRESHOLD) { 226 struct path *path = (struct path *)&prep->payload.data[big_key_path]; 227 228 path_put(path); 229 } 230 kfree(prep->payload.data[big_key_data]); 231 } 232 233 /* 234 * dispose of the links from a revoked keyring 235 * - called with the key sem write-locked 236 */ 237 void big_key_revoke(struct key *key) 238 { 239 struct path *path = (struct path *)&key->payload.data[big_key_path]; 240 241 /* clear the quota */ 242 key_payload_reserve(key, 0); 243 if (key_is_instantiated(key) && 244 (size_t)key->payload.data[big_key_len] > BIG_KEY_FILE_THRESHOLD) 245 vfs_truncate(path, 0); 246 } 247 248 /* 249 * dispose of the data dangling from the corpse of a big_key key 250 */ 251 void big_key_destroy(struct key *key) 252 { 253 size_t datalen = (size_t)key->payload.data[big_key_len]; 254 255 if (datalen > BIG_KEY_FILE_THRESHOLD) { 256 struct path *path = (struct path *)&key->payload.data[big_key_path]; 257 258 path_put(path); 259 path->mnt = NULL; 260 path->dentry = NULL; 261 } 262 kfree(key->payload.data[big_key_data]); 263 key->payload.data[big_key_data] = NULL; 264 } 265 266 /* 267 * describe the big_key key 268 */ 269 void big_key_describe(const struct key *key, struct seq_file *m) 270 { 271 size_t datalen = (size_t)key->payload.data[big_key_len]; 272 273 seq_puts(m, key->description); 274 275 if (key_is_instantiated(key)) 276 seq_printf(m, ": %zu [%s]", 277 datalen, 278 datalen > BIG_KEY_FILE_THRESHOLD ? "file" : "buff"); 279 } 280 281 /* 282 * read the key data 283 * - the key's semaphore is read-locked 284 */ 285 long big_key_read(const struct key *key, char __user *buffer, size_t buflen) 286 { 287 size_t datalen = (size_t)key->payload.data[big_key_len]; 288 long ret; 289 290 if (!buffer || buflen < datalen) 291 return datalen; 292 293 if (datalen > BIG_KEY_FILE_THRESHOLD) { 294 struct path *path = (struct path *)&key->payload.data[big_key_path]; 295 struct file *file; 296 u8 *data; 297 u8 *enckey = (u8 *)key->payload.data[big_key_data]; 298 size_t enclen = ALIGN(datalen, crypto_skcipher_blocksize(big_key_skcipher)); 299 loff_t pos = 0; 300 301 data = kmalloc(enclen, GFP_KERNEL); 302 if (!data) 303 return -ENOMEM; 304 305 file = dentry_open(path, O_RDONLY, current_cred()); 306 if (IS_ERR(file)) { 307 ret = PTR_ERR(file); 308 goto error; 309 } 310 311 /* read file to kernel and decrypt */ 312 ret = kernel_read(file, data, enclen, &pos); 313 if (ret >= 0 && ret != enclen) { 314 ret = -EIO; 315 goto err_fput; 316 } 317 318 ret = big_key_crypt(BIG_KEY_DEC, data, enclen, enckey); 319 if (ret) 320 goto err_fput; 321 322 ret = datalen; 323 324 /* copy decrypted data to user */ 325 if (copy_to_user(buffer, data, datalen) != 0) 326 ret = -EFAULT; 327 328 err_fput: 329 fput(file); 330 error: 331 kfree(data); 332 } else { 333 ret = datalen; 334 if (copy_to_user(buffer, key->payload.data[big_key_data], 335 datalen) != 0) 336 ret = -EFAULT; 337 } 338 339 return ret; 340 } 341 342 /* 343 * Register key type 344 */ 345 static int __init big_key_init(void) 346 { 347 struct crypto_skcipher *cipher; 348 struct crypto_rng *rng; 349 int ret; 350 351 rng = crypto_alloc_rng(big_key_rng_name, 0, 0); 352 if (IS_ERR(rng)) { 353 pr_err("Can't alloc rng: %ld\n", PTR_ERR(rng)); 354 return PTR_ERR(rng); 355 } 356 357 big_key_rng = rng; 358 359 /* seed RNG */ 360 ret = crypto_rng_reset(rng, NULL, crypto_rng_seedsize(rng)); 361 if (ret) { 362 pr_err("Can't reset rng: %d\n", ret); 363 goto error_rng; 364 } 365 366 /* init block cipher */ 367 cipher = crypto_alloc_skcipher(big_key_alg_name, 0, CRYPTO_ALG_ASYNC); 368 if (IS_ERR(cipher)) { 369 ret = PTR_ERR(cipher); 370 pr_err("Can't alloc crypto: %d\n", ret); 371 goto error_rng; 372 } 373 374 big_key_skcipher = cipher; 375 376 ret = register_key_type(&key_type_big_key); 377 if (ret < 0) { 378 pr_err("Can't register type: %d\n", ret); 379 goto error_cipher; 380 } 381 382 return 0; 383 384 error_cipher: 385 crypto_free_skcipher(big_key_skcipher); 386 error_rng: 387 crypto_free_rng(big_key_rng); 388 return ret; 389 } 390 391 late_initcall(big_key_init); 392