1
2
3
4
5
6
7
8
9
10
11#ifndef _FSCRYPT_PRIVATE_H
12#define _FSCRYPT_PRIVATE_H
13
14#include <linux/fscrypt.h>
15#include <linux/siphash.h>
16#include <crypto/hash.h>
17#include <linux/blk-crypto.h>
18
19#define CONST_STRLEN(str) (sizeof(str) - 1)
20
21#define FSCRYPT_FILE_NONCE_SIZE 16
22
23#define FSCRYPT_MIN_KEY_SIZE 16
24
25#define FSCRYPT_CONTEXT_V1 1
26#define FSCRYPT_CONTEXT_V2 2
27
28
29#define FSCRYPT_MODE_MAX FSCRYPT_MODE_ADIANTUM
30
31struct fscrypt_context_v1 {
32 u8 version;
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[FSCRYPT_FILE_NONCE_SIZE];
38};
39
40struct fscrypt_context_v2 {
41 u8 version;
42 u8 contents_encryption_mode;
43 u8 filenames_encryption_mode;
44 u8 flags;
45 u8 __reserved[4];
46 u8 master_key_identifier[FSCRYPT_KEY_IDENTIFIER_SIZE];
47 u8 nonce[FSCRYPT_FILE_NONCE_SIZE];
48};
49
50
51
52
53
54
55
56
57
58
59
60union fscrypt_context {
61 u8 version;
62 struct fscrypt_context_v1 v1;
63 struct fscrypt_context_v2 v2;
64};
65
66
67
68
69
70static inline int fscrypt_context_size(const union fscrypt_context *ctx)
71{
72 switch (ctx->version) {
73 case FSCRYPT_CONTEXT_V1:
74 BUILD_BUG_ON(sizeof(ctx->v1) != 28);
75 return sizeof(ctx->v1);
76 case FSCRYPT_CONTEXT_V2:
77 BUILD_BUG_ON(sizeof(ctx->v2) != 40);
78 return sizeof(ctx->v2);
79 }
80 return 0;
81}
82
83
84static inline bool fscrypt_context_is_valid(const union fscrypt_context *ctx,
85 int ctx_size)
86{
87 return ctx_size >= 1 && ctx_size == fscrypt_context_size(ctx);
88}
89
90
91static inline const u8 *fscrypt_context_nonce(const union fscrypt_context *ctx)
92{
93 switch (ctx->version) {
94 case FSCRYPT_CONTEXT_V1:
95 return ctx->v1.nonce;
96 case FSCRYPT_CONTEXT_V2:
97 return ctx->v2.nonce;
98 }
99 WARN_ON(1);
100 return NULL;
101}
102
103union fscrypt_policy {
104 u8 version;
105 struct fscrypt_policy_v1 v1;
106 struct fscrypt_policy_v2 v2;
107};
108
109
110
111
112
113static inline int fscrypt_policy_size(const union fscrypt_policy *policy)
114{
115 switch (policy->version) {
116 case FSCRYPT_POLICY_V1:
117 return sizeof(policy->v1);
118 case FSCRYPT_POLICY_V2:
119 return sizeof(policy->v2);
120 }
121 return 0;
122}
123
124
125static inline u8
126fscrypt_policy_contents_mode(const union fscrypt_policy *policy)
127{
128 switch (policy->version) {
129 case FSCRYPT_POLICY_V1:
130 return policy->v1.contents_encryption_mode;
131 case FSCRYPT_POLICY_V2:
132 return policy->v2.contents_encryption_mode;
133 }
134 BUG();
135}
136
137
138static inline u8
139fscrypt_policy_fnames_mode(const union fscrypt_policy *policy)
140{
141 switch (policy->version) {
142 case FSCRYPT_POLICY_V1:
143 return policy->v1.filenames_encryption_mode;
144 case FSCRYPT_POLICY_V2:
145 return policy->v2.filenames_encryption_mode;
146 }
147 BUG();
148}
149
150
151static inline u8
152fscrypt_policy_flags(const union fscrypt_policy *policy)
153{
154 switch (policy->version) {
155 case FSCRYPT_POLICY_V1:
156 return policy->v1.flags;
157 case FSCRYPT_POLICY_V2:
158 return policy->v2.flags;
159 }
160 BUG();
161}
162
163
164
165
166
167struct fscrypt_symlink_data {
168 __le16 len;
169 char encrypted_path[1];
170} __packed;
171
172
173
174
175
176
177
178
179struct fscrypt_prepared_key {
180 struct crypto_skcipher *tfm;
181#ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
182 struct fscrypt_blk_crypto_key *blk_key;
183#endif
184};
185
186
187
188
189
190
191
192
193struct fscrypt_info {
194
195
196 struct fscrypt_prepared_key ci_enc_key;
197
198
199 bool ci_owns_key;
200
201#ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
202
203
204
205
206 bool ci_inlinecrypt;
207#endif
208
209
210
211
212
213 struct fscrypt_mode *ci_mode;
214
215
216 struct inode *ci_inode;
217
218
219
220
221
222
223 struct key *ci_master_key;
224
225
226
227
228
229 struct list_head ci_master_key_link;
230
231
232
233
234
235 struct fscrypt_direct_key *ci_direct_key;
236
237
238
239
240
241
242 siphash_key_t ci_dirhash_key;
243 bool ci_dirhash_key_initialized;
244
245
246 union fscrypt_policy ci_policy;
247
248
249 u8 ci_nonce[FSCRYPT_FILE_NONCE_SIZE];
250
251
252 u32 ci_hashed_ino;
253};
254
255typedef enum {
256 FS_DECRYPT = 0,
257 FS_ENCRYPT,
258} fscrypt_direction_t;
259
260
261extern struct kmem_cache *fscrypt_info_cachep;
262int fscrypt_initialize(unsigned int cop_flags);
263int fscrypt_crypt_block(const struct inode *inode, fscrypt_direction_t rw,
264 u64 lblk_num, struct page *src_page,
265 struct page *dest_page, unsigned int len,
266 unsigned int offs, gfp_t gfp_flags);
267struct page *fscrypt_alloc_bounce_page(gfp_t gfp_flags);
268
269void __printf(3, 4) __cold
270fscrypt_msg(const struct inode *inode, const char *level, const char *fmt, ...);
271
272#define fscrypt_warn(inode, fmt, ...) \
273 fscrypt_msg((inode), KERN_WARNING, fmt, ##__VA_ARGS__)
274#define fscrypt_err(inode, fmt, ...) \
275 fscrypt_msg((inode), KERN_ERR, fmt, ##__VA_ARGS__)
276
277#define FSCRYPT_MAX_IV_SIZE 32
278
279union fscrypt_iv {
280 struct {
281
282 __le64 lblk_num;
283
284
285 u8 nonce[FSCRYPT_FILE_NONCE_SIZE];
286 };
287 u8 raw[FSCRYPT_MAX_IV_SIZE];
288 __le64 dun[FSCRYPT_MAX_IV_SIZE / sizeof(__le64)];
289};
290
291void fscrypt_generate_iv(union fscrypt_iv *iv, u64 lblk_num,
292 const struct fscrypt_info *ci);
293
294
295int fscrypt_fname_encrypt(const struct inode *inode, const struct qstr *iname,
296 u8 *out, unsigned int olen);
297bool fscrypt_fname_encrypted_size(const union fscrypt_policy *policy,
298 u32 orig_len, u32 max_len,
299 u32 *encrypted_len_ret);
300
301
302
303struct fscrypt_hkdf {
304 struct crypto_shash *hmac_tfm;
305};
306
307int fscrypt_init_hkdf(struct fscrypt_hkdf *hkdf, const u8 *master_key,
308 unsigned int master_key_size);
309
310
311
312
313
314
315
316
317#define HKDF_CONTEXT_KEY_IDENTIFIER 1
318#define HKDF_CONTEXT_PER_FILE_ENC_KEY 2
319#define HKDF_CONTEXT_DIRECT_KEY 3
320#define HKDF_CONTEXT_IV_INO_LBLK_64_KEY 4
321#define HKDF_CONTEXT_DIRHASH_KEY 5
322#define HKDF_CONTEXT_IV_INO_LBLK_32_KEY 6
323#define HKDF_CONTEXT_INODE_HASH_KEY 7
324
325int fscrypt_hkdf_expand(const struct fscrypt_hkdf *hkdf, u8 context,
326 const u8 *info, unsigned int infolen,
327 u8 *okm, unsigned int okmlen);
328
329void fscrypt_destroy_hkdf(struct fscrypt_hkdf *hkdf);
330
331
332#ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
333int fscrypt_select_encryption_impl(struct fscrypt_info *ci);
334
335static inline bool
336fscrypt_using_inline_encryption(const struct fscrypt_info *ci)
337{
338 return ci->ci_inlinecrypt;
339}
340
341int fscrypt_prepare_inline_crypt_key(struct fscrypt_prepared_key *prep_key,
342 const u8 *raw_key,
343 const struct fscrypt_info *ci);
344
345void fscrypt_destroy_inline_crypt_key(struct fscrypt_prepared_key *prep_key);
346
347
348
349
350
351static inline bool
352fscrypt_is_key_prepared(struct fscrypt_prepared_key *prep_key,
353 const struct fscrypt_info *ci)
354{
355
356
357
358
359
360
361
362
363 if (fscrypt_using_inline_encryption(ci))
364 return smp_load_acquire(&prep_key->blk_key) != NULL;
365 return smp_load_acquire(&prep_key->tfm) != NULL;
366}
367
368#else
369
370static inline int fscrypt_select_encryption_impl(struct fscrypt_info *ci)
371{
372 return 0;
373}
374
375static inline bool
376fscrypt_using_inline_encryption(const struct fscrypt_info *ci)
377{
378 return false;
379}
380
381static inline int
382fscrypt_prepare_inline_crypt_key(struct fscrypt_prepared_key *prep_key,
383 const u8 *raw_key,
384 const struct fscrypt_info *ci)
385{
386 WARN_ON(1);
387 return -EOPNOTSUPP;
388}
389
390static inline void
391fscrypt_destroy_inline_crypt_key(struct fscrypt_prepared_key *prep_key)
392{
393}
394
395static inline bool
396fscrypt_is_key_prepared(struct fscrypt_prepared_key *prep_key,
397 const struct fscrypt_info *ci)
398{
399 return smp_load_acquire(&prep_key->tfm) != NULL;
400}
401#endif
402
403
404
405
406
407
408struct fscrypt_master_key_secret {
409
410
411
412
413
414 struct fscrypt_hkdf hkdf;
415
416
417 u32 size;
418
419
420 u8 raw[FSCRYPT_MAX_KEY_SIZE];
421
422} __randomize_layout;
423
424
425
426
427
428
429
430
431struct fscrypt_master_key {
432
433
434
435
436
437
438
439
440
441
442
443 struct fscrypt_master_key_secret mk_secret;
444
445
446
447
448
449
450
451 struct fscrypt_key_specifier mk_spec;
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467 struct key *mk_users;
468
469
470
471
472
473
474
475
476 refcount_t mk_refcount;
477
478
479
480
481
482 struct list_head mk_decrypted_inodes;
483 spinlock_t mk_decrypted_inodes_lock;
484
485
486
487
488
489 struct fscrypt_prepared_key mk_direct_keys[FSCRYPT_MODE_MAX + 1];
490 struct fscrypt_prepared_key mk_iv_ino_lblk_64_keys[FSCRYPT_MODE_MAX + 1];
491 struct fscrypt_prepared_key mk_iv_ino_lblk_32_keys[FSCRYPT_MODE_MAX + 1];
492
493
494 siphash_key_t mk_ino_hash_key;
495 bool mk_ino_hash_key_initialized;
496
497} __randomize_layout;
498
499static inline bool
500is_master_key_secret_present(const struct fscrypt_master_key_secret *secret)
501{
502
503
504
505
506
507
508
509 return READ_ONCE(secret->size) != 0;
510}
511
512static inline const char *master_key_spec_type(
513 const struct fscrypt_key_specifier *spec)
514{
515 switch (spec->type) {
516 case FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR:
517 return "descriptor";
518 case FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER:
519 return "identifier";
520 }
521 return "[unknown]";
522}
523
524static inline int master_key_spec_len(const struct fscrypt_key_specifier *spec)
525{
526 switch (spec->type) {
527 case FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR:
528 return FSCRYPT_KEY_DESCRIPTOR_SIZE;
529 case FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER:
530 return FSCRYPT_KEY_IDENTIFIER_SIZE;
531 }
532 return 0;
533}
534
535struct key *
536fscrypt_find_master_key(struct super_block *sb,
537 const struct fscrypt_key_specifier *mk_spec);
538
539int fscrypt_add_test_dummy_key(struct super_block *sb,
540 struct fscrypt_key_specifier *key_spec);
541
542int fscrypt_verify_key_added(struct super_block *sb,
543 const u8 identifier[FSCRYPT_KEY_IDENTIFIER_SIZE]);
544
545int __init fscrypt_init_keyring(void);
546
547
548
549struct fscrypt_mode {
550 const char *friendly_name;
551 const char *cipher_str;
552 int keysize;
553 int ivsize;
554 int logged_impl_name;
555 enum blk_crypto_mode_num blk_crypto_mode;
556};
557
558extern struct fscrypt_mode fscrypt_modes[];
559
560int fscrypt_prepare_key(struct fscrypt_prepared_key *prep_key,
561 const u8 *raw_key, const struct fscrypt_info *ci);
562
563void fscrypt_destroy_prepared_key(struct fscrypt_prepared_key *prep_key);
564
565int fscrypt_set_per_file_enc_key(struct fscrypt_info *ci, const u8 *raw_key);
566
567int fscrypt_derive_dirhash_key(struct fscrypt_info *ci,
568 const struct fscrypt_master_key *mk);
569
570void fscrypt_hash_inode_number(struct fscrypt_info *ci,
571 const struct fscrypt_master_key *mk);
572
573int fscrypt_get_encryption_info(struct inode *inode, bool allow_unsupported);
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588static inline int fscrypt_require_key(struct inode *inode)
589{
590 if (IS_ENCRYPTED(inode)) {
591 int err = fscrypt_get_encryption_info(inode, false);
592
593 if (err)
594 return err;
595 if (!fscrypt_has_encryption_key(inode))
596 return -ENOKEY;
597 }
598 return 0;
599}
600
601
602
603void fscrypt_put_direct_key(struct fscrypt_direct_key *dk);
604
605int fscrypt_setup_v1_file_key(struct fscrypt_info *ci,
606 const u8 *raw_master_key);
607
608int fscrypt_setup_v1_file_key_via_subscribed_keyrings(struct fscrypt_info *ci);
609
610
611
612bool fscrypt_policies_equal(const union fscrypt_policy *policy1,
613 const union fscrypt_policy *policy2);
614bool fscrypt_supported_policy(const union fscrypt_policy *policy_u,
615 const struct inode *inode);
616int fscrypt_policy_from_context(union fscrypt_policy *policy_u,
617 const union fscrypt_context *ctx_u,
618 int ctx_size);
619const union fscrypt_policy *fscrypt_policy_to_inherit(struct inode *dir);
620
621#endif
622