security/keys/big_key.c

   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);