fs/crypto/fscrypt_private.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * fscrypt_private.h
   4  *
   5  * Copyright (C) 2015, Google, Inc.
   6  *
   7  * This contains encryption key functions.
   8  *
   9  * Written by Michael Halcrow, Ildar Muslukhov, and Uday Savagaonkar, 2015.
  10  */
  11
  12 #ifndef _FSCRYPT_PRIVATE_H
  13 #define _FSCRYPT_PRIVATE_H
  14
  15 #include <linux/fscrypt.h>
  16 #include <crypto/hash.h>
  17
  18 /* Encryption parameters */
  19 #define FS_KEY_DERIVATION_NONCE_SIZE    16
  20
  21 /**
  22  * Encryption context for inode
  23  *
  24  * Protector format:
  25  *  1 byte: Protector format (1 = this version)
  26  *  1 byte: File contents encryption mode
  27  *  1 byte: File names encryption mode
  28  *  1 byte: Flags
  29  *  8 bytes: Master Key descriptor
  30  *  16 bytes: Encryption Key derivation nonce
  31  */
  32 struct fscrypt_context {
  33         u8 format;
  34         u8 contents_encryption_mode;
  35         u8 filenames_encryption_mode;
  36         u8 flags;
  37         u8 master_key_descriptor[FS_KEY_DESCRIPTOR_SIZE];
  38         u8 nonce[FS_KEY_DERIVATION_NONCE_SIZE];
  39 } __packed;
  40
  41 #define FS_ENCRYPTION_CONTEXT_FORMAT_V1         1
  42
  43 /**
  44  * For encrypted symlinks, the ciphertext length is stored at the beginning
  45  * of the string in little-endian format.
  46  */
  47 struct fscrypt_symlink_data {
  48         __le16 len;
  49         char encrypted_path[1];
  50 } __packed;
  51
  52 /*
  53  * fscrypt_info - the "encryption key" for an inode
  54  *
  55  * When an encrypted file's key is made available, an instance of this struct is
  56  * allocated and stored in ->i_crypt_info.  Once created, it remains until the
  57  * inode is evicted.
  58  */
  59 struct fscrypt_info {
  60
  61         /* The actual crypto transform used for encryption and decryption */
  62         struct crypto_skcipher *ci_ctfm;
  63
  64         /*
  65          * Cipher for ESSIV IV generation.  Only set for CBC contents
  66          * encryption, otherwise is NULL.
  67          */
  68         struct crypto_cipher *ci_essiv_tfm;
  69
  70         /*
  71          * Encryption mode used for this inode.  It corresponds to either
  72          * ci_data_mode or ci_filename_mode, depending on the inode type.
  73          */
  74         struct fscrypt_mode *ci_mode;
  75
  76         /*
  77          * If non-NULL, then this inode uses a master key directly rather than a
  78          * derived key, and ci_ctfm will equal ci_master_key->mk_ctfm.
  79          * Otherwise, this inode uses a derived key.
  80          */
  81         struct fscrypt_master_key *ci_master_key;
  82
  83         /* fields from the fscrypt_context */
  84         u8 ci_data_mode;
  85         u8 ci_filename_mode;
  86         u8 ci_flags;
  87         u8 ci_master_key_descriptor[FS_KEY_DESCRIPTOR_SIZE];
  88         u8 ci_nonce[FS_KEY_DERIVATION_NONCE_SIZE];
  89 };
  90
  91 typedef enum {
  92         FS_DECRYPT = 0,
  93         FS_ENCRYPT,
  94 } fscrypt_direction_t;
  95
  96 #define FS_CTX_REQUIRES_FREE_ENCRYPT_FL         0x00000001
  97
  98 static inline bool fscrypt_valid_enc_modes(u32 contents_mode,
  99                                            u32 filenames_mode)
 100 {
 101         if (contents_mode == FS_ENCRYPTION_MODE_AES_128_CBC &&
 102             filenames_mode == FS_ENCRYPTION_MODE_AES_128_CTS)
 103                 return true;
 104
 105         if (contents_mode == FS_ENCRYPTION_MODE_AES_256_XTS &&
 106             filenames_mode == FS_ENCRYPTION_MODE_AES_256_CTS)
 107                 return true;
 108
 109         if (contents_mode == FS_ENCRYPTION_MODE_ADIANTUM &&
 110             filenames_mode == FS_ENCRYPTION_MODE_ADIANTUM)
 111                 return true;
 112
 113         return false;
 114 }
 115
 116 /* crypto.c */
 117 extern struct kmem_cache *fscrypt_info_cachep;
 118 extern int fscrypt_initialize(unsigned int cop_flags);
 119 extern int fscrypt_crypt_block(const struct inode *inode,
 120                                fscrypt_direction_t rw, u64 lblk_num,
 121                                struct page *src_page, struct page *dest_page,
 122                                unsigned int len, unsigned int offs,
 123                                gfp_t gfp_flags);
 124 extern struct page *fscrypt_alloc_bounce_page(gfp_t gfp_flags);
 125 extern const struct dentry_operations fscrypt_d_ops;
 126
 127 extern void __printf(3, 4) __cold
 128 fscrypt_msg(struct super_block *sb, const char *level, const char *fmt, ...);
 129
 130 #define fscrypt_warn(sb, fmt, ...)              \
 131         fscrypt_msg(sb, KERN_WARNING, fmt, ##__VA_ARGS__)
 132 #define fscrypt_err(sb, fmt, ...)               \
 133         fscrypt_msg(sb, KERN_ERR, fmt, ##__VA_ARGS__)
 134
 135 #define FSCRYPT_MAX_IV_SIZE     32
 136
 137 union fscrypt_iv {
 138         struct {
 139                 /* logical block number within the file */
 140                 __le64 lblk_num;
 141
 142                 /* per-file nonce; only set in DIRECT_KEY mode */
 143                 u8 nonce[FS_KEY_DERIVATION_NONCE_SIZE];
 144         };
 145         u8 raw[FSCRYPT_MAX_IV_SIZE];
 146 };
 147
 148 void fscrypt_generate_iv(union fscrypt_iv *iv, u64 lblk_num,
 149                          const struct fscrypt_info *ci);
 150
 151 /* fname.c */
 152 extern int fname_encrypt(struct inode *inode, const struct qstr *iname,
 153                          u8 *out, unsigned int olen);
 154 extern bool fscrypt_fname_encrypted_size(const struct inode *inode,
 155                                          u32 orig_len, u32 max_len,
 156                                          u32 *encrypted_len_ret);
 157
 158 /* keyinfo.c */
 159
 160 struct fscrypt_mode {
 161         const char *friendly_name;
 162         const char *cipher_str;
 163         int keysize;
 164         int ivsize;
 165         bool logged_impl_name;
 166         bool needs_essiv;
 167 };
 168
 169 extern void __exit fscrypt_essiv_cleanup(void);
 170
 171 #endif /* _FSCRYPT_PRIVATE_H */