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#define FSCRYPT_MIN_KEY_SIZE 16 24 25#define FSCRYPT_CONTEXT_V1 1 26#define FSCRYPT_CONTEXT_V2 2 27 28/* Keep this in sync with include/uapi/linux/fscrypt.h */ 29#define FSCRYPT_MODE_MAX FSCRYPT_MODE_ADIANTUM 30 31struct fscrypt_context_v1 { 32 u8 version; /* FSCRYPT_CONTEXT_V1 */ 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; /* FSCRYPT_CONTEXT_V2 */ 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 * fscrypt_context - the encryption context of an inode 52 * 53 * This is the on-disk equivalent of an fscrypt_policy, stored alongside each 54 * encrypted file usually in a hidden extended attribute. It contains the 55 * fields from the fscrypt_policy, in order to identify the encryption algorithm 56 * and key with which the file is encrypted. It also contains a nonce that was 57 * randomly generated by fscrypt itself; this is used as KDF input or as a tweak 58 * to cause different files to be encrypted differently. 59 */ 60union fscrypt_context { 61 u8 version; 62 struct fscrypt_context_v1 v1; 63 struct fscrypt_context_v2 v2; 64}; 65 66/* 67 * Return the size expected for the given fscrypt_context based on its version 68 * number, or 0 if the context version is unrecognized. 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/* Check whether an fscrypt_context has a recognized version number and size */ 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/* Retrieve the context's nonce, assuming the context was already validated */ 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 * Return the size expected for the given fscrypt_policy based on its version 111 * number, or 0 if the policy version is unrecognized. 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/* Return the contents encryption mode of a valid encryption policy */ 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/* Return the filenames encryption mode of a valid encryption policy */ 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/* Return the flags (FSCRYPT_POLICY_FLAG*) of a valid encryption policy */ 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 * For encrypted symlinks, the ciphertext length is stored at the beginning 165 * of the string in little-endian format. 166 */ 167struct fscrypt_symlink_data { 168 __le16 len; 169 char encrypted_path[1]; 170} __packed; 171 172/** 173 * struct fscrypt_prepared_key - a key prepared for actual encryption/decryption 174 * @tfm: crypto API transform object 175 * @blk_key: key for blk-crypto 176 * 177 * Normally only one of the fields will be non-NULL. 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 * fscrypt_info - the "encryption key" for an inode 188 * 189 * When an encrypted file's key is made available, an instance of this struct is 190 * allocated and stored in ->i_crypt_info. Once created, it remains until the 191 * inode is evicted. 192 */ 193struct fscrypt_info { 194 195 /* The key in a form prepared for actual encryption/decryption */ 196 struct fscrypt_prepared_key ci_enc_key; 197 198 /* True if ci_enc_key should be freed when this fscrypt_info is freed */ 199 bool ci_owns_key; 200 201#ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT 202 /* 203 * True if this inode will use inline encryption (blk-crypto) instead of 204 * the traditional filesystem-layer encryption. 205 */ 206 bool ci_inlinecrypt; 207#endif 208 209 /* 210 * Encryption mode used for this inode. It corresponds to either the 211 * contents or filenames encryption mode, depending on the inode type. 212 */ 213 struct fscrypt_mode *ci_mode; 214 215 /* Back-pointer to the inode */ 216 struct inode *ci_inode; 217 218 /* 219 * The master key with which this inode was unlocked (decrypted). This 220 * will be NULL if the master key was found in a process-subscribed 221 * keyring rather than in the filesystem-level keyring. 222 */ 223 struct fscrypt_master_key *ci_master_key; 224 225 /* 226 * Link in list of inodes that were unlocked with the master key. 227 * Only used when ->ci_master_key is set. 228 */ 229 struct list_head ci_master_key_link; 230 231 /* 232 * If non-NULL, then encryption is done using the master key directly 233 * and ci_enc_key will equal ci_direct_key->dk_key. 234 */ 235 struct fscrypt_direct_key *ci_direct_key; 236 237 /* 238 * This inode's hash key for filenames. This is a 128-bit SipHash-2-4 239 * key. This is only set for directories that use a keyed dirhash over 240 * the plaintext filenames -- currently just casefolded directories. 241 */ 242 siphash_key_t ci_dirhash_key; 243 bool ci_dirhash_key_initialized; 244 245 /* The encryption policy used by this inode */ 246 union fscrypt_policy ci_policy; 247 248 /* This inode's nonce, copied from the fscrypt_context */ 249 u8 ci_nonce[FSCRYPT_FILE_NONCE_SIZE]; 250 251 /* Hashed inode number. Only set for IV_INO_LBLK_32 */ 252 u32 ci_hashed_ino; 253}; 254 255typedef enum { 256 FS_DECRYPT = 0, 257 FS_ENCRYPT, 258} fscrypt_direction_t; 259 260/* crypto.c */ 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 /* logical block number within the file */ 282 __le64 lblk_num; 283 284 /* per-file nonce; only set in DIRECT_KEY mode */ 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/* fname.c */ 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); 300extern const struct dentry_operations fscrypt_d_ops; 301 302/* hkdf.c */ 303 304struct fscrypt_hkdf { 305 struct crypto_shash *hmac_tfm; 306}; 307 308int fscrypt_init_hkdf(struct fscrypt_hkdf *hkdf, const u8 *master_key, 309 unsigned int master_key_size); 310 311/* 312 * The list of contexts in which fscrypt uses HKDF. These values are used as 313 * the first byte of the HKDF application-specific info string to guarantee that 314 * info strings are never repeated between contexts. This ensures that all HKDF 315 * outputs are unique and cryptographically isolated, i.e. knowledge of one 316 * output doesn't reveal another. 317 */ 318#define HKDF_CONTEXT_KEY_IDENTIFIER 1 /* info=<empty> */ 319#define HKDF_CONTEXT_PER_FILE_ENC_KEY 2 /* info=file_nonce */ 320#define HKDF_CONTEXT_DIRECT_KEY 3 /* info=mode_num */ 321#define HKDF_CONTEXT_IV_INO_LBLK_64_KEY 4 /* info=mode_num||fs_uuid */ 322#define HKDF_CONTEXT_DIRHASH_KEY 5 /* info=file_nonce */ 323#define HKDF_CONTEXT_IV_INO_LBLK_32_KEY 6 /* info=mode_num||fs_uuid */ 324#define HKDF_CONTEXT_INODE_HASH_KEY 7 /* info=<empty> */ 325 326int fscrypt_hkdf_expand(const struct fscrypt_hkdf *hkdf, u8 context, 327 const u8 *info, unsigned int infolen, 328 u8 *okm, unsigned int okmlen); 329 330void fscrypt_destroy_hkdf(struct fscrypt_hkdf *hkdf); 331 332/* inline_crypt.c */ 333#ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT 334int fscrypt_select_encryption_impl(struct fscrypt_info *ci); 335 336static inline bool 337fscrypt_using_inline_encryption(const struct fscrypt_info *ci) 338{ 339 return ci->ci_inlinecrypt; 340} 341 342int fscrypt_prepare_inline_crypt_key(struct fscrypt_prepared_key *prep_key, 343 const u8 *raw_key, 344 const struct fscrypt_info *ci); 345 346void fscrypt_destroy_inline_crypt_key(struct fscrypt_prepared_key *prep_key); 347 348/* 349 * Check whether the crypto transform or blk-crypto key has been allocated in 350 * @prep_key, depending on which encryption implementation the file will use. 351 */ 352static inline bool 353fscrypt_is_key_prepared(struct fscrypt_prepared_key *prep_key, 354 const struct fscrypt_info *ci) 355{ 356 /* 357 * The two smp_load_acquire()'s here pair with the smp_store_release()'s 358 * in fscrypt_prepare_inline_crypt_key() and fscrypt_prepare_key(). 359 * I.e., in some cases (namely, if this prep_key is a per-mode 360 * encryption key) another task can publish blk_key or tfm concurrently, 361 * executing a RELEASE barrier. We need to use smp_load_acquire() here 362 * to safely ACQUIRE the memory the other task published. 363 */ 364 if (fscrypt_using_inline_encryption(ci)) 365 return smp_load_acquire(&prep_key->blk_key) != NULL; 366 return smp_load_acquire(&prep_key->tfm) != NULL; 367} 368 369#else /* CONFIG_FS_ENCRYPTION_INLINE_CRYPT */ 370 371static inline int fscrypt_select_encryption_impl(struct fscrypt_info *ci) 372{ 373 return 0; 374} 375 376static inline bool 377fscrypt_using_inline_encryption(const struct fscrypt_info *ci) 378{ 379 return false; 380} 381 382static inline int 383fscrypt_prepare_inline_crypt_key(struct fscrypt_prepared_key *prep_key, 384 const u8 *raw_key, 385 const struct fscrypt_info *ci) 386{ 387 WARN_ON(1); 388 return -EOPNOTSUPP; 389} 390 391static inline void 392fscrypt_destroy_inline_crypt_key(struct fscrypt_prepared_key *prep_key) 393{ 394} 395 396static inline bool 397fscrypt_is_key_prepared(struct fscrypt_prepared_key *prep_key, 398 const struct fscrypt_info *ci) 399{ 400 return smp_load_acquire(&prep_key->tfm) != NULL; 401} 402#endif /* !CONFIG_FS_ENCRYPTION_INLINE_CRYPT */ 403 404/* keyring.c */ 405 406/* 407 * fscrypt_master_key_secret - secret key material of an in-use master key 408 */ 409struct fscrypt_master_key_secret { 410 411 /* 412 * For v2 policy keys: HKDF context keyed by this master key. 413 * For v1 policy keys: not set (hkdf.hmac_tfm == NULL). 414 */ 415 struct fscrypt_hkdf hkdf; 416 417 /* Size of the raw key in bytes. Set even if ->raw isn't set. */ 418 u32 size; 419 420 /* For v1 policy keys: the raw key. Wiped for v2 policy keys. */ 421 u8 raw[FSCRYPT_MAX_KEY_SIZE]; 422 423} __randomize_layout; 424 425/* 426 * fscrypt_master_key - an in-use master key 427 * 428 * This represents a master encryption key which has been added to the 429 * filesystem and can be used to "unlock" the encrypted files which were 430 * encrypted with it. 431 */ 432struct fscrypt_master_key { 433 434 /* 435 * Back-pointer to the super_block of the filesystem to which this 436 * master key has been added. Only valid if ->mk_active_refs > 0. 437 */ 438 struct super_block *mk_sb; 439 440 /* 441 * Link in ->mk_sb->s_master_keys->key_hashtable. 442 * Only valid if ->mk_active_refs > 0. 443 */ 444 struct hlist_node mk_node; 445 446 /* Semaphore that protects ->mk_secret and ->mk_users */ 447 struct rw_semaphore mk_sem; 448 449 /* 450 * Active and structural reference counts. An active ref guarantees 451 * that the struct continues to exist, continues to be in the keyring 452 * ->mk_sb->s_master_keys, and that any embedded subkeys (e.g. 453 * ->mk_direct_keys) that have been prepared continue to exist. 454 * A structural ref only guarantees that the struct continues to exist. 455 * 456 * There is one active ref associated with ->mk_secret being present, 457 * and one active ref for each inode in ->mk_decrypted_inodes. 458 * 459 * There is one structural ref associated with the active refcount being 460 * nonzero. Finding a key in the keyring also takes a structural ref, 461 * which is then held temporarily while the key is operated on. 462 */ 463 refcount_t mk_active_refs; 464 refcount_t mk_struct_refs; 465 466 struct rcu_head mk_rcu_head; 467 468 /* 469 * The secret key material. After FS_IOC_REMOVE_ENCRYPTION_KEY is 470 * executed, this is wiped and no new inodes can be unlocked with this 471 * key; however, there may still be inodes in ->mk_decrypted_inodes 472 * which could not be evicted. As long as some inodes still remain, 473 * FS_IOC_REMOVE_ENCRYPTION_KEY can be retried, or 474 * FS_IOC_ADD_ENCRYPTION_KEY can add the secret again. 475 * 476 * While ->mk_secret is present, one ref in ->mk_active_refs is held. 477 * 478 * Locking: protected by ->mk_sem. The manipulation of ->mk_active_refs 479 * associated with this field is protected by ->mk_sem as well. 480 */ 481 struct fscrypt_master_key_secret mk_secret; 482 483 /* 484 * For v1 policy keys: an arbitrary key descriptor which was assigned by 485 * userspace (->descriptor). 486 * 487 * For v2 policy keys: a cryptographic hash of this key (->identifier). 488 */ 489 struct fscrypt_key_specifier mk_spec; 490 491 /* 492 * Keyring which contains a key of type 'key_type_fscrypt_user' for each 493 * user who has added this key. Normally each key will be added by just 494 * one user, but it's possible that multiple users share a key, and in 495 * that case we need to keep track of those users so that one user can't 496 * remove the key before the others want it removed too. 497 * 498 * This is NULL for v1 policy keys; those can only be added by root. 499 * 500 * Locking: protected by ->mk_sem. (We don't just rely on the keyrings 501 * subsystem semaphore ->mk_users->sem, as we need support for atomic 502 * search+insert along with proper synchronization with ->mk_secret.) 503 */ 504 struct key *mk_users; 505 506 /* 507 * List of inodes that were unlocked using this key. This allows the 508 * inodes to be evicted efficiently if the key is removed. 509 */ 510 struct list_head mk_decrypted_inodes; 511 spinlock_t mk_decrypted_inodes_lock; 512 513 /* 514 * Per-mode encryption keys for the various types of encryption policies 515 * that use them. Allocated and derived on-demand. 516 */ 517 struct fscrypt_prepared_key mk_direct_keys[FSCRYPT_MODE_MAX + 1]; 518 struct fscrypt_prepared_key mk_iv_ino_lblk_64_keys[FSCRYPT_MODE_MAX + 1]; 519 struct fscrypt_prepared_key mk_iv_ino_lblk_32_keys[FSCRYPT_MODE_MAX + 1]; 520 521 /* Hash key for inode numbers. Initialized only when needed. */ 522 siphash_key_t mk_ino_hash_key; 523 bool mk_ino_hash_key_initialized; 524 525} __randomize_layout; 526 527static inline bool 528is_master_key_secret_present(const struct fscrypt_master_key_secret *secret) 529{ 530 /* 531 * The READ_ONCE() is only necessary for fscrypt_drop_inode(). 532 * fscrypt_drop_inode() runs in atomic context, so it can't take the key 533 * semaphore and thus 'secret' can change concurrently which would be a 534 * data race. But fscrypt_drop_inode() only need to know whether the 535 * secret *was* present at the time of check, so READ_ONCE() suffices. 536 */ 537 return READ_ONCE(secret->size) != 0; 538} 539 540static inline const char *master_key_spec_type( 541 const struct fscrypt_key_specifier *spec) 542{ 543 switch (spec->type) { 544 case FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR: 545 return "descriptor"; 546 case FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER: 547 return "identifier"; 548 } 549 return "[unknown]"; 550} 551 552static inline int master_key_spec_len(const struct fscrypt_key_specifier *spec) 553{ 554 switch (spec->type) { 555 case FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR: 556 return FSCRYPT_KEY_DESCRIPTOR_SIZE; 557 case FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER: 558 return FSCRYPT_KEY_IDENTIFIER_SIZE; 559 } 560 return 0; 561} 562 563void fscrypt_put_master_key(struct fscrypt_master_key *mk); 564 565void fscrypt_put_master_key_activeref(struct fscrypt_master_key *mk); 566 567struct fscrypt_master_key * 568fscrypt_find_master_key(struct super_block *sb, 569 const struct fscrypt_key_specifier *mk_spec); 570 571int fscrypt_add_test_dummy_key(struct super_block *sb, 572 struct fscrypt_key_specifier *key_spec); 573 574int fscrypt_verify_key_added(struct super_block *sb, 575 const u8 identifier[FSCRYPT_KEY_IDENTIFIER_SIZE]); 576 577int __init fscrypt_init_keyring(void); 578 579/* keysetup.c */ 580 581struct fscrypt_mode { 582 const char *friendly_name; 583 const char *cipher_str; 584 int keysize; /* key size in bytes */ 585 int security_strength; /* security strength in bytes */ 586 int ivsize; /* IV size in bytes */ 587 int logged_impl_name; 588 enum blk_crypto_mode_num blk_crypto_mode; 589}; 590 591extern struct fscrypt_mode fscrypt_modes[]; 592 593int fscrypt_prepare_key(struct fscrypt_prepared_key *prep_key, 594 const u8 *raw_key, const struct fscrypt_info *ci); 595 596void fscrypt_destroy_prepared_key(struct fscrypt_prepared_key *prep_key); 597 598int fscrypt_set_per_file_enc_key(struct fscrypt_info *ci, const u8 *raw_key); 599 600int fscrypt_derive_dirhash_key(struct fscrypt_info *ci, 601 const struct fscrypt_master_key *mk); 602 603void fscrypt_hash_inode_number(struct fscrypt_info *ci, 604 const struct fscrypt_master_key *mk); 605 606/* keysetup_v1.c */ 607 608void fscrypt_put_direct_key(struct fscrypt_direct_key *dk); 609 610int fscrypt_setup_v1_file_key(struct fscrypt_info *ci, 611 const u8 *raw_master_key); 612 613int fscrypt_setup_v1_file_key_via_subscribed_keyrings(struct fscrypt_info *ci); 614 615/* policy.c */ 616 617bool fscrypt_policies_equal(const union fscrypt_policy *policy1, 618 const union fscrypt_policy *policy2); 619bool fscrypt_supported_policy(const union fscrypt_policy *policy_u, 620 const struct inode *inode); 621int fscrypt_policy_from_context(union fscrypt_policy *policy_u, 622 const union fscrypt_context *ctx_u, 623 int ctx_size); 624const union fscrypt_policy *fscrypt_policy_to_inherit(struct inode *dir); 625 626#endif /* _FSCRYPT_PRIVATE_H */ 627