blob: 0d9ebfd3bf3a54f6a8ee6837518d45b1ac83a9d2 [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001/* SPDX-License-Identifier: GPL-2.0 */
Theodore Ts'o3325bea2016-11-26 20:32:46 -05002/*
3 * fscrypt_private.h
4 *
5 * Copyright (C) 2015, Google, Inc.
6 *
Eric Biggers3ec4f2a62019-08-04 19:35:45 -07007 * Originally written by Michael Halcrow, Ildar Muslukhov, and Uday Savagaonkar.
8 * Heavily modified since then.
Theodore Ts'o3325bea2016-11-26 20:32:46 -05009 */
10
11#ifndef _FSCRYPT_PRIVATE_H
12#define _FSCRYPT_PRIVATE_H
13
Dave Chinner734f0d22017-10-09 12:15:34 -070014#include <linux/fscrypt.h>
Daniel Walterb7e7cf72017-06-19 09:27:58 +020015#include <crypto/hash.h>
Theodore Ts'o3325bea2016-11-26 20:32:46 -050016
Eric Biggers22d94f42019-08-04 19:35:46 -070017#define CONST_STRLEN(str) (sizeof(str) - 1)
18
Eric Biggers11b88182018-04-30 15:51:46 -070019#define FS_KEY_DERIVATION_NONCE_SIZE 16
Theodore Ts'occ4e0df2016-11-26 22:05:18 -050020
Eric Biggers22d94f42019-08-04 19:35:46 -070021#define FSCRYPT_MIN_KEY_SIZE 16
22
Theodore Ts'occ4e0df2016-11-26 22:05:18 -050023/**
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 */
34struct fscrypt_context {
35 u8 format;
36 u8 contents_encryption_mode;
37 u8 filenames_encryption_mode;
38 u8 flags;
Eric Biggers3b6df592019-08-04 19:35:44 -070039 u8 master_key_descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE];
Theodore Ts'occ4e0df2016-11-26 22:05:18 -050040 u8 nonce[FS_KEY_DERIVATION_NONCE_SIZE];
41} __packed;
42
43#define FS_ENCRYPTION_CONTEXT_FORMAT_V1 1
44
Eric Biggers0eaab5b2018-01-11 23:30:08 -050045/**
46 * For encrypted symlinks, the ciphertext length is stored at the beginning
47 * of the string in little-endian format.
48 */
49struct fscrypt_symlink_data {
50 __le16 len;
51 char encrypted_path[1];
52} __packed;
53
Theodore Ts'occ4e0df2016-11-26 22:05:18 -050054/*
Eric Biggers8094c3c2019-01-06 08:36:21 -050055 * 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.
Theodore Ts'occ4e0df2016-11-26 22:05:18 -050060 */
61struct fscrypt_info {
Eric Biggers8094c3c2019-01-06 08:36:21 -050062
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
Eric Biggers59dc6a82019-08-04 19:35:44 -070078 /* Back-pointer to the inode */
79 struct inode *ci_inode;
80
Eric Biggers8094c3c2019-01-06 08:36:21 -050081 /*
Eric Biggersa828daa2019-08-04 19:35:45 -070082 * If non-NULL, then encryption is done using the master key directly
83 * and ci_ctfm will equal ci_direct_key->dk_ctfm.
Eric Biggers8094c3c2019-01-06 08:36:21 -050084 */
Eric Biggersa828daa2019-08-04 19:35:45 -070085 struct fscrypt_direct_key *ci_direct_key;
Eric Biggers8094c3c2019-01-06 08:36:21 -050086
87 /* fields from the fscrypt_context */
Theodore Ts'occ4e0df2016-11-26 22:05:18 -050088 u8 ci_data_mode;
89 u8 ci_filename_mode;
90 u8 ci_flags;
Eric Biggers3b6df592019-08-04 19:35:44 -070091 u8 ci_master_key_descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE];
Eric Biggers8094c3c2019-01-06 08:36:21 -050092 u8 ci_nonce[FS_KEY_DERIVATION_NONCE_SIZE];
Theodore Ts'occ4e0df2016-11-26 22:05:18 -050093};
94
Richard Weinberger58ae7462016-12-19 12:25:32 +010095typedef enum {
96 FS_DECRYPT = 0,
97 FS_ENCRYPT,
98} fscrypt_direction_t;
99
Theodore Ts'occ4e0df2016-11-26 22:05:18 -0500100#define FS_CTX_REQUIRES_FREE_ENCRYPT_FL 0x00000001
Theodore Ts'occ4e0df2016-11-26 22:05:18 -0500101
Eric Biggersbb8179e2018-01-05 10:44:58 -0800102static inline bool fscrypt_valid_enc_modes(u32 contents_mode,
103 u32 filenames_mode)
104{
Eric Biggers3b6df592019-08-04 19:35:44 -0700105 if (contents_mode == FSCRYPT_MODE_AES_128_CBC &&
106 filenames_mode == FSCRYPT_MODE_AES_128_CTS)
Eric Biggersbb8179e2018-01-05 10:44:58 -0800107 return true;
108
Eric Biggers3b6df592019-08-04 19:35:44 -0700109 if (contents_mode == FSCRYPT_MODE_AES_256_XTS &&
110 filenames_mode == FSCRYPT_MODE_AES_256_CTS)
Eric Biggersbb8179e2018-01-05 10:44:58 -0800111 return true;
112
Eric Biggers3b6df592019-08-04 19:35:44 -0700113 if (contents_mode == FSCRYPT_MODE_ADIANTUM &&
114 filenames_mode == FSCRYPT_MODE_ADIANTUM)
Eric Biggers8094c3c2019-01-06 08:36:21 -0500115 return true;
116
Eric Biggersbb8179e2018-01-05 10:44:58 -0800117 return false;
118}
119
Theodore Ts'ob98701df2016-11-26 20:43:09 -0500120/* crypto.c */
Eric Biggerse4de7822018-01-05 10:44:54 -0800121extern struct kmem_cache *fscrypt_info_cachep;
Richard Weinberger58ae7462016-12-19 12:25:32 +0100122extern int fscrypt_initialize(unsigned int cop_flags);
Eric Biggersf47fcbb2019-05-20 09:29:41 -0700123extern 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);
Eric Biggersd2d07272019-05-20 09:29:39 -0700128extern struct page *fscrypt_alloc_bounce_page(gfp_t gfp_flags);
Eric Biggers54222022018-04-30 15:51:36 -0700129extern const struct dentry_operations fscrypt_d_ops;
Theodore Ts'ob98701df2016-11-26 20:43:09 -0500130
Eric Biggers544d08f2018-04-30 15:51:47 -0700131extern void __printf(3, 4) __cold
Eric Biggers886da8b2019-07-24 11:07:58 -0700132fscrypt_msg(const struct inode *inode, const char *level, const char *fmt, ...);
Eric Biggers544d08f2018-04-30 15:51:47 -0700133
Eric Biggers886da8b2019-07-24 11:07:58 -0700134#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__)
Eric Biggers544d08f2018-04-30 15:51:47 -0700138
Eric Biggers8094c3c2019-01-06 08:36:21 -0500139#define FSCRYPT_MAX_IV_SIZE 32
140
141union 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
152void fscrypt_generate_iv(union fscrypt_iv *iv, u64 lblk_num,
153 const struct fscrypt_info *ci);
154
Eric Biggers76e81d62018-01-05 10:45:01 -0800155/* fname.c */
Eric Biggers50c961d2018-01-11 23:30:08 -0500156extern int fname_encrypt(struct inode *inode, const struct qstr *iname,
157 u8 *out, unsigned int olen);
Eric Biggersb9db0b42018-01-11 23:30:08 -0500158extern bool fscrypt_fname_encrypted_size(const struct inode *inode,
159 u32 orig_len, u32 max_len,
160 u32 *encrypted_len_ret);
Eric Biggers76e81d62018-01-05 10:45:01 -0800161
Eric Biggers22d94f42019-08-04 19:35:46 -0700162/* keyring.c */
163
164/*
165 * fscrypt_master_key_secret - secret key material of an in-use master key
166 */
167struct 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 */
184struct 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
194static 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
204static 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
213extern struct key *
214fscrypt_find_master_key(struct super_block *sb,
215 const struct fscrypt_key_specifier *mk_spec);
216
217extern int __init fscrypt_init_keyring(void);
218
Eric Biggersfeed8252019-08-04 19:35:45 -0700219/* keysetup.c */
Eric Biggers8094c3c2019-01-06 08:36:21 -0500220
221struct 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
Eric Biggers3ec4f2a62019-08-04 19:35:45 -0700230static inline bool
231fscrypt_mode_supports_direct_key(const struct fscrypt_mode *mode)
232{
233 return mode->ivsize >= offsetofend(union fscrypt_iv, nonce);
234}
235
Eric Biggers0109ce762019-08-04 19:35:45 -0700236extern struct crypto_skcipher *
237fscrypt_allocate_skcipher(struct fscrypt_mode *mode, const u8 *raw_key,
238 const struct inode *inode);
239
240extern int fscrypt_set_derived_key(struct fscrypt_info *ci,
241 const u8 *derived_key);
242
243/* keysetup_v1.c */
244
245extern void fscrypt_put_direct_key(struct fscrypt_direct_key *dk);
246
247extern int fscrypt_setup_v1_file_key(struct fscrypt_info *ci,
248 const u8 *raw_master_key);
249
250extern int fscrypt_setup_v1_file_key_via_subscribed_keyrings(
251 struct fscrypt_info *ci);
252
Theodore Ts'o3325bea2016-11-26 20:32:46 -0500253#endif /* _FSCRYPT_PRIVATE_H */