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[FSCRYPT_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         /* Back-pointer to the inode */
  77         struct inode *ci_inode;
  78
  79         /*
  80          * If non-NULL, then encryption is done using the master key directly
  81          * and ci_ctfm will equal ci_direct_key->dk_ctfm.
  82          */
  83         struct fscrypt_direct_key *ci_direct_key;
  84
  85         /* fields from the fscrypt_context */
  86         u8 ci_data_mode;
  87         u8 ci_filename_mode;
  88         u8 ci_flags;
  89         u8 ci_master_key_descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE];
  90         u8 ci_nonce[FS_KEY_DERIVATION_NONCE_SIZE];
  91 };
  92
  93 typedef enum {
  94         FS_DECRYPT = 0,
  95         FS_ENCRYPT,
  96 } fscrypt_direction_t;
  97
  98 #define FS_CTX_REQUIRES_FREE_ENCRYPT_FL         0x00000001
  99
 100 static inline bool fscrypt_valid_enc_modes(u32 contents_mode,
 101                                            u32 filenames_mode)
 102 {
 103         if (contents_mode == FSCRYPT_MODE_AES_128_CBC &&
 104             filenames_mode == FSCRYPT_MODE_AES_128_CTS)
 105                 return true;
 106
 107         if (contents_mode == FSCRYPT_MODE_AES_256_XTS &&
 108             filenames_mode == FSCRYPT_MODE_AES_256_CTS)
 109                 return true;
 110
 111         if (contents_mode == FSCRYPT_MODE_ADIANTUM &&
 112             filenames_mode == FSCRYPT_MODE_ADIANTUM)
 113                 return true;
 114
 115         return false;
 116 }
 117
 118 /* crypto.c */
 119 extern struct kmem_cache *fscrypt_info_cachep;
 120 extern int fscrypt_initialize(unsigned int cop_flags);
 121 extern int fscrypt_crypt_block(const struct inode *inode,
 122                                fscrypt_direction_t rw, u64 lblk_num,
 123                                struct page *src_page, struct page *dest_page,
 124                                unsigned int len, unsigned int offs,
 125                                gfp_t gfp_flags);
 126 extern struct page *fscrypt_alloc_bounce_page(gfp_t gfp_flags);
 127 extern const struct dentry_operations fscrypt_d_ops;
 128
 129 extern void __printf(3, 4) __cold
 130 fscrypt_msg(const struct inode *inode, const char *level, const char *fmt, ...);
 131
 132 #define fscrypt_warn(inode, fmt, ...)           \
 133         fscrypt_msg((inode), KERN_WARNING, fmt, ##__VA_ARGS__)
 134 #define fscrypt_err(inode, fmt, ...)            \
 135         fscrypt_msg((inode), KERN_ERR, fmt, ##__VA_ARGS__)
 136
 137 #define FSCRYPT_MAX_IV_SIZE     32
 138
 139 union fscrypt_iv {
 140         struct {
 141                 /* logical block number within the file */
 142                 __le64 lblk_num;
 143
 144                 /* per-file nonce; only set in DIRECT_KEY mode */
 145                 u8 nonce[FS_KEY_DERIVATION_NONCE_SIZE];
 146         };
 147         u8 raw[FSCRYPT_MAX_IV_SIZE];
 148 };
 149
 150 void fscrypt_generate_iv(union fscrypt_iv *iv, u64 lblk_num,
 151                          const struct fscrypt_info *ci);
 152
 153 /* fname.c */
 154 extern int fname_encrypt(struct inode *inode, const struct qstr *iname,
 155                          u8 *out, unsigned int olen);
 156 extern bool fscrypt_fname_encrypted_size(const struct inode *inode,
 157                                          u32 orig_len, u32 max_len,
 158                                          u32 *encrypted_len_ret);
 159
 160 /* keyinfo.c */
 161
 162 struct fscrypt_mode {
 163         const char *friendly_name;
 164         const char *cipher_str;
 165         int keysize;
 166         int ivsize;
 167         bool logged_impl_name;
 168         bool needs_essiv;
 169 };
 170
 171 #endif /* _FSCRYPT_PRIVATE_H */