fs/crypto/crypto.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * This contains encryption functions for per-file encryption.
   4  *
   5  * Copyright (C) 2015, Google, Inc.
   6  * Copyright (C) 2015, Motorola Mobility
   7  *
   8  * Written by Michael Halcrow, 2014.
   9  *
  10  * Filename encryption additions
  11  *      Uday Savagaonkar, 2014
  12  * Encryption policy handling additions
  13  *      Ildar Muslukhov, 2014
  14  * Add fscrypt_pullback_bio_page()
  15  *      Jaegeuk Kim, 2015.
  16  *
  17  * This has not yet undergone a rigorous security audit.
  18  *
  19  * The usage of AES-XTS should conform to recommendations in NIST
  20  * Special Publication 800-38E and IEEE P1619/D16.
  21  */
  22
  23 #include <linux/pagemap.h>
  24 #include <linux/mempool.h>
  25 #include <linux/module.h>
  26 #include <linux/scatterlist.h>
  27 #include <linux/ratelimit.h>
  28 #include <linux/dcache.h>
  29 #include <linux/namei.h>
  30 #include <crypto/aes.h>
  31 #include <crypto/skcipher.h>
  32 #include "fscrypt_private.h"
  33
  34 static unsigned int num_prealloc_crypto_pages = 32;
  35 static unsigned int num_prealloc_crypto_ctxs = 128;
  36
  37 module_param(num_prealloc_crypto_pages, uint, 0444);
  38 MODULE_PARM_DESC(num_prealloc_crypto_pages,
  39                 "Number of crypto pages to preallocate");
  40 module_param(num_prealloc_crypto_ctxs, uint, 0444);
  41 MODULE_PARM_DESC(num_prealloc_crypto_ctxs,
  42                 "Number of crypto contexts to preallocate");
  43
  44 static mempool_t *fscrypt_bounce_page_pool = NULL;
  45
  46 static LIST_HEAD(fscrypt_free_ctxs);
  47 static DEFINE_SPINLOCK(fscrypt_ctx_lock);
  48
  49 static struct workqueue_struct *fscrypt_read_workqueue;
  50 static DEFINE_MUTEX(fscrypt_init_mutex);
  51
  52 static struct kmem_cache *fscrypt_ctx_cachep;
  53 struct kmem_cache *fscrypt_info_cachep;
  54
  55 void fscrypt_enqueue_decrypt_work(struct work_struct *work)
  56 {
  57         queue_work(fscrypt_read_workqueue, work);
  58 }
  59 EXPORT_SYMBOL(fscrypt_enqueue_decrypt_work);
  60
  61 /**
  62  * fscrypt_release_ctx() - Releases an encryption context
  63  * @ctx: The encryption context to release.
  64  *
  65  * If the encryption context was allocated from the pre-allocated pool, returns
  66  * it to that pool. Else, frees it.
  67  *
  68  * If there's a bounce page in the context, this frees that.
  69  */
  70 void fscrypt_release_ctx(struct fscrypt_ctx *ctx)
  71 {
  72         unsigned long flags;
  73
  74         if (ctx->flags & FS_CTX_HAS_BOUNCE_BUFFER_FL && ctx->w.bounce_page) {
  75                 mempool_free(ctx->w.bounce_page, fscrypt_bounce_page_pool);
  76                 ctx->w.bounce_page = NULL;
  77         }
  78         ctx->w.control_page = NULL;
  79         if (ctx->flags & FS_CTX_REQUIRES_FREE_ENCRYPT_FL) {
  80                 kmem_cache_free(fscrypt_ctx_cachep, ctx);
  81         } else {
  82                 spin_lock_irqsave(&fscrypt_ctx_lock, flags);
  83                 list_add(&ctx->free_list, &fscrypt_free_ctxs);
  84                 spin_unlock_irqrestore(&fscrypt_ctx_lock, flags);
  85         }
  86 }
  87 EXPORT_SYMBOL(fscrypt_release_ctx);
  88
  89 /**
  90  * fscrypt_get_ctx() - Gets an encryption context
  91  * @gfp_flags:   The gfp flag for memory allocation
  92  *
  93  * Allocates and initializes an encryption context.
  94  *
  95  * Return: A new encryption context on success; an ERR_PTR() otherwise.
  96  */
  97 struct fscrypt_ctx *fscrypt_get_ctx(gfp_t gfp_flags)
  98 {
  99         struct fscrypt_ctx *ctx;
 100         unsigned long flags;
 101
 102         /*
 103          * We first try getting the ctx from a free list because in
 104          * the common case the ctx will have an allocated and
 105          * initialized crypto tfm, so it's probably a worthwhile
 106          * optimization. For the bounce page, we first try getting it
 107          * from the kernel allocator because that's just about as fast
 108          * as getting it from a list and because a cache of free pages
 109          * should generally be a "last resort" option for a filesystem
 110          * to be able to do its job.
 111          */
 112         spin_lock_irqsave(&fscrypt_ctx_lock, flags);
 113         ctx = list_first_entry_or_null(&fscrypt_free_ctxs,
 114                                         struct fscrypt_ctx, free_list);
 115         if (ctx)
 116                 list_del(&ctx->free_list);
 117         spin_unlock_irqrestore(&fscrypt_ctx_lock, flags);
 118         if (!ctx) {
 119                 ctx = kmem_cache_zalloc(fscrypt_ctx_cachep, gfp_flags);
 120                 if (!ctx)
 121                         return ERR_PTR(-ENOMEM);
 122                 ctx->flags |= FS_CTX_REQUIRES_FREE_ENCRYPT_FL;
 123         } else {
 124                 ctx->flags &= ~FS_CTX_REQUIRES_FREE_ENCRYPT_FL;
 125         }
 126         ctx->flags &= ~FS_CTX_HAS_BOUNCE_BUFFER_FL;
 127         return ctx;
 128 }
 129 EXPORT_SYMBOL(fscrypt_get_ctx);
 130
 131 void fscrypt_generate_iv(union fscrypt_iv *iv, u64 lblk_num,
 132                          const struct fscrypt_info *ci)
 133 {
 134         memset(iv, 0, ci->ci_mode->ivsize);
 135         iv->lblk_num = cpu_to_le64(lblk_num);
 136
 137         if (ci->ci_flags & FS_POLICY_FLAG_DIRECT_KEY)
 138                 memcpy(iv->nonce, ci->ci_nonce, FS_KEY_DERIVATION_NONCE_SIZE);
 139
 140         if (ci->ci_essiv_tfm != NULL)
 141                 crypto_cipher_encrypt_one(ci->ci_essiv_tfm, iv->raw, iv->raw);
 142 }
 143
 144 int fscrypt_do_page_crypto(const struct inode *inode, fscrypt_direction_t rw,
 145                            u64 lblk_num, struct page *src_page,
 146                            struct page *dest_page, unsigned int len,
 147                            unsigned int offs, gfp_t gfp_flags)
 148 {
 149         union fscrypt_iv iv;
 150         struct skcipher_request *req = NULL;
 151         DECLARE_CRYPTO_WAIT(wait);
 152         struct scatterlist dst, src;
 153         struct fscrypt_info *ci = inode->i_crypt_info;
 154         struct crypto_skcipher *tfm = ci->ci_ctfm;
 155         int res = 0;
 156
 157         BUG_ON(len == 0);
 158
 159         fscrypt_generate_iv(&iv, lblk_num, ci);
 160
 161         req = skcipher_request_alloc(tfm, gfp_flags);
 162         if (!req)
 163                 return -ENOMEM;
 164
 165         skcipher_request_set_callback(
 166                 req, CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,
 167                 crypto_req_done, &wait);
 168
 169         sg_init_table(&dst, 1);
 170         sg_set_page(&dst, dest_page, len, offs);
 171         sg_init_table(&src, 1);
 172         sg_set_page(&src, src_page, len, offs);
 173         skcipher_request_set_crypt(req, &src, &dst, len, &iv);
 174         if (rw == FS_DECRYPT)
 175                 res = crypto_wait_req(crypto_skcipher_decrypt(req), &wait);
 176         else
 177                 res = crypto_wait_req(crypto_skcipher_encrypt(req), &wait);
 178         skcipher_request_free(req);
 179         if (res) {
 180                 fscrypt_err(inode->i_sb,
 181                             "%scryption failed for inode %lu, block %llu: %d",
 182                             (rw == FS_DECRYPT ? "de" : "en"),
 183                             inode->i_ino, lblk_num, res);
 184                 return res;
 185         }
 186         return 0;
 187 }
 188
 189 struct page *fscrypt_alloc_bounce_page(struct fscrypt_ctx *ctx,
 190                                        gfp_t gfp_flags)
 191 {
 192         ctx->w.bounce_page = mempool_alloc(fscrypt_bounce_page_pool, gfp_flags);
 193         if (ctx->w.bounce_page == NULL)
 194                 return ERR_PTR(-ENOMEM);
 195         ctx->flags |= FS_CTX_HAS_BOUNCE_BUFFER_FL;
 196         return ctx->w.bounce_page;
 197 }
 198
 199 /**
 200  * fscypt_encrypt_page() - Encrypts a page
 201  * @inode:     The inode for which the encryption should take place
 202  * @page:      The page to encrypt. Must be locked for bounce-page
 203  *             encryption.
 204  * @len:       Length of data to encrypt in @page and encrypted
 205  *             data in returned page.
 206  * @offs:      Offset of data within @page and returned
 207  *             page holding encrypted data.
 208  * @lblk_num:  Logical block number. This must be unique for multiple
 209  *             calls with same inode, except when overwriting
 210  *             previously written data.
 211  * @gfp_flags: The gfp flag for memory allocation
 212  *
 213  * Encrypts @page using the ctx encryption context. Performs encryption
 214  * either in-place or into a newly allocated bounce page.
 215  * Called on the page write path.
 216  *
 217  * Bounce page allocation is the default.
 218  * In this case, the contents of @page are encrypted and stored in an
 219  * allocated bounce page. @page has to be locked and the caller must call
 220  * fscrypt_restore_control_page() on the returned ciphertext page to
 221  * release the bounce buffer and the encryption context.
 222  *
 223  * In-place encryption is used by setting the FS_CFLG_OWN_PAGES flag in
 224  * fscrypt_operations. Here, the input-page is returned with its content
 225  * encrypted.
 226  *
 227  * Return: A page with the encrypted content on success. Else, an
 228  * error value or NULL.
 229  */
 230 struct page *fscrypt_encrypt_page(const struct inode *inode,
 231                                 struct page *page,
 232                                 unsigned int len,
 233                                 unsigned int offs,
 234                                 u64 lblk_num, gfp_t gfp_flags)
 235
 236 {
 237         struct fscrypt_ctx *ctx;
 238         struct page *ciphertext_page = page;
 239         int err;
 240
 241         BUG_ON(len % FS_CRYPTO_BLOCK_SIZE != 0);
 242
 243         if (inode->i_sb->s_cop->flags & FS_CFLG_OWN_PAGES) {
 244                 /* with inplace-encryption we just encrypt the page */
 245                 err = fscrypt_do_page_crypto(inode, FS_ENCRYPT, lblk_num, page,
 246                                              ciphertext_page, len, offs,
 247                                              gfp_flags);
 248                 if (err)
 249                         return ERR_PTR(err);
 250
 251                 return ciphertext_page;
 252         }
 253
 254         BUG_ON(!PageLocked(page));
 255
 256         ctx = fscrypt_get_ctx(gfp_flags);
 257         if (IS_ERR(ctx))
 258                 return ERR_CAST(ctx);
 259
 260         /* The encryption operation will require a bounce page. */
 261         ciphertext_page = fscrypt_alloc_bounce_page(ctx, gfp_flags);
 262         if (IS_ERR(ciphertext_page))
 263                 goto errout;
 264
 265         ctx->w.control_page = page;
 266         err = fscrypt_do_page_crypto(inode, FS_ENCRYPT, lblk_num,
 267                                      page, ciphertext_page, len, offs,
 268                                      gfp_flags);
 269         if (err) {
 270                 ciphertext_page = ERR_PTR(err);
 271                 goto errout;
 272         }
 273         SetPagePrivate(ciphertext_page);
 274         set_page_private(ciphertext_page, (unsigned long)ctx);
 275         lock_page(ciphertext_page);
 276         return ciphertext_page;
 277
 278 errout:
 279         fscrypt_release_ctx(ctx);
 280         return ciphertext_page;
 281 }
 282 EXPORT_SYMBOL(fscrypt_encrypt_page);
 283
 284 /**
 285  * fscrypt_decrypt_page() - Decrypts a page in-place
 286  * @inode:     The corresponding inode for the page to decrypt.
 287  * @page:      The page to decrypt. Must be locked in case
 288  *             it is a writeback page (FS_CFLG_OWN_PAGES unset).
 289  * @len:       Number of bytes in @page to be decrypted.
 290  * @offs:      Start of data in @page.
 291  * @lblk_num:  Logical block number.
 292  *
 293  * Decrypts page in-place using the ctx encryption context.
 294  *
 295  * Called from the read completion callback.
 296  *
 297  * Return: Zero on success, non-zero otherwise.
 298  */
 299 int fscrypt_decrypt_page(const struct inode *inode, struct page *page,
 300                         unsigned int len, unsigned int offs, u64 lblk_num)
 301 {
 302         if (!(inode->i_sb->s_cop->flags & FS_CFLG_OWN_PAGES))
 303                 BUG_ON(!PageLocked(page));
 304
 305         return fscrypt_do_page_crypto(inode, FS_DECRYPT, lblk_num, page, page,
 306                                       len, offs, GFP_NOFS);
 307 }
 308 EXPORT_SYMBOL(fscrypt_decrypt_page);
 309
 310 /*
 311  * Validate dentries in encrypted directories to make sure we aren't potentially
 312  * caching stale dentries after a key has been added.
 313  */
 314 static int fscrypt_d_revalidate(struct dentry *dentry, unsigned int flags)
 315 {
 316         struct dentry *dir;
 317         int err;
 318         int valid;
 319
 320         /*
 321          * Plaintext names are always valid, since fscrypt doesn't support
 322          * reverting to ciphertext names without evicting the directory's inode
 323          * -- which implies eviction of the dentries in the directory.
 324          */
 325         if (!(dentry->d_flags & DCACHE_ENCRYPTED_NAME))
 326                 return 1;
 327
 328         /*
 329          * Ciphertext name; valid if the directory's key is still unavailable.
 330          *
 331          * Although fscrypt forbids rename() on ciphertext names, we still must
 332          * use dget_parent() here rather than use ->d_parent directly.  That's
 333          * because a corrupted fs image may contain directory hard links, which
 334          * the VFS handles by moving the directory's dentry tree in the dcache
 335          * each time ->lookup() finds the directory and it already has a dentry
 336          * elsewhere.  Thus ->d_parent can be changing, and we must safely grab
 337          * a reference to some ->d_parent to prevent it from being freed.
 338          */
 339
 340         if (flags & LOOKUP_RCU)
 341                 return -ECHILD;
 342
 343         dir = dget_parent(dentry);
 344         err = fscrypt_get_encryption_info(d_inode(dir));
 345         valid = !fscrypt_has_encryption_key(d_inode(dir));
 346         dput(dir);
 347
 348         if (err < 0)
 349                 return err;
 350
 351         return valid;
 352 }
 353
 354 const struct dentry_operations fscrypt_d_ops = {
 355         .d_revalidate = fscrypt_d_revalidate,
 356 };
 357
 358 void fscrypt_restore_control_page(struct page *page)
 359 {
 360         struct fscrypt_ctx *ctx;
 361
 362         ctx = (struct fscrypt_ctx *)page_private(page);
 363         set_page_private(page, (unsigned long)NULL);
 364         ClearPagePrivate(page);
 365         unlock_page(page);
 366         fscrypt_release_ctx(ctx);
 367 }
 368 EXPORT_SYMBOL(fscrypt_restore_control_page);
 369
 370 static void fscrypt_destroy(void)
 371 {
 372         struct fscrypt_ctx *pos, *n;
 373
 374         list_for_each_entry_safe(pos, n, &fscrypt_free_ctxs, free_list)
 375                 kmem_cache_free(fscrypt_ctx_cachep, pos);
 376         INIT_LIST_HEAD(&fscrypt_free_ctxs);
 377         mempool_destroy(fscrypt_bounce_page_pool);
 378         fscrypt_bounce_page_pool = NULL;
 379 }
 380
 381 /**
 382  * fscrypt_initialize() - allocate major buffers for fs encryption.
 383  * @cop_flags:  fscrypt operations flags
 384  *
 385  * We only call this when we start accessing encrypted files, since it
 386  * results in memory getting allocated that wouldn't otherwise be used.
 387  *
 388  * Return: Zero on success, non-zero otherwise.
 389  */
 390 int fscrypt_initialize(unsigned int cop_flags)
 391 {
 392         int i, res = -ENOMEM;
 393
 394         /* No need to allocate a bounce page pool if this FS won't use it. */
 395         if (cop_flags & FS_CFLG_OWN_PAGES)
 396                 return 0;
 397
 398         mutex_lock(&fscrypt_init_mutex);
 399         if (fscrypt_bounce_page_pool)
 400                 goto already_initialized;
 401
 402         for (i = 0; i < num_prealloc_crypto_ctxs; i++) {
 403                 struct fscrypt_ctx *ctx;
 404
 405                 ctx = kmem_cache_zalloc(fscrypt_ctx_cachep, GFP_NOFS);
 406                 if (!ctx)
 407                         goto fail;
 408                 list_add(&ctx->free_list, &fscrypt_free_ctxs);
 409         }
 410
 411         fscrypt_bounce_page_pool =
 412                 mempool_create_page_pool(num_prealloc_crypto_pages, 0);
 413         if (!fscrypt_bounce_page_pool)
 414                 goto fail;
 415
 416 already_initialized:
 417         mutex_unlock(&fscrypt_init_mutex);
 418         return 0;
 419 fail:
 420         fscrypt_destroy();
 421         mutex_unlock(&fscrypt_init_mutex);
 422         return res;
 423 }
 424
 425 void fscrypt_msg(struct super_block *sb, const char *level,
 426                  const char *fmt, ...)
 427 {
 428         static DEFINE_RATELIMIT_STATE(rs, DEFAULT_RATELIMIT_INTERVAL,
 429                                       DEFAULT_RATELIMIT_BURST);
 430         struct va_format vaf;
 431         va_list args;
 432
 433         if (!__ratelimit(&rs))
 434                 return;
 435
 436         va_start(args, fmt);
 437         vaf.fmt = fmt;
 438         vaf.va = &args;
 439         if (sb)
 440                 printk("%sfscrypt (%s): %pV\n", level, sb->s_id, &vaf);
 441         else
 442                 printk("%sfscrypt: %pV\n", level, &vaf);
 443         va_end(args);
 444 }
 445
 446 /**
 447  * fscrypt_init() - Set up for fs encryption.
 448  */
 449 static int __init fscrypt_init(void)
 450 {
 451         /*
 452          * Use an unbound workqueue to allow bios to be decrypted in parallel
 453          * even when they happen to complete on the same CPU.  This sacrifices
 454          * locality, but it's worthwhile since decryption is CPU-intensive.
 455          *
 456          * Also use a high-priority workqueue to prioritize decryption work,
 457          * which blocks reads from completing, over regular application tasks.
 458          */
 459         fscrypt_read_workqueue = alloc_workqueue("fscrypt_read_queue",
 460                                                  WQ_UNBOUND | WQ_HIGHPRI,
 461                                                  num_online_cpus());
 462         if (!fscrypt_read_workqueue)
 463                 goto fail;
 464
 465         fscrypt_ctx_cachep = KMEM_CACHE(fscrypt_ctx, SLAB_RECLAIM_ACCOUNT);
 466         if (!fscrypt_ctx_cachep)
 467                 goto fail_free_queue;
 468
 469         fscrypt_info_cachep = KMEM_CACHE(fscrypt_info, SLAB_RECLAIM_ACCOUNT);
 470         if (!fscrypt_info_cachep)
 471                 goto fail_free_ctx;
 472
 473         return 0;
 474
 475 fail_free_ctx:
 476         kmem_cache_destroy(fscrypt_ctx_cachep);
 477 fail_free_queue:
 478         destroy_workqueue(fscrypt_read_workqueue);
 479 fail:
 480         return -ENOMEM;
 481 }
 482 module_init(fscrypt_init)
 483
 484 /**
 485  * fscrypt_exit() - Shutdown the fs encryption system
 486  */
 487 static void __exit fscrypt_exit(void)
 488 {
 489         fscrypt_destroy();
 490
 491         if (fscrypt_read_workqueue)
 492                 destroy_workqueue(fscrypt_read_workqueue);
 493         kmem_cache_destroy(fscrypt_ctx_cachep);
 494         kmem_cache_destroy(fscrypt_info_cachep);
 495
 496         fscrypt_essiv_cleanup();
 497 }
 498 module_exit(fscrypt_exit);
 499
 500 MODULE_LICENSE("GPL");