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 /* Encryption parameters */
  18 #define FS_KEY_DERIVATION_NONCE_SIZE    16
  19
  20 /**
  21  * Encryption context for inode
  22  *
  23  * Protector format:
  24  *  1 byte: Protector format (1 = this version)
  25  *  1 byte: File contents encryption mode
  26  *  1 byte: File names encryption mode
  27  *  1 byte: Flags
  28  *  8 bytes: Master Key descriptor
  29  *  16 bytes: Encryption Key derivation nonce
  30  */
  31 struct fscrypt_context {
  32         u8 format;
  33         u8 contents_encryption_mode;
  34         u8 filenames_encryption_mode;
  35         u8 flags;
  36         u8 master_key_descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE];
  37         u8 nonce[FS_KEY_DERIVATION_NONCE_SIZE];
  38 } __packed;
  39
  40 #define FS_ENCRYPTION_CONTEXT_FORMAT_V1         1
  41
  42 /**
  43  * For encrypted symlinks, the ciphertext length is stored at the beginning
  44  * of the string in little-endian format.
  45  */
  46 struct fscrypt_symlink_data {
  47         __le16 len;
  48         char encrypted_path[1];
  49 } __packed;
  50
  51 /*
  52  * fscrypt_info - the "encryption key" for an inode
  53  *
  54  * When an encrypted file's key is made available, an instance of this struct is
  55  * allocated and stored in ->i_crypt_info.  Once created, it remains until the
  56  * inode is evicted.
  57  */
  58 struct fscrypt_info {
  59
  60         /* The actual crypto transform used for encryption and decryption */
  61         struct crypto_skcipher *ci_ctfm;
  62
  63         /*
  64          * Cipher for ESSIV IV generation.  Only set for CBC contents
  65          * encryption, otherwise is NULL.
  66          */
  67         struct crypto_cipher *ci_essiv_tfm;
  68
  69         /*
  70          * Encryption mode used for this inode.  It corresponds to either
  71          * ci_data_mode or ci_filename_mode, depending on the inode type.
  72          */
  73         struct fscrypt_mode *ci_mode;
  74
  75         /* Back-pointer to the inode */
  76         struct inode *ci_inode;
  77
  78         /*
  79          * If non-NULL, then encryption is done using the master key directly
  80          * and ci_ctfm will equal ci_direct_key->dk_ctfm.
  81          */
  82         struct fscrypt_direct_key *ci_direct_key;
  83
  84         /* fields from the fscrypt_context */
  85         u8 ci_data_mode;
  86         u8 ci_filename_mode;
  87         u8 ci_flags;
  88         u8 ci_master_key_descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE];
  89         u8 ci_nonce[FS_KEY_DERIVATION_NONCE_SIZE];
  90 };
  91
  92 typedef enum {
  93         FS_DECRYPT = 0,
  94         FS_ENCRYPT,
  95 } fscrypt_direction_t;
  96
  97 #define FS_CTX_REQUIRES_FREE_ENCRYPT_FL         0x00000001
  98
  99 static inline bool fscrypt_valid_enc_modes(u32 contents_mode,
 100                                            u32 filenames_mode)
 101 {
 102         if (contents_mode == FSCRYPT_MODE_AES_128_CBC &&
 103             filenames_mode == FSCRYPT_MODE_AES_128_CTS)
 104                 return true;
 105
 106         if (contents_mode == FSCRYPT_MODE_AES_256_XTS &&
 107             filenames_mode == FSCRYPT_MODE_AES_256_CTS)
 108                 return true;
 109
 110         if (contents_mode == FSCRYPT_MODE_ADIANTUM &&
 111             filenames_mode == FSCRYPT_MODE_ADIANTUM)
 112                 return true;
 113
 114         return false;
 115 }
 116
 117 /* crypto.c */
 118 extern struct kmem_cache *fscrypt_info_cachep;
 119 extern int fscrypt_initialize(unsigned int cop_flags);
 120 extern int fscrypt_crypt_block(const struct inode *inode,
 121                                fscrypt_direction_t rw, u64 lblk_num,
 122                                struct page *src_page, struct page *dest_page,
 123                                unsigned int len, unsigned int offs,
 124                                gfp_t gfp_flags);
 125 extern struct page *fscrypt_alloc_bounce_page(gfp_t gfp_flags);
 126 extern const struct dentry_operations fscrypt_d_ops;
 127
 128 extern void __printf(3, 4) __cold
 129 fscrypt_msg(const struct inode *inode, const char *level, const char *fmt, ...);
 130
 131 #define fscrypt_warn(inode, fmt, ...)           \
 132         fscrypt_msg((inode), KERN_WARNING, fmt, ##__VA_ARGS__)
 133 #define fscrypt_err(inode, fmt, ...)            \
 134         fscrypt_msg((inode), KERN_ERR, fmt, ##__VA_ARGS__)
 135
 136 #define FSCRYPT_MAX_IV_SIZE     32
 137
 138 union fscrypt_iv {
 139         struct {
 140                 /* logical block number within the file */
 141                 __le64 lblk_num;
 142
 143                 /* per-file nonce; only set in DIRECT_KEY mode */
 144                 u8 nonce[FS_KEY_DERIVATION_NONCE_SIZE];
 145         };
 146         u8 raw[FSCRYPT_MAX_IV_SIZE];
 147 };
 148
 149 void fscrypt_generate_iv(union fscrypt_iv *iv, u64 lblk_num,
 150                          const struct fscrypt_info *ci);
 151
 152 /* fname.c */
 153 extern int fname_encrypt(struct inode *inode, const struct qstr *iname,
 154                          u8 *out, unsigned int olen);
 155 extern bool fscrypt_fname_encrypted_size(const struct inode *inode,
 156                                          u32 orig_len, u32 max_len,
 157                                          u32 *encrypted_len_ret);
 158
 159 /* keyinfo.c */
 160
 161 struct fscrypt_mode {
 162         const char *friendly_name;
 163         const char *cipher_str;
 164         int keysize;
 165         int ivsize;
 166         bool logged_impl_name;
 167         bool needs_essiv;
 168 };
 169
 170 static inline bool
 171 fscrypt_mode_supports_direct_key(const struct fscrypt_mode *mode)
 172 {
 173         return mode->ivsize >= offsetofend(union fscrypt_iv, nonce);
 174 }
 175
 176 extern struct crypto_skcipher *
 177 fscrypt_allocate_skcipher(struct fscrypt_mode *mode, const u8 *raw_key,
 178                           const struct inode *inode);
 179
 180 extern int fscrypt_set_derived_key(struct fscrypt_info *ci,
 181                                    const u8 *derived_key);
 182
 183 /* keysetup_v1.c */
 184
 185 extern void fscrypt_put_direct_key(struct fscrypt_direct_key *dk);
 186
 187 extern int fscrypt_setup_v1_file_key(struct fscrypt_info *ci,
 188                                      const u8 *raw_master_key);
 189
 190 extern int fscrypt_setup_v1_file_key_via_subscribed_keyrings(
 191                                         struct fscrypt_info *ci);
 192
 193 #endif /* _FSCRYPT_PRIVATE_H */