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 <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 /* 24 * Minimum size of an fscrypt master key. Note: a longer key will be required 25 * if ciphers with a 256-bit security strength are used. This is just the 26 * absolute minimum, which applies when only 128-bit encryption is used. 27 */ 28 #define FSCRYPT_MIN_KEY_SIZE 16 29 30 #define FSCRYPT_CONTEXT_V1 1 31 #define FSCRYPT_CONTEXT_V2 2 32 33 /* Keep this in sync with include/uapi/linux/fscrypt.h */ 34 #define FSCRYPT_MODE_MAX FSCRYPT_MODE_AES_256_HCTR2 35 36 struct fscrypt_context_v1 { 37 u8 version; /* FSCRYPT_CONTEXT_V1 */ 38 u8 contents_encryption_mode; 39 u8 filenames_encryption_mode; 40 u8 flags; 41 u8 master_key_descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE]; 42 u8 nonce[FSCRYPT_FILE_NONCE_SIZE]; 43 }; 44 45 struct fscrypt_context_v2 { 46 u8 version; /* FSCRYPT_CONTEXT_V2 */ 47 u8 contents_encryption_mode; 48 u8 filenames_encryption_mode; 49 u8 flags; 50 u8 __reserved[4]; 51 u8 master_key_identifier[FSCRYPT_KEY_IDENTIFIER_SIZE]; 52 u8 nonce[FSCRYPT_FILE_NONCE_SIZE]; 53 }; 54 55 /* 56 * fscrypt_context - the encryption context of an inode 57 * 58 * This is the on-disk equivalent of an fscrypt_policy, stored alongside each 59 * encrypted file usually in a hidden extended attribute. It contains the 60 * fields from the fscrypt_policy, in order to identify the encryption algorithm 61 * and key with which the file is encrypted. It also contains a nonce that was 62 * randomly generated by fscrypt itself; this is used as KDF input or as a tweak 63 * to cause different files to be encrypted differently. 64 */ 65 union fscrypt_context { 66 u8 version; 67 struct fscrypt_context_v1 v1; 68 struct fscrypt_context_v2 v2; 69 }; 70 71 /* 72 * Return the size expected for the given fscrypt_context based on its version 73 * number, or 0 if the context version is unrecognized. 74 */ 75 static inline int fscrypt_context_size(const union fscrypt_context *ctx) 76 { 77 switch (ctx->version) { 78 case FSCRYPT_CONTEXT_V1: 79 BUILD_BUG_ON(sizeof(ctx->v1) != 28); 80 return sizeof(ctx->v1); 81 case FSCRYPT_CONTEXT_V2: 82 BUILD_BUG_ON(sizeof(ctx->v2) != 40); 83 return sizeof(ctx->v2); 84 } 85 return 0; 86 } 87 88 /* Check whether an fscrypt_context has a recognized version number and size */ 89 static inline bool fscrypt_context_is_valid(const union fscrypt_context *ctx, 90 int ctx_size) 91 { 92 return ctx_size >= 1 && ctx_size == fscrypt_context_size(ctx); 93 } 94 95 /* Retrieve the context's nonce, assuming the context was already validated */ 96 static inline const u8 *fscrypt_context_nonce(const union fscrypt_context *ctx) 97 { 98 switch (ctx->version) { 99 case FSCRYPT_CONTEXT_V1: 100 return ctx->v1.nonce; 101 case FSCRYPT_CONTEXT_V2: 102 return ctx->v2.nonce; 103 } 104 WARN_ON_ONCE(1); 105 return NULL; 106 } 107 108 union fscrypt_policy { 109 u8 version; 110 struct fscrypt_policy_v1 v1; 111 struct fscrypt_policy_v2 v2; 112 }; 113 114 /* 115 * Return the size expected for the given fscrypt_policy based on its version 116 * number, or 0 if the policy version is unrecognized. 117 */ 118 static inline int fscrypt_policy_size(const union fscrypt_policy *policy) 119 { 120 switch (policy->version) { 121 case FSCRYPT_POLICY_V1: 122 return sizeof(policy->v1); 123 case FSCRYPT_POLICY_V2: 124 return sizeof(policy->v2); 125 } 126 return 0; 127 } 128 129 /* Return the contents encryption mode of a valid encryption policy */ 130 static inline u8 131 fscrypt_policy_contents_mode(const union fscrypt_policy *policy) 132 { 133 switch (policy->version) { 134 case FSCRYPT_POLICY_V1: 135 return policy->v1.contents_encryption_mode; 136 case FSCRYPT_POLICY_V2: 137 return policy->v2.contents_encryption_mode; 138 } 139 BUG(); 140 } 141 142 /* Return the filenames encryption mode of a valid encryption policy */ 143 static inline u8 144 fscrypt_policy_fnames_mode(const union fscrypt_policy *policy) 145 { 146 switch (policy->version) { 147 case FSCRYPT_POLICY_V1: 148 return policy->v1.filenames_encryption_mode; 149 case FSCRYPT_POLICY_V2: 150 return policy->v2.filenames_encryption_mode; 151 } 152 BUG(); 153 } 154 155 /* Return the flags (FSCRYPT_POLICY_FLAG*) of a valid encryption policy */ 156 static inline u8 157 fscrypt_policy_flags(const union fscrypt_policy *policy) 158 { 159 switch (policy->version) { 160 case FSCRYPT_POLICY_V1: 161 return policy->v1.flags; 162 case FSCRYPT_POLICY_V2: 163 return policy->v2.flags; 164 } 165 BUG(); 166 } 167 168 /* 169 * For encrypted symlinks, the ciphertext length is stored at the beginning 170 * of the string in little-endian format. 171 */ 172 struct fscrypt_symlink_data { 173 __le16 len; 174 char encrypted_path[]; 175 } __packed; 176 177 /** 178 * struct fscrypt_prepared_key - a key prepared for actual encryption/decryption 179 * @tfm: crypto API transform object 180 * @blk_key: key for blk-crypto 181 * 182 * Normally only one of the fields will be non-NULL. 183 */ 184 struct fscrypt_prepared_key { 185 struct crypto_skcipher *tfm; 186 #ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT 187 struct blk_crypto_key *blk_key; 188 #endif 189 }; 190 191 /* 192 * fscrypt_info - the "encryption key" for an inode 193 * 194 * When an encrypted file's key is made available, an instance of this struct is 195 * allocated and stored in ->i_crypt_info. Once created, it remains until the 196 * inode is evicted. 197 */ 198 struct fscrypt_info { 199 200 /* The key in a form prepared for actual encryption/decryption */ 201 struct fscrypt_prepared_key ci_enc_key; 202 203 /* True if ci_enc_key should be freed when this fscrypt_info is freed */ 204 bool ci_owns_key; 205 206 #ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT 207 /* 208 * True if this inode will use inline encryption (blk-crypto) instead of 209 * the traditional filesystem-layer encryption. 210 */ 211 bool ci_inlinecrypt; 212 #endif 213 214 /* 215 * Encryption mode used for this inode. It corresponds to either the 216 * contents or filenames encryption mode, depending on the inode type. 217 */ 218 struct fscrypt_mode *ci_mode; 219 220 /* Back-pointer to the inode */ 221 struct inode *ci_inode; 222 223 /* 224 * The master key with which this inode was unlocked (decrypted). This 225 * will be NULL if the master key was found in a process-subscribed 226 * keyring rather than in the filesystem-level keyring. 227 */ 228 struct fscrypt_master_key *ci_master_key; 229 230 /* 231 * Link in list of inodes that were unlocked with the master key. 232 * Only used when ->ci_master_key is set. 233 */ 234 struct list_head ci_master_key_link; 235 236 /* 237 * If non-NULL, then encryption is done using the master key directly 238 * and ci_enc_key will equal ci_direct_key->dk_key. 239 */ 240 struct fscrypt_direct_key *ci_direct_key; 241 242 /* 243 * This inode's hash key for filenames. This is a 128-bit SipHash-2-4 244 * key. This is only set for directories that use a keyed dirhash over 245 * the plaintext filenames -- currently just casefolded directories. 246 */ 247 siphash_key_t ci_dirhash_key; 248 bool ci_dirhash_key_initialized; 249 250 /* The encryption policy used by this inode */ 251 union fscrypt_policy ci_policy; 252 253 /* This inode's nonce, copied from the fscrypt_context */ 254 u8 ci_nonce[FSCRYPT_FILE_NONCE_SIZE]; 255 256 /* Hashed inode number. Only set for IV_INO_LBLK_32 */ 257 u32 ci_hashed_ino; 258 }; 259 260 typedef enum { 261 FS_DECRYPT = 0, 262 FS_ENCRYPT, 263 } fscrypt_direction_t; 264 265 /* crypto.c */ 266 extern struct kmem_cache *fscrypt_info_cachep; 267 int fscrypt_initialize(struct super_block *sb); 268 int fscrypt_crypt_block(const struct inode *inode, fscrypt_direction_t rw, 269 u64 lblk_num, struct page *src_page, 270 struct page *dest_page, unsigned int len, 271 unsigned int offs, gfp_t gfp_flags); 272 struct page *fscrypt_alloc_bounce_page(gfp_t gfp_flags); 273 274 void __printf(3, 4) __cold 275 fscrypt_msg(const struct inode *inode, const char *level, const char *fmt, ...); 276 277 #define fscrypt_warn(inode, fmt, ...) \ 278 fscrypt_msg((inode), KERN_WARNING, fmt, ##__VA_ARGS__) 279 #define fscrypt_err(inode, fmt, ...) \ 280 fscrypt_msg((inode), KERN_ERR, fmt, ##__VA_ARGS__) 281 282 #define FSCRYPT_MAX_IV_SIZE 32 283 284 union fscrypt_iv { 285 struct { 286 /* logical block number within the file */ 287 __le64 lblk_num; 288 289 /* per-file nonce; only set in DIRECT_KEY mode */ 290 u8 nonce[FSCRYPT_FILE_NONCE_SIZE]; 291 }; 292 u8 raw[FSCRYPT_MAX_IV_SIZE]; 293 __le64 dun[FSCRYPT_MAX_IV_SIZE / sizeof(__le64)]; 294 }; 295 296 void fscrypt_generate_iv(union fscrypt_iv *iv, u64 lblk_num, 297 const struct fscrypt_info *ci); 298 299 /* 300 * Return the number of bits used by the maximum file logical block number that 301 * is possible on the given filesystem. 302 */ 303 static inline int 304 fscrypt_max_file_lblk_bits(const struct super_block *sb) 305 { 306 return fls64(sb->s_maxbytes - 1) - sb->s_blocksize_bits; 307 } 308 309 /* fname.c */ 310 bool __fscrypt_fname_encrypted_size(const union fscrypt_policy *policy, 311 u32 orig_len, u32 max_len, 312 u32 *encrypted_len_ret); 313 314 /* hkdf.c */ 315 struct fscrypt_hkdf { 316 struct crypto_shash *hmac_tfm; 317 }; 318 319 int fscrypt_init_hkdf(struct fscrypt_hkdf *hkdf, const u8 *master_key, 320 unsigned int master_key_size); 321 322 /* 323 * The list of contexts in which fscrypt uses HKDF. These values are used as 324 * the first byte of the HKDF application-specific info string to guarantee that 325 * info strings are never repeated between contexts. This ensures that all HKDF 326 * outputs are unique and cryptographically isolated, i.e. knowledge of one 327 * output doesn't reveal another. 328 */ 329 #define HKDF_CONTEXT_KEY_IDENTIFIER 1 /* info=<empty> */ 330 #define HKDF_CONTEXT_PER_FILE_ENC_KEY 2 /* info=file_nonce */ 331 #define HKDF_CONTEXT_DIRECT_KEY 3 /* info=mode_num */ 332 #define HKDF_CONTEXT_IV_INO_LBLK_64_KEY 4 /* info=mode_num||fs_uuid */ 333 #define HKDF_CONTEXT_DIRHASH_KEY 5 /* info=file_nonce */ 334 #define HKDF_CONTEXT_IV_INO_LBLK_32_KEY 6 /* info=mode_num||fs_uuid */ 335 #define HKDF_CONTEXT_INODE_HASH_KEY 7 /* info=<empty> */ 336 337 int fscrypt_hkdf_expand(const struct fscrypt_hkdf *hkdf, u8 context, 338 const u8 *info, unsigned int infolen, 339 u8 *okm, unsigned int okmlen); 340 341 void fscrypt_destroy_hkdf(struct fscrypt_hkdf *hkdf); 342 343 /* inline_crypt.c */ 344 #ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT 345 int fscrypt_select_encryption_impl(struct fscrypt_info *ci); 346 347 static inline bool 348 fscrypt_using_inline_encryption(const struct fscrypt_info *ci) 349 { 350 return ci->ci_inlinecrypt; 351 } 352 353 int fscrypt_prepare_inline_crypt_key(struct fscrypt_prepared_key *prep_key, 354 const u8 *raw_key, 355 const struct fscrypt_info *ci); 356 357 void fscrypt_destroy_inline_crypt_key(struct super_block *sb, 358 struct fscrypt_prepared_key *prep_key); 359 360 /* 361 * Check whether the crypto transform or blk-crypto key has been allocated in 362 * @prep_key, depending on which encryption implementation the file will use. 363 */ 364 static inline bool 365 fscrypt_is_key_prepared(struct fscrypt_prepared_key *prep_key, 366 const struct fscrypt_info *ci) 367 { 368 /* 369 * The two smp_load_acquire()'s here pair with the smp_store_release()'s 370 * in fscrypt_prepare_inline_crypt_key() and fscrypt_prepare_key(). 371 * I.e., in some cases (namely, if this prep_key is a per-mode 372 * encryption key) another task can publish blk_key or tfm concurrently, 373 * executing a RELEASE barrier. We need to use smp_load_acquire() here 374 * to safely ACQUIRE the memory the other task published. 375 */ 376 if (fscrypt_using_inline_encryption(ci)) 377 return smp_load_acquire(&prep_key->blk_key) != NULL; 378 return smp_load_acquire(&prep_key->tfm) != NULL; 379 } 380 381 #else /* CONFIG_FS_ENCRYPTION_INLINE_CRYPT */ 382 383 static inline int fscrypt_select_encryption_impl(struct fscrypt_info *ci) 384 { 385 return 0; 386 } 387 388 static inline bool 389 fscrypt_using_inline_encryption(const struct fscrypt_info *ci) 390 { 391 return false; 392 } 393 394 static inline int 395 fscrypt_prepare_inline_crypt_key(struct fscrypt_prepared_key *prep_key, 396 const u8 *raw_key, 397 const struct fscrypt_info *ci) 398 { 399 WARN_ON_ONCE(1); 400 return -EOPNOTSUPP; 401 } 402 403 static inline void 404 fscrypt_destroy_inline_crypt_key(struct super_block *sb, 405 struct fscrypt_prepared_key *prep_key) 406 { 407 } 408 409 static inline bool 410 fscrypt_is_key_prepared(struct fscrypt_prepared_key *prep_key, 411 const struct fscrypt_info *ci) 412 { 413 return smp_load_acquire(&prep_key->tfm) != NULL; 414 } 415 #endif /* !CONFIG_FS_ENCRYPTION_INLINE_CRYPT */ 416 417 /* keyring.c */ 418 419 /* 420 * fscrypt_master_key_secret - secret key material of an in-use master key 421 */ 422 struct fscrypt_master_key_secret { 423 424 /* 425 * For v2 policy keys: HKDF context keyed by this master key. 426 * For v1 policy keys: not set (hkdf.hmac_tfm == NULL). 427 */ 428 struct fscrypt_hkdf hkdf; 429 430 /* 431 * Size of the raw key in bytes. This remains set even if ->raw was 432 * zeroized due to no longer being needed. I.e. we still remember the 433 * size of the key even if we don't need to remember the key itself. 434 */ 435 u32 size; 436 437 /* For v1 policy keys: the raw key. Wiped for v2 policy keys. */ 438 u8 raw[FSCRYPT_MAX_KEY_SIZE]; 439 440 } __randomize_layout; 441 442 /* 443 * fscrypt_master_key - an in-use master key 444 * 445 * This represents a master encryption key which has been added to the 446 * filesystem and can be used to "unlock" the encrypted files which were 447 * encrypted with it. 448 */ 449 struct fscrypt_master_key { 450 451 /* 452 * Link in ->s_master_keys->key_hashtable. 453 * Only valid if ->mk_active_refs > 0. 454 */ 455 struct hlist_node mk_node; 456 457 /* Semaphore that protects ->mk_secret and ->mk_users */ 458 struct rw_semaphore mk_sem; 459 460 /* 461 * Active and structural reference counts. An active ref guarantees 462 * that the struct continues to exist, continues to be in the keyring 463 * ->s_master_keys, and that any embedded subkeys (e.g. 464 * ->mk_direct_keys) that have been prepared continue to exist. 465 * A structural ref only guarantees that the struct continues to exist. 466 * 467 * There is one active ref associated with ->mk_secret being present, 468 * and one active ref for each inode in ->mk_decrypted_inodes. 469 * 470 * There is one structural ref associated with the active refcount being 471 * nonzero. Finding a key in the keyring also takes a structural ref, 472 * which is then held temporarily while the key is operated on. 473 */ 474 refcount_t mk_active_refs; 475 refcount_t mk_struct_refs; 476 477 struct rcu_head mk_rcu_head; 478 479 /* 480 * The secret key material. After FS_IOC_REMOVE_ENCRYPTION_KEY is 481 * executed, this is wiped and no new inodes can be unlocked with this 482 * key; however, there may still be inodes in ->mk_decrypted_inodes 483 * which could not be evicted. As long as some inodes still remain, 484 * FS_IOC_REMOVE_ENCRYPTION_KEY can be retried, or 485 * FS_IOC_ADD_ENCRYPTION_KEY can add the secret again. 486 * 487 * While ->mk_secret is present, one ref in ->mk_active_refs is held. 488 * 489 * Locking: protected by ->mk_sem. The manipulation of ->mk_active_refs 490 * associated with this field is protected by ->mk_sem as well. 491 */ 492 struct fscrypt_master_key_secret mk_secret; 493 494 /* 495 * For v1 policy keys: an arbitrary key descriptor which was assigned by 496 * userspace (->descriptor). 497 * 498 * For v2 policy keys: a cryptographic hash of this key (->identifier). 499 */ 500 struct fscrypt_key_specifier mk_spec; 501 502 /* 503 * Keyring which contains a key of type 'key_type_fscrypt_user' for each 504 * user who has added this key. Normally each key will be added by just 505 * one user, but it's possible that multiple users share a key, and in 506 * that case we need to keep track of those users so that one user can't 507 * remove the key before the others want it removed too. 508 * 509 * This is NULL for v1 policy keys; those can only be added by root. 510 * 511 * Locking: protected by ->mk_sem. (We don't just rely on the keyrings 512 * subsystem semaphore ->mk_users->sem, as we need support for atomic 513 * search+insert along with proper synchronization with ->mk_secret.) 514 */ 515 struct key *mk_users; 516 517 /* 518 * List of inodes that were unlocked using this key. This allows the 519 * inodes to be evicted efficiently if the key is removed. 520 */ 521 struct list_head mk_decrypted_inodes; 522 spinlock_t mk_decrypted_inodes_lock; 523 524 /* 525 * Per-mode encryption keys for the various types of encryption policies 526 * that use them. Allocated and derived on-demand. 527 */ 528 struct fscrypt_prepared_key mk_direct_keys[FSCRYPT_MODE_MAX + 1]; 529 struct fscrypt_prepared_key mk_iv_ino_lblk_64_keys[FSCRYPT_MODE_MAX + 1]; 530 struct fscrypt_prepared_key mk_iv_ino_lblk_32_keys[FSCRYPT_MODE_MAX + 1]; 531 532 /* Hash key for inode numbers. Initialized only when needed. */ 533 siphash_key_t mk_ino_hash_key; 534 bool mk_ino_hash_key_initialized; 535 536 } __randomize_layout; 537 538 static inline bool 539 is_master_key_secret_present(const struct fscrypt_master_key_secret *secret) 540 { 541 /* 542 * The READ_ONCE() is only necessary for fscrypt_drop_inode(). 543 * fscrypt_drop_inode() runs in atomic context, so it can't take the key 544 * semaphore and thus 'secret' can change concurrently which would be a 545 * data race. But fscrypt_drop_inode() only need to know whether the 546 * secret *was* present at the time of check, so READ_ONCE() suffices. 547 */ 548 return READ_ONCE(secret->size) != 0; 549 } 550 551 static inline const char *master_key_spec_type( 552 const struct fscrypt_key_specifier *spec) 553 { 554 switch (spec->type) { 555 case FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR: 556 return "descriptor"; 557 case FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER: 558 return "identifier"; 559 } 560 return "[unknown]"; 561 } 562 563 static inline int master_key_spec_len(const struct fscrypt_key_specifier *spec) 564 { 565 switch (spec->type) { 566 case FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR: 567 return FSCRYPT_KEY_DESCRIPTOR_SIZE; 568 case FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER: 569 return FSCRYPT_KEY_IDENTIFIER_SIZE; 570 } 571 return 0; 572 } 573 574 void fscrypt_put_master_key(struct fscrypt_master_key *mk); 575 576 void fscrypt_put_master_key_activeref(struct super_block *sb, 577 struct fscrypt_master_key *mk); 578 579 struct fscrypt_master_key * 580 fscrypt_find_master_key(struct super_block *sb, 581 const struct fscrypt_key_specifier *mk_spec); 582 583 int fscrypt_get_test_dummy_key_identifier( 584 u8 key_identifier[FSCRYPT_KEY_IDENTIFIER_SIZE]); 585 586 int fscrypt_add_test_dummy_key(struct super_block *sb, 587 struct fscrypt_key_specifier *key_spec); 588 589 int fscrypt_verify_key_added(struct super_block *sb, 590 const u8 identifier[FSCRYPT_KEY_IDENTIFIER_SIZE]); 591 592 int __init fscrypt_init_keyring(void); 593 594 /* keysetup.c */ 595 596 struct fscrypt_mode { 597 const char *friendly_name; 598 const char *cipher_str; 599 int keysize; /* key size in bytes */ 600 int security_strength; /* security strength in bytes */ 601 int ivsize; /* IV size in bytes */ 602 int logged_cryptoapi_impl; 603 int logged_blk_crypto_native; 604 int logged_blk_crypto_fallback; 605 enum blk_crypto_mode_num blk_crypto_mode; 606 }; 607 608 extern struct fscrypt_mode fscrypt_modes[]; 609 610 int fscrypt_prepare_key(struct fscrypt_prepared_key *prep_key, 611 const u8 *raw_key, const struct fscrypt_info *ci); 612 613 void fscrypt_destroy_prepared_key(struct super_block *sb, 614 struct fscrypt_prepared_key *prep_key); 615 616 int fscrypt_set_per_file_enc_key(struct fscrypt_info *ci, const u8 *raw_key); 617 618 int fscrypt_derive_dirhash_key(struct fscrypt_info *ci, 619 const struct fscrypt_master_key *mk); 620 621 void fscrypt_hash_inode_number(struct fscrypt_info *ci, 622 const struct fscrypt_master_key *mk); 623 624 int fscrypt_get_encryption_info(struct inode *inode, bool allow_unsupported); 625 626 /** 627 * fscrypt_require_key() - require an inode's encryption key 628 * @inode: the inode we need the key for 629 * 630 * If the inode is encrypted, set up its encryption key if not already done. 631 * Then require that the key be present and return -ENOKEY otherwise. 632 * 633 * No locks are needed, and the key will live as long as the struct inode --- so 634 * it won't go away from under you. 635 * 636 * Return: 0 on success, -ENOKEY if the key is missing, or another -errno code 637 * if a problem occurred while setting up the encryption key. 638 */ 639 static inline int fscrypt_require_key(struct inode *inode) 640 { 641 if (IS_ENCRYPTED(inode)) { 642 int err = fscrypt_get_encryption_info(inode, false); 643 644 if (err) 645 return err; 646 if (!fscrypt_has_encryption_key(inode)) 647 return -ENOKEY; 648 } 649 return 0; 650 } 651 652 /* keysetup_v1.c */ 653 654 void fscrypt_put_direct_key(struct fscrypt_direct_key *dk); 655 656 int fscrypt_setup_v1_file_key(struct fscrypt_info *ci, 657 const u8 *raw_master_key); 658 659 int fscrypt_setup_v1_file_key_via_subscribed_keyrings(struct fscrypt_info *ci); 660 661 /* policy.c */ 662 663 bool fscrypt_policies_equal(const union fscrypt_policy *policy1, 664 const union fscrypt_policy *policy2); 665 int fscrypt_policy_to_key_spec(const union fscrypt_policy *policy, 666 struct fscrypt_key_specifier *key_spec); 667 const union fscrypt_policy *fscrypt_get_dummy_policy(struct super_block *sb); 668 bool fscrypt_supported_policy(const union fscrypt_policy *policy_u, 669 const struct inode *inode); 670 int fscrypt_policy_from_context(union fscrypt_policy *policy_u, 671 const union fscrypt_context *ctx_u, 672 int ctx_size); 673 const union fscrypt_policy *fscrypt_policy_to_inherit(struct inode *dir); 674 675 #endif /* _FSCRYPT_PRIVATE_H */ 676