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 36struct 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 45struct 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 */ 65union 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 */ 75static 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 */ 89static 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 */ 96static 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 108union 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 */ 118static 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 */ 130static inline u8 131fscrypt_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 */ 143static inline u8 144fscrypt_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 */ 156static inline u8 157fscrypt_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 */ 172struct 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 */ 184struct 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 */ 198struct 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 260typedef enum { 261 FS_DECRYPT = 0, 262 FS_ENCRYPT, 263} fscrypt_direction_t; 264 265/* crypto.c */ 266extern struct kmem_cache *fscrypt_info_cachep; 267int fscrypt_initialize(struct super_block *sb); 268int 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); 272struct page *fscrypt_alloc_bounce_page(gfp_t gfp_flags); 273 274void __printf(3, 4) __cold 275fscrypt_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 284union 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 296void fscrypt_generate_iv(union fscrypt_iv *iv, u64 lblk_num, 297 const struct fscrypt_info *ci); 298 299/* fname.c */ 300bool __fscrypt_fname_encrypted_size(const union fscrypt_policy *policy, 301 u32 orig_len, u32 max_len, 302 u32 *encrypted_len_ret); 303 304/* hkdf.c */ 305struct fscrypt_hkdf { 306 struct crypto_shash *hmac_tfm; 307}; 308 309int fscrypt_init_hkdf(struct fscrypt_hkdf *hkdf, const u8 *master_key, 310 unsigned int master_key_size); 311 312/* 313 * The list of contexts in which fscrypt uses HKDF. These values are used as 314 * the first byte of the HKDF application-specific info string to guarantee that 315 * info strings are never repeated between contexts. This ensures that all HKDF 316 * outputs are unique and cryptographically isolated, i.e. knowledge of one 317 * output doesn't reveal another. 318 */ 319#define HKDF_CONTEXT_KEY_IDENTIFIER 1 /* info=<empty> */ 320#define HKDF_CONTEXT_PER_FILE_ENC_KEY 2 /* info=file_nonce */ 321#define HKDF_CONTEXT_DIRECT_KEY 3 /* info=mode_num */ 322#define HKDF_CONTEXT_IV_INO_LBLK_64_KEY 4 /* info=mode_num||fs_uuid */ 323#define HKDF_CONTEXT_DIRHASH_KEY 5 /* info=file_nonce */ 324#define HKDF_CONTEXT_IV_INO_LBLK_32_KEY 6 /* info=mode_num||fs_uuid */ 325#define HKDF_CONTEXT_INODE_HASH_KEY 7 /* info=<empty> */ 326 327int fscrypt_hkdf_expand(const struct fscrypt_hkdf *hkdf, u8 context, 328 const u8 *info, unsigned int infolen, 329 u8 *okm, unsigned int okmlen); 330 331void fscrypt_destroy_hkdf(struct fscrypt_hkdf *hkdf); 332 333/* inline_crypt.c */ 334#ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT 335int fscrypt_select_encryption_impl(struct fscrypt_info *ci); 336 337static inline bool 338fscrypt_using_inline_encryption(const struct fscrypt_info *ci) 339{ 340 return ci->ci_inlinecrypt; 341} 342 343int fscrypt_prepare_inline_crypt_key(struct fscrypt_prepared_key *prep_key, 344 const u8 *raw_key, 345 const struct fscrypt_info *ci); 346 347void fscrypt_destroy_inline_crypt_key(struct super_block *sb, 348 struct fscrypt_prepared_key *prep_key); 349 350/* 351 * Check whether the crypto transform or blk-crypto key has been allocated in 352 * @prep_key, depending on which encryption implementation the file will use. 353 */ 354static inline bool 355fscrypt_is_key_prepared(struct fscrypt_prepared_key *prep_key, 356 const struct fscrypt_info *ci) 357{ 358 /* 359 * The two smp_load_acquire()'s here pair with the smp_store_release()'s 360 * in fscrypt_prepare_inline_crypt_key() and fscrypt_prepare_key(). 361 * I.e., in some cases (namely, if this prep_key is a per-mode 362 * encryption key) another task can publish blk_key or tfm concurrently, 363 * executing a RELEASE barrier. We need to use smp_load_acquire() here 364 * to safely ACQUIRE the memory the other task published. 365 */ 366 if (fscrypt_using_inline_encryption(ci)) 367 return smp_load_acquire(&prep_key->blk_key) != NULL; 368 return smp_load_acquire(&prep_key->tfm) != NULL; 369} 370 371#else /* CONFIG_FS_ENCRYPTION_INLINE_CRYPT */ 372 373static inline int fscrypt_select_encryption_impl(struct fscrypt_info *ci) 374{ 375 return 0; 376} 377 378static inline bool 379fscrypt_using_inline_encryption(const struct fscrypt_info *ci) 380{ 381 return false; 382} 383 384static inline int 385fscrypt_prepare_inline_crypt_key(struct fscrypt_prepared_key *prep_key, 386 const u8 *raw_key, 387 const struct fscrypt_info *ci) 388{ 389 WARN_ON_ONCE(1); 390 return -EOPNOTSUPP; 391} 392 393static inline void 394fscrypt_destroy_inline_crypt_key(struct super_block *sb, 395 struct fscrypt_prepared_key *prep_key) 396{ 397} 398 399static inline bool 400fscrypt_is_key_prepared(struct fscrypt_prepared_key *prep_key, 401 const struct fscrypt_info *ci) 402{ 403 return smp_load_acquire(&prep_key->tfm) != NULL; 404} 405#endif /* !CONFIG_FS_ENCRYPTION_INLINE_CRYPT */ 406 407/* keyring.c */ 408 409/* 410 * fscrypt_master_key_secret - secret key material of an in-use master key 411 */ 412struct fscrypt_master_key_secret { 413 414 /* 415 * For v2 policy keys: HKDF context keyed by this master key. 416 * For v1 policy keys: not set (hkdf.hmac_tfm == NULL). 417 */ 418 struct fscrypt_hkdf hkdf; 419 420 /* 421 * Size of the raw key in bytes. This remains set even if ->raw was 422 * zeroized due to no longer being needed. I.e. we still remember the 423 * size of the key even if we don't need to remember the key itself. 424 */ 425 u32 size; 426 427 /* For v1 policy keys: the raw key. Wiped for v2 policy keys. */ 428 u8 raw[FSCRYPT_MAX_KEY_SIZE]; 429 430} __randomize_layout; 431 432/* 433 * fscrypt_master_key - an in-use master key 434 * 435 * This represents a master encryption key which has been added to the 436 * filesystem and can be used to "unlock" the encrypted files which were 437 * encrypted with it. 438 */ 439struct fscrypt_master_key { 440 441 /* 442 * Link in ->s_master_keys->key_hashtable. 443 * Only valid if ->mk_active_refs > 0. 444 */ 445 struct hlist_node mk_node; 446 447 /* Semaphore that protects ->mk_secret and ->mk_users */ 448 struct rw_semaphore mk_sem; 449 450 /* 451 * Active and structural reference counts. An active ref guarantees 452 * that the struct continues to exist, continues to be in the keyring 453 * ->s_master_keys, and that any embedded subkeys (e.g. 454 * ->mk_direct_keys) that have been prepared continue to exist. 455 * A structural ref only guarantees that the struct continues to exist. 456 * 457 * There is one active ref associated with ->mk_secret being present, 458 * and one active ref for each inode in ->mk_decrypted_inodes. 459 * 460 * There is one structural ref associated with the active refcount being 461 * nonzero. Finding a key in the keyring also takes a structural ref, 462 * which is then held temporarily while the key is operated on. 463 */ 464 refcount_t mk_active_refs; 465 refcount_t mk_struct_refs; 466 467 struct rcu_head mk_rcu_head; 468 469 /* 470 * The secret key material. After FS_IOC_REMOVE_ENCRYPTION_KEY is 471 * executed, this is wiped and no new inodes can be unlocked with this 472 * key; however, there may still be inodes in ->mk_decrypted_inodes 473 * which could not be evicted. As long as some inodes still remain, 474 * FS_IOC_REMOVE_ENCRYPTION_KEY can be retried, or 475 * FS_IOC_ADD_ENCRYPTION_KEY can add the secret again. 476 * 477 * While ->mk_secret is present, one ref in ->mk_active_refs is held. 478 * 479 * Locking: protected by ->mk_sem. The manipulation of ->mk_active_refs 480 * associated with this field is protected by ->mk_sem as well. 481 */ 482 struct fscrypt_master_key_secret mk_secret; 483 484 /* 485 * For v1 policy keys: an arbitrary key descriptor which was assigned by 486 * userspace (->descriptor). 487 * 488 * For v2 policy keys: a cryptographic hash of this key (->identifier). 489 */ 490 struct fscrypt_key_specifier mk_spec; 491 492 /* 493 * Keyring which contains a key of type 'key_type_fscrypt_user' for each 494 * user who has added this key. Normally each key will be added by just 495 * one user, but it's possible that multiple users share a key, and in 496 * that case we need to keep track of those users so that one user can't 497 * remove the key before the others want it removed too. 498 * 499 * This is NULL for v1 policy keys; those can only be added by root. 500 * 501 * Locking: protected by ->mk_sem. (We don't just rely on the keyrings 502 * subsystem semaphore ->mk_users->sem, as we need support for atomic 503 * search+insert along with proper synchronization with ->mk_secret.) 504 */ 505 struct key *mk_users; 506 507 /* 508 * List of inodes that were unlocked using this key. This allows the 509 * inodes to be evicted efficiently if the key is removed. 510 */ 511 struct list_head mk_decrypted_inodes; 512 spinlock_t mk_decrypted_inodes_lock; 513 514 /* 515 * Per-mode encryption keys for the various types of encryption policies 516 * that use them. Allocated and derived on-demand. 517 */ 518 struct fscrypt_prepared_key mk_direct_keys[FSCRYPT_MODE_MAX + 1]; 519 struct fscrypt_prepared_key mk_iv_ino_lblk_64_keys[FSCRYPT_MODE_MAX + 1]; 520 struct fscrypt_prepared_key mk_iv_ino_lblk_32_keys[FSCRYPT_MODE_MAX + 1]; 521 522 /* Hash key for inode numbers. Initialized only when needed. */ 523 siphash_key_t mk_ino_hash_key; 524 bool mk_ino_hash_key_initialized; 525 526} __randomize_layout; 527 528static inline bool 529is_master_key_secret_present(const struct fscrypt_master_key_secret *secret) 530{ 531 /* 532 * The READ_ONCE() is only necessary for fscrypt_drop_inode(). 533 * fscrypt_drop_inode() runs in atomic context, so it can't take the key 534 * semaphore and thus 'secret' can change concurrently which would be a 535 * data race. But fscrypt_drop_inode() only need to know whether the 536 * secret *was* present at the time of check, so READ_ONCE() suffices. 537 */ 538 return READ_ONCE(secret->size) != 0; 539} 540 541static inline const char *master_key_spec_type( 542 const struct fscrypt_key_specifier *spec) 543{ 544 switch (spec->type) { 545 case FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR: 546 return "descriptor"; 547 case FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER: 548 return "identifier"; 549 } 550 return "[unknown]"; 551} 552 553static inline int master_key_spec_len(const struct fscrypt_key_specifier *spec) 554{ 555 switch (spec->type) { 556 case FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR: 557 return FSCRYPT_KEY_DESCRIPTOR_SIZE; 558 case FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER: 559 return FSCRYPT_KEY_IDENTIFIER_SIZE; 560 } 561 return 0; 562} 563 564void fscrypt_put_master_key(struct fscrypt_master_key *mk); 565 566void fscrypt_put_master_key_activeref(struct super_block *sb, 567 struct fscrypt_master_key *mk); 568 569struct fscrypt_master_key * 570fscrypt_find_master_key(struct super_block *sb, 571 const struct fscrypt_key_specifier *mk_spec); 572 573int fscrypt_get_test_dummy_key_identifier( 574 u8 key_identifier[FSCRYPT_KEY_IDENTIFIER_SIZE]); 575 576int fscrypt_add_test_dummy_key(struct super_block *sb, 577 struct fscrypt_key_specifier *key_spec); 578 579int fscrypt_verify_key_added(struct super_block *sb, 580 const u8 identifier[FSCRYPT_KEY_IDENTIFIER_SIZE]); 581 582int __init fscrypt_init_keyring(void); 583 584/* keysetup.c */ 585 586struct fscrypt_mode { 587 const char *friendly_name; 588 const char *cipher_str; 589 int keysize; /* key size in bytes */ 590 int security_strength; /* security strength in bytes */ 591 int ivsize; /* IV size in bytes */ 592 int logged_cryptoapi_impl; 593 int logged_blk_crypto_native; 594 int logged_blk_crypto_fallback; 595 enum blk_crypto_mode_num blk_crypto_mode; 596}; 597 598extern struct fscrypt_mode fscrypt_modes[]; 599 600int fscrypt_prepare_key(struct fscrypt_prepared_key *prep_key, 601 const u8 *raw_key, const struct fscrypt_info *ci); 602 603void fscrypt_destroy_prepared_key(struct super_block *sb, 604 struct fscrypt_prepared_key *prep_key); 605 606int fscrypt_set_per_file_enc_key(struct fscrypt_info *ci, const u8 *raw_key); 607 608int fscrypt_derive_dirhash_key(struct fscrypt_info *ci, 609 const struct fscrypt_master_key *mk); 610 611void fscrypt_hash_inode_number(struct fscrypt_info *ci, 612 const struct fscrypt_master_key *mk); 613 614int fscrypt_get_encryption_info(struct inode *inode, bool allow_unsupported); 615 616/** 617 * fscrypt_require_key() - require an inode's encryption key 618 * @inode: the inode we need the key for 619 * 620 * If the inode is encrypted, set up its encryption key if not already done. 621 * Then require that the key be present and return -ENOKEY otherwise. 622 * 623 * No locks are needed, and the key will live as long as the struct inode --- so 624 * it won't go away from under you. 625 * 626 * Return: 0 on success, -ENOKEY if the key is missing, or another -errno code 627 * if a problem occurred while setting up the encryption key. 628 */ 629static inline int fscrypt_require_key(struct inode *inode) 630{ 631 if (IS_ENCRYPTED(inode)) { 632 int err = fscrypt_get_encryption_info(inode, false); 633 634 if (err) 635 return err; 636 if (!fscrypt_has_encryption_key(inode)) 637 return -ENOKEY; 638 } 639 return 0; 640} 641 642/* keysetup_v1.c */ 643 644void fscrypt_put_direct_key(struct fscrypt_direct_key *dk); 645 646int fscrypt_setup_v1_file_key(struct fscrypt_info *ci, 647 const u8 *raw_master_key); 648 649int fscrypt_setup_v1_file_key_via_subscribed_keyrings(struct fscrypt_info *ci); 650 651/* policy.c */ 652 653bool fscrypt_policies_equal(const union fscrypt_policy *policy1, 654 const union fscrypt_policy *policy2); 655int fscrypt_policy_to_key_spec(const union fscrypt_policy *policy, 656 struct fscrypt_key_specifier *key_spec); 657const union fscrypt_policy *fscrypt_get_dummy_policy(struct super_block *sb); 658bool fscrypt_supported_policy(const union fscrypt_policy *policy_u, 659 const struct inode *inode); 660int fscrypt_policy_from_context(union fscrypt_policy *policy_u, 661 const union fscrypt_context *ctx_u, 662 int ctx_size); 663const union fscrypt_policy *fscrypt_policy_to_inherit(struct inode *dir); 664 665#endif /* _FSCRYPT_PRIVATE_H */ 666