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  * Originally written by Michael Halcrow, Ildar Muslukhov, and Uday Savagaonkar.
   8  * Heavily modified since then.
   9  */
  10
  11 #ifndef _FSCRYPT_PRIVATE_H
  12 #define _FSCRYPT_PRIVATE_H
  13
  14 #include <linux/fscrypt.h>
  15 #include <crypto/hash.h>
  16
  17 #define CONST_STRLEN(str)       (sizeof(str) - 1)
  18
  19 #define FS_KEY_DERIVATION_NONCE_SIZE    16
  20
  21 #define FSCRYPT_MIN_KEY_SIZE            16
  22
  23 /**
  24  * Encryption context for inode
  25  *
  26  * Protector format:
  27  *  1 byte: Protector format (1 = this version)
  28  *  1 byte: File contents encryption mode
  29  *  1 byte: File names encryption mode
  30  *  1 byte: Flags
  31  *  8 bytes: Master Key descriptor
  32  *  16 bytes: Encryption Key derivation nonce
  33  */
  34 struct fscrypt_context {
  35         u8 format;
  36         u8 contents_encryption_mode;
  37         u8 filenames_encryption_mode;
  38         u8 flags;
  39         u8 master_key_descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE];
  40         u8 nonce[FS_KEY_DERIVATION_NONCE_SIZE];
  41 } __packed;
  42
  43 #define FS_ENCRYPTION_CONTEXT_FORMAT_V1         1
  44
  45 /**
  46  * For encrypted symlinks, the ciphertext length is stored at the beginning
  47  * of the string in little-endian format.
  48  */
  49 struct fscrypt_symlink_data {
  50         __le16 len;
  51         char encrypted_path[1];
  52 } __packed;
  53
  54 /*
  55  * fscrypt_info - the "encryption key" for an inode
  56  *
  57  * When an encrypted file's key is made available, an instance of this struct is
  58  * allocated and stored in ->i_crypt_info.  Once created, it remains until the
  59  * inode is evicted.
  60  */
  61 struct fscrypt_info {
  62
  63         /* The actual crypto transform used for encryption and decryption */
  64         struct crypto_skcipher *ci_ctfm;
  65
  66         /*
  67          * Cipher for ESSIV IV generation.  Only set for CBC contents
  68          * encryption, otherwise is NULL.
  69          */
  70         struct crypto_cipher *ci_essiv_tfm;
  71
  72         /*
  73          * Encryption mode used for this inode.  It corresponds to either
  74          * ci_data_mode or ci_filename_mode, depending on the inode type.
  75          */
  76         struct fscrypt_mode *ci_mode;
  77
  78         /* Back-pointer to the inode */
  79         struct inode *ci_inode;
  80
  81         /*
  82          * If non-NULL, then encryption is done using the master key directly
  83          * and ci_ctfm will equal ci_direct_key->dk_ctfm.
  84          */
  85         struct fscrypt_direct_key *ci_direct_key;
  86
  87         /* fields from the fscrypt_context */
  88         u8 ci_data_mode;
  89         u8 ci_filename_mode;
  90         u8 ci_flags;
  91         u8 ci_master_key_descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE];
  92         u8 ci_nonce[FS_KEY_DERIVATION_NONCE_SIZE];
  93 };
  94
  95 typedef enum {
  96         FS_DECRYPT = 0,
  97         FS_ENCRYPT,
  98 } fscrypt_direction_t;
  99
 100 #define FS_CTX_REQUIRES_FREE_ENCRYPT_FL         0x00000001
 101
 102 static inline bool fscrypt_valid_enc_modes(u32 contents_mode,
 103                                            u32 filenames_mode)
 104 {
 105         if (contents_mode == FSCRYPT_MODE_AES_128_CBC &&
 106             filenames_mode == FSCRYPT_MODE_AES_128_CTS)
 107                 return true;
 108
 109         if (contents_mode == FSCRYPT_MODE_AES_256_XTS &&
 110             filenames_mode == FSCRYPT_MODE_AES_256_CTS)
 111                 return true;
 112
 113         if (contents_mode == FSCRYPT_MODE_ADIANTUM &&
 114             filenames_mode == FSCRYPT_MODE_ADIANTUM)
 115                 return true;
 116
 117         return false;
 118 }
 119
 120 /* crypto.c */
 121 extern struct kmem_cache *fscrypt_info_cachep;
 122 extern int fscrypt_initialize(unsigned int cop_flags);
 123 extern int fscrypt_crypt_block(const struct inode *inode,
 124                                fscrypt_direction_t rw, u64 lblk_num,
 125                                struct page *src_page, struct page *dest_page,
 126                                unsigned int len, unsigned int offs,
 127                                gfp_t gfp_flags);
 128 extern struct page *fscrypt_alloc_bounce_page(gfp_t gfp_flags);
 129 extern const struct dentry_operations fscrypt_d_ops;
 130
 131 extern void __printf(3, 4) __cold
 132 fscrypt_msg(const struct inode *inode, const char *level, const char *fmt, ...);
 133
 134 #define fscrypt_warn(inode, fmt, ...)           \
 135         fscrypt_msg((inode), KERN_WARNING, fmt, ##__VA_ARGS__)
 136 #define fscrypt_err(inode, fmt, ...)            \
 137         fscrypt_msg((inode), KERN_ERR, fmt, ##__VA_ARGS__)
 138
 139 #define FSCRYPT_MAX_IV_SIZE     32
 140
 141 union fscrypt_iv {
 142         struct {
 143                 /* logical block number within the file */
 144                 __le64 lblk_num;
 145
 146                 /* per-file nonce; only set in DIRECT_KEY mode */
 147                 u8 nonce[FS_KEY_DERIVATION_NONCE_SIZE];
 148         };
 149         u8 raw[FSCRYPT_MAX_IV_SIZE];
 150 };
 151
 152 void fscrypt_generate_iv(union fscrypt_iv *iv, u64 lblk_num,
 153                          const struct fscrypt_info *ci);
 154
 155 /* fname.c */
 156 extern int fname_encrypt(struct inode *inode, const struct qstr *iname,
 157                          u8 *out, unsigned int olen);
 158 extern bool fscrypt_fname_encrypted_size(const struct inode *inode,
 159                                          u32 orig_len, u32 max_len,
 160                                          u32 *encrypted_len_ret);
 161
 162 /* keyring.c */
 163
 164 /*
 165  * fscrypt_master_key_secret - secret key material of an in-use master key
 166  */
 167 struct fscrypt_master_key_secret {
 168
 169         /* Size of the raw key in bytes */
 170         u32                     size;
 171
 172         /* The raw key */
 173         u8                      raw[FSCRYPT_MAX_KEY_SIZE];
 174
 175 } __randomize_layout;
 176
 177 /*
 178  * fscrypt_master_key - an in-use master key
 179  *
 180  * This represents a master encryption key which has been added to the
 181  * filesystem and can be used to "unlock" the encrypted files which were
 182  * encrypted with it.
 183  */
 184 struct fscrypt_master_key {
 185
 186         /* The secret key material */
 187         struct fscrypt_master_key_secret        mk_secret;
 188
 189         /* Arbitrary key descriptor which was assigned by userspace */
 190         struct fscrypt_key_specifier            mk_spec;
 191
 192 } __randomize_layout;
 193
 194 static inline const char *master_key_spec_type(
 195                                 const struct fscrypt_key_specifier *spec)
 196 {
 197         switch (spec->type) {
 198         case FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR:
 199                 return "descriptor";
 200         }
 201         return "[unknown]";
 202 }
 203
 204 static inline int master_key_spec_len(const struct fscrypt_key_specifier *spec)
 205 {
 206         switch (spec->type) {
 207         case FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR:
 208                 return FSCRYPT_KEY_DESCRIPTOR_SIZE;
 209         }
 210         return 0;
 211 }
 212
 213 extern struct key *
 214 fscrypt_find_master_key(struct super_block *sb,
 215                         const struct fscrypt_key_specifier *mk_spec);
 216
 217 extern int __init fscrypt_init_keyring(void);
 218
 219 /* keysetup.c */
 220
 221 struct fscrypt_mode {
 222         const char *friendly_name;
 223         const char *cipher_str;
 224         int keysize;
 225         int ivsize;
 226         bool logged_impl_name;
 227         bool needs_essiv;
 228 };
 229
 230 static inline bool
 231 fscrypt_mode_supports_direct_key(const struct fscrypt_mode *mode)
 232 {
 233         return mode->ivsize >= offsetofend(union fscrypt_iv, nonce);
 234 }
 235
 236 extern struct crypto_skcipher *
 237 fscrypt_allocate_skcipher(struct fscrypt_mode *mode, const u8 *raw_key,
 238                           const struct inode *inode);
 239
 240 extern int fscrypt_set_derived_key(struct fscrypt_info *ci,
 241                                    const u8 *derived_key);
 242
 243 /* keysetup_v1.c */
 244
 245 extern void fscrypt_put_direct_key(struct fscrypt_direct_key *dk);
 246
 247 extern int fscrypt_setup_v1_file_key(struct fscrypt_info *ci,
 248                                      const u8 *raw_master_key);
 249
 250 extern int fscrypt_setup_v1_file_key_via_subscribed_keyrings(
 251                                         struct fscrypt_info *ci);
 252
 253 #endif /* _FSCRYPT_PRIVATE_H */