In order to have a common code base for fscrypt "post read" processing for all filesystems which support encryption, this commit removes filesystem specific build config option (e.g. CONFIG_EXT4_FS_ENCRYPTION) and replaces it with a build option (i.e. CONFIG_FS_ENCRYPTION) whose value affects all the filesystems making use of fscrypt.
Showing the changes to include/linux (4 of 31 files). Show all
Unified · Split
| @@ -698,7 +698,7 @@ struct inode { · 697 unmodified lines | ||
| 698 | 698 | struct fsnotify_mark_connector __rcu *i_fsnotify_marks; |
| 699 | 699 | #endif |
| 700 | 700 | |
| 701 | −#if IS_ENABLED(CONFIG_FS_ENCRYPTION) | |
| 701 | +#ifdef CONFIG_FS_ENCRYPTION | |
| 702 | 702 | struct fscrypt_info *i_crypt_info; |
| 703 | 703 | #endif |
| 704 | 704 | |
| @@ -1403,7 +1403,7 @@ struct super_block { · 698 unmodified lines | ||
| 1403 | 1403 | void *s_security; |
| 1404 | 1404 | #endif |
| 1405 | 1405 | const struct xattr_handler **s_xattr; |
| 1406 | −#if IS_ENABLED(CONFIG_FS_ENCRYPTION) | |
| 1406 | +#ifdef CONFIG_FS_ENCRYPTION | |
| 1407 | 1407 | const struct fscrypt_operations *s_cop; |
| 1408 | 1408 | #endif |
| 1409 | 1409 | struct hlist_bl_head s_roots; /* alternate root dentries for NFS */ |
| @@ -2,9 +2,8 @@ · 1 unmodified line | ||
| 2 | 2 | /* |
| 3 | 3 | * fscrypt.h: declarations for per-file encryption |
| 4 | 4 | * |
| 5 | − * Filesystems that implement per-file encryption include this header | |
| 6 | − * file with the __FS_HAS_ENCRYPTION set according to whether that filesystem | |
| 7 | − * is being built with encryption support or not. | |
| 5 | + * Filesystems that implement per-file encryption must include this header | |
| 6 | + * file. | |
| 8 | 7 | * |
| 9 | 8 | * Copyright (C) 2015, Google, Inc. |
| 10 | 9 | * |
| @@ -15,6 +14,8 @@ · 4 unmodified lines | ||
| 15 | 14 | #define _LINUX_FSCRYPT_H |
| 16 | 15 | |
| 17 | 16 | #include <linux/fs.h> |
| 17 | +#include <linux/mm.h> | |
| 18 | +#include <linux/slab.h> | |
| 18 | 19 | |
| 19 | 20 | #define FS_CRYPTO_BLOCK_SIZE 16 |
| 20 | 21 | |
| @@ -42,11 +43,410 @@ struct fscrypt_name { · 21 unmodified lines | ||
| 42 | 43 | /* Maximum value for the third parameter of fscrypt_operations.set_context(). */ |
| 43 | 44 | #define FSCRYPT_SET_CONTEXT_MAX_SIZE 28 |
| 44 | 45 | |
| 45 | −#if __FS_HAS_ENCRYPTION | |
| 46 | −#include <linux/fscrypt_supp.h> | |
| 47 | −#else | |
| 48 | −#include <linux/fscrypt_notsupp.h> | |
| 49 | −#endif | |
| 46 | +#ifdef CONFIG_FS_ENCRYPTION | |
| 47 | +/* | |
| 48 | + * fscrypt superblock flags | |
| 49 | + */ | |
| 50 | +#define FS_CFLG_OWN_PAGES (1U << 1) | |
| 51 | + | |
| 52 | +/* | |
| 53 | + * crypto operations for filesystems | |
| 54 | + */ | |
| 55 | +struct fscrypt_operations { | |
| 56 | + unsigned int flags; | |
| 57 | + const char *key_prefix; | |
| 58 | + int (*get_context)(struct inode *, void *, size_t); | |
| 59 | + int (*set_context)(struct inode *, const void *, size_t, void *); | |
| 60 | + bool (*dummy_context)(struct inode *); | |
| 61 | + bool (*empty_dir)(struct inode *); | |
| 62 | + unsigned int max_namelen; | |
| 63 | +}; | |
| 64 | + | |
| 65 | +struct fscrypt_ctx { | |
| 66 | + union { | |
| 67 | + struct { | |
| 68 | + struct page *bounce_page; /* Ciphertext page */ | |
| 69 | + struct page *control_page; /* Original page */ | |
| 70 | + } w; | |
| 71 | + struct { | |
| 72 | + struct bio *bio; | |
| 73 | + struct work_struct work; | |
| 74 | + } r; | |
| 75 | + struct list_head free_list; /* Free list */ | |
| 76 | + }; | |
| 77 | + u8 flags; /* Flags */ | |
| 78 | +}; | |
| 79 | + | |
| 80 | +static inline bool fscrypt_has_encryption_key(const struct inode *inode) | |
| 81 | +{ | |
| 82 | + return (inode->i_crypt_info != NULL); | |
| 83 | +} | |
| 84 | + | |
| 85 | +static inline bool fscrypt_dummy_context_enabled(struct inode *inode) | |
| 86 | +{ | |
| 87 | + return inode->i_sb->s_cop->dummy_context && | |
| 88 | + inode->i_sb->s_cop->dummy_context(inode); | |
| 89 | +} | |
| 90 | + | |
| 91 | +/* crypto.c */ | |
| 92 | +extern void fscrypt_enqueue_decrypt_work(struct work_struct *); | |
| 93 | +extern struct fscrypt_ctx *fscrypt_get_ctx(const struct inode *, gfp_t); | |
| 94 | +extern void fscrypt_release_ctx(struct fscrypt_ctx *); | |
| 95 | +extern struct page *fscrypt_encrypt_page(const struct inode *, struct page *, | |
| 96 | + unsigned int, unsigned int, | |
| 97 | + u64, gfp_t); | |
| 98 | +extern int fscrypt_decrypt_page(const struct inode *, struct page *, unsigned int, | |
| 99 | + unsigned int, u64); | |
| 100 | + | |
| 101 | +static inline struct page *fscrypt_control_page(struct page *page) | |
| 102 | +{ | |
| 103 | + return ((struct fscrypt_ctx *)page_private(page))->w.control_page; | |
| 104 | +} | |
| 105 | + | |
| 106 | +extern void fscrypt_restore_control_page(struct page *); | |
| 107 | + | |
| 108 | +/* policy.c */ | |
| 109 | +extern int fscrypt_ioctl_set_policy(struct file *, const void __user *); | |
| 110 | +extern int fscrypt_ioctl_get_policy(struct file *, void __user *); | |
| 111 | +extern int fscrypt_has_permitted_context(struct inode *, struct inode *); | |
| 112 | +extern int fscrypt_inherit_context(struct inode *, struct inode *, | |
| 113 | + void *, bool); | |
| 114 | +/* keyinfo.c */ | |
| 115 | +extern int fscrypt_get_encryption_info(struct inode *); | |
| 116 | +extern void fscrypt_put_encryption_info(struct inode *); | |
| 117 | + | |
| 118 | +/* fname.c */ | |
| 119 | +extern int fscrypt_setup_filename(struct inode *, const struct qstr *, | |
| 120 | + int lookup, struct fscrypt_name *); | |
| 121 | + | |
| 122 | +static inline void fscrypt_free_filename(struct fscrypt_name *fname) | |
| 123 | +{ | |
| 124 | + kfree(fname->crypto_buf.name); | |
| 125 | +} | |
| 126 | + | |
| 127 | +extern int fscrypt_fname_alloc_buffer(const struct inode *, u32, | |
| 128 | + struct fscrypt_str *); | |
| 129 | +extern void fscrypt_fname_free_buffer(struct fscrypt_str *); | |
| 130 | +extern int fscrypt_fname_disk_to_usr(struct inode *, u32, u32, | |
| 131 | + const struct fscrypt_str *, struct fscrypt_str *); | |
| 132 | + | |
| 133 | +#define FSCRYPT_FNAME_MAX_UNDIGESTED_SIZE 32 | |
| 134 | + | |
| 135 | +/* Extracts the second-to-last ciphertext block; see explanation below */ | |
| 136 | +#define FSCRYPT_FNAME_DIGEST(name, len) \ | |
| 137 | + ((name) + round_down((len) - FS_CRYPTO_BLOCK_SIZE - 1, \ | |
| 138 | + FS_CRYPTO_BLOCK_SIZE)) | |
| 139 | + | |
| 140 | +#define FSCRYPT_FNAME_DIGEST_SIZE FS_CRYPTO_BLOCK_SIZE | |
| 141 | + | |
| 142 | +/** | |
| 143 | + * fscrypt_digested_name - alternate identifier for an on-disk filename | |
| 144 | + * | |
| 145 | + * When userspace lists an encrypted directory without access to the key, | |
| 146 | + * filenames whose ciphertext is longer than FSCRYPT_FNAME_MAX_UNDIGESTED_SIZE | |
| 147 | + * bytes are shown in this abbreviated form (base64-encoded) rather than as the | |
| 148 | + * full ciphertext (base64-encoded). This is necessary to allow supporting | |
| 149 | + * filenames up to NAME_MAX bytes, since base64 encoding expands the length. | |
| 150 | + * | |
| 151 | + * To make it possible for filesystems to still find the correct directory entry | |
| 152 | + * despite not knowing the full on-disk name, we encode any filesystem-specific | |
| 153 | + * 'hash' and/or 'minor_hash' which the filesystem may need for its lookups, | |
| 154 | + * followed by the second-to-last ciphertext block of the filename. Due to the | |
| 155 | + * use of the CBC-CTS encryption mode, the second-to-last ciphertext block | |
| 156 | + * depends on the full plaintext. (Note that ciphertext stealing causes the | |
| 157 | + * last two blocks to appear "flipped".) This makes accidental collisions very | |
| 158 | + * unlikely: just a 1 in 2^128 chance for two filenames to collide even if they | |
| 159 | + * share the same filesystem-specific hashes. | |
| 160 | + * | |
| 161 | + * However, this scheme isn't immune to intentional collisions, which can be | |
| 162 | + * created by anyone able to create arbitrary plaintext filenames and view them | |
| 163 | + * without the key. Making the "digest" be a real cryptographic hash like | |
| 164 | + * SHA-256 over the full ciphertext would prevent this, although it would be | |
| 165 | + * less efficient and harder to implement, especially since the filesystem would | |
| 166 | + * need to calculate it for each directory entry examined during a search. | |
| 167 | + */ | |
| 168 | +struct fscrypt_digested_name { | |
| 169 | + u32 hash; | |
| 170 | + u32 minor_hash; | |
| 171 | + u8 digest[FSCRYPT_FNAME_DIGEST_SIZE]; | |
| 172 | +}; | |
| 173 | + | |
| 174 | +/** | |
| 175 | + * fscrypt_match_name() - test whether the given name matches a directory entry | |
| 176 | + * @fname: the name being searched for | |
| 177 | + * @de_name: the name from the directory entry | |
| 178 | + * @de_name_len: the length of @de_name in bytes | |
| 179 | + * | |
| 180 | + * Normally @fname->disk_name will be set, and in that case we simply compare | |
| 181 | + * that to the name stored in the directory entry. The only exception is that | |
| 182 | + * if we don't have the key for an encrypted directory and a filename in it is | |
| 183 | + * very long, then we won't have the full disk_name and we'll instead need to | |
| 184 | + * match against the fscrypt_digested_name. | |
| 185 | + * | |
| 186 | + * Return: %true if the name matches, otherwise %false. | |
| 187 | + */ | |
| 188 | +static inline bool fscrypt_match_name(const struct fscrypt_name *fname, | |
| 189 | + const u8 *de_name, u32 de_name_len) | |
| 190 | +{ | |
| 191 | + if (unlikely(!fname->disk_name.name)) { | |
| 192 | + const struct fscrypt_digested_name *n = | |
| 193 | + (const void *)fname->crypto_buf.name; | |
| 194 | + if (WARN_ON_ONCE(fname->usr_fname->name[0] != '_')) | |
| 195 | + return false; | |
| 196 | + if (de_name_len <= FSCRYPT_FNAME_MAX_UNDIGESTED_SIZE) | |
| 197 | + return false; | |
| 198 | + return !memcmp(FSCRYPT_FNAME_DIGEST(de_name, de_name_len), | |
| 199 | + n->digest, FSCRYPT_FNAME_DIGEST_SIZE); | |
| 200 | + } | |
| 201 | + | |
| 202 | + if (de_name_len != fname->disk_name.len) | |
| 203 | + return false; | |
| 204 | + return !memcmp(de_name, fname->disk_name.name, fname->disk_name.len); | |
| 205 | +} | |
| 206 | + | |
| 207 | +/* bio.c */ | |
| 208 | +extern void fscrypt_decrypt_bio(struct bio *); | |
| 209 | +extern void fscrypt_enqueue_decrypt_bio(struct fscrypt_ctx *ctx, | |
| 210 | + struct bio *bio); | |
| 211 | +extern void fscrypt_pullback_bio_page(struct page **, bool); | |
| 212 | +extern int fscrypt_zeroout_range(const struct inode *, pgoff_t, sector_t, | |
| 213 | + unsigned int); | |
| 214 | + | |
| 215 | +/* hooks.c */ | |
| 216 | +extern int fscrypt_file_open(struct inode *inode, struct file *filp); | |
| 217 | +extern int __fscrypt_prepare_link(struct inode *inode, struct inode *dir); | |
| 218 | +extern int __fscrypt_prepare_rename(struct inode *old_dir, | |
| 219 | + struct dentry *old_dentry, | |
| 220 | + struct inode *new_dir, | |
| 221 | + struct dentry *new_dentry, | |
| 222 | + unsigned int flags); | |
| 223 | +extern int __fscrypt_prepare_lookup(struct inode *dir, struct dentry *dentry); | |
| 224 | +extern int __fscrypt_prepare_symlink(struct inode *dir, unsigned int len, | |
| 225 | + unsigned int max_len, | |
| 226 | + struct fscrypt_str *disk_link); | |
| 227 | +extern int __fscrypt_encrypt_symlink(struct inode *inode, const char *target, | |
| 228 | + unsigned int len, | |
| 229 | + struct fscrypt_str *disk_link); | |
| 230 | +extern const char *fscrypt_get_symlink(struct inode *inode, const void *caddr, | |
| 231 | + unsigned int max_size, | |
| 232 | + struct delayed_call *done); | |
| 233 | +#else /* !CONFIG_FS_ENCRYPTION */ | |
| 234 | + | |
| 235 | +static inline bool fscrypt_has_encryption_key(const struct inode *inode) | |
| 236 | +{ | |
| 237 | + return false; | |
| 238 | +} | |
| 239 | + | |
| 240 | +static inline bool fscrypt_dummy_context_enabled(struct inode *inode) | |
| 241 | +{ | |
| 242 | + return false; | |
| 243 | +} | |
| 244 | + | |
| 245 | +/* crypto.c */ | |
| 246 | +static inline void fscrypt_enqueue_decrypt_work(struct work_struct *work) | |
| 247 | +{ | |
| 248 | +} | |
| 249 | + | |
| 250 | +static inline struct fscrypt_ctx *fscrypt_get_ctx(const struct inode *inode, | |
| 251 | + gfp_t gfp_flags) | |
| 252 | +{ | |
| 253 | + return ERR_PTR(-EOPNOTSUPP); | |
| 254 | +} | |
| 255 | + | |
| 256 | +static inline void fscrypt_release_ctx(struct fscrypt_ctx *ctx) | |
| 257 | +{ | |
| 258 | + return; | |
| 259 | +} | |
| 260 | + | |
| 261 | +static inline struct page *fscrypt_encrypt_page(const struct inode *inode, | |
| 262 | + struct page *page, | |
| 263 | + unsigned int len, | |
| 264 | + unsigned int offs, | |
| 265 | + u64 lblk_num, gfp_t gfp_flags) | |
| 266 | +{ | |
| 267 | + return ERR_PTR(-EOPNOTSUPP); | |
| 268 | +} | |
| 269 | + | |
| 270 | +static inline int fscrypt_decrypt_page(const struct inode *inode, | |
| 271 | + struct page *page, | |
| 272 | + unsigned int len, unsigned int offs, | |
| 273 | + u64 lblk_num) | |
| 274 | +{ | |
| 275 | + return -EOPNOTSUPP; | |
| 276 | +} | |
| 277 | + | |
| 278 | +static inline struct page *fscrypt_control_page(struct page *page) | |
| 279 | +{ | |
| 280 | + WARN_ON_ONCE(1); | |
| 281 | + return ERR_PTR(-EINVAL); | |
| 282 | +} | |
| 283 | + | |
| 284 | +static inline void fscrypt_restore_control_page(struct page *page) | |
| 285 | +{ | |
| 286 | + return; | |
| 287 | +} | |
| 288 | + | |
| 289 | +/* policy.c */ | |
| 290 | +static inline int fscrypt_ioctl_set_policy(struct file *filp, | |
| 291 | + const void __user *arg) | |
| 292 | +{ | |
| 293 | + return -EOPNOTSUPP; | |
| 294 | +} | |
| 295 | + | |
| 296 | +static inline int fscrypt_ioctl_get_policy(struct file *filp, void __user *arg) | |
| 297 | +{ | |
| 298 | + return -EOPNOTSUPP; | |
| 299 | +} | |
| 300 | + | |
| 301 | +static inline int fscrypt_has_permitted_context(struct inode *parent, | |
| 302 | + struct inode *child) | |
| 303 | +{ | |
| 304 | + return 0; | |
| 305 | +} | |
| 306 | + | |
| 307 | +static inline int fscrypt_inherit_context(struct inode *parent, | |
| 308 | + struct inode *child, | |
| 309 | + void *fs_data, bool preload) | |
| 310 | +{ | |
| 311 | + return -EOPNOTSUPP; | |
| 312 | +} | |
| 313 | + | |
| 314 | +/* keyinfo.c */ | |
| 315 | +static inline int fscrypt_get_encryption_info(struct inode *inode) | |
| 316 | +{ | |
| 317 | + return -EOPNOTSUPP; | |
| 318 | +} | |
| 319 | + | |
| 320 | +static inline void fscrypt_put_encryption_info(struct inode *inode) | |
| 321 | +{ | |
| 322 | + return; | |
| 323 | +} | |
| 324 | + | |
| 325 | + /* fname.c */ | |
| 326 | +static inline int fscrypt_setup_filename(struct inode *dir, | |
| 327 | + const struct qstr *iname, | |
| 328 | + int lookup, struct fscrypt_name *fname) | |
| 329 | +{ | |
| 330 | + if (IS_ENCRYPTED(dir)) | |
| 331 | + return -EOPNOTSUPP; | |
| 332 | + | |
| 333 | + memset(fname, 0, sizeof(struct fscrypt_name)); | |
| 334 | + fname->usr_fname = iname; | |
| 335 | + fname->disk_name.name = (unsigned char *)iname->name; | |
| 336 | + fname->disk_name.len = iname->len; | |
| 337 | + return 0; | |
| 338 | +} | |
| 339 | + | |
| 340 | +static inline void fscrypt_free_filename(struct fscrypt_name *fname) | |
| 341 | +{ | |
| 342 | + return; | |
| 343 | +} | |
| 344 | + | |
| 345 | +static inline int fscrypt_fname_alloc_buffer(const struct inode *inode, | |
| 346 | + u32 max_encrypted_len, | |
| 347 | + struct fscrypt_str *crypto_str) | |
| 348 | +{ | |
| 349 | + return -EOPNOTSUPP; | |
| 350 | +} | |
| 351 | + | |
| 352 | +static inline void fscrypt_fname_free_buffer(struct fscrypt_str *crypto_str) | |
| 353 | +{ | |
| 354 | + return; | |
| 355 | +} | |
| 356 | + | |
| 357 | +static inline int fscrypt_fname_disk_to_usr(struct inode *inode, | |
| 358 | + u32 hash, u32 minor_hash, | |
| 359 | + const struct fscrypt_str *iname, | |
| 360 | + struct fscrypt_str *oname) | |
| 361 | +{ | |
| 362 | + return -EOPNOTSUPP; | |
| 363 | +} | |
| 364 | + | |
| 365 | +static inline bool fscrypt_match_name(const struct fscrypt_name *fname, | |
| 366 | + const u8 *de_name, u32 de_name_len) | |
| 367 | +{ | |
| 368 | + /* Encryption support disabled; use standard comparison */ | |
| 369 | + if (de_name_len != fname->disk_name.len) | |
| 370 | + return false; | |
| 371 | + return !memcmp(de_name, fname->disk_name.name, fname->disk_name.len); | |
| 372 | +} | |
| 373 | + | |
| 374 | +/* bio.c */ | |
| 375 | +static inline void fscrypt_decrypt_bio(struct bio *bio) | |
| 376 | +{ | |
| 377 | +} | |
| 378 | + | |
| 379 | +static inline void fscrypt_enqueue_decrypt_bio(struct fscrypt_ctx *ctx, | |
| 380 | + struct bio *bio) | |
| 381 | +{ | |
| 382 | +} | |
| 383 | + | |
| 384 | +static inline void fscrypt_pullback_bio_page(struct page **page, bool restore) | |
| 385 | +{ | |
| 386 | + return; | |
| 387 | +} | |
| 388 | + | |
| 389 | +static inline int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk, | |
| 390 | + sector_t pblk, unsigned int len) | |
| 391 | +{ | |
| 392 | + return -EOPNOTSUPP; | |
| 393 | +} | |
| 394 | + | |
| 395 | +/* hooks.c */ | |
| 396 | + | |
| 397 | +static inline int fscrypt_file_open(struct inode *inode, struct file *filp) | |
| 398 | +{ | |
| 399 | + if (IS_ENCRYPTED(inode)) | |
| 400 | + return -EOPNOTSUPP; | |
| 401 | + return 0; | |
| 402 | +} | |
| 403 | + | |
| 404 | +static inline int __fscrypt_prepare_link(struct inode *inode, | |
| 405 | + struct inode *dir) | |
| 406 | +{ | |
| 407 | + return -EOPNOTSUPP; | |
| 408 | +} | |
| 409 | + | |
| 410 | +static inline int __fscrypt_prepare_rename(struct inode *old_dir, | |
| 411 | + struct dentry *old_dentry, | |
| 412 | + struct inode *new_dir, | |
| 413 | + struct dentry *new_dentry, | |
| 414 | + unsigned int flags) | |
| 415 | +{ | |
| 416 | + return -EOPNOTSUPP; | |
| 417 | +} | |
| 418 | + | |
| 419 | +static inline int __fscrypt_prepare_lookup(struct inode *dir, | |
| 420 | + struct dentry *dentry) | |
| 421 | +{ | |
| 422 | + return -EOPNOTSUPP; | |
| 423 | +} | |
| 424 | + | |
| 425 | +static inline int __fscrypt_prepare_symlink(struct inode *dir, | |
| 426 | + unsigned int len, | |
| 427 | + unsigned int max_len, | |
| 428 | + struct fscrypt_str *disk_link) | |
| 429 | +{ | |
| 430 | + return -EOPNOTSUPP; | |
| 431 | +} | |
| 432 | + | |
| 433 | + | |
| 434 | +static inline int __fscrypt_encrypt_symlink(struct inode *inode, | |
| 435 | + const char *target, | |
| 436 | + unsigned int len, | |
| 437 | + struct fscrypt_str *disk_link) | |
| 438 | +{ | |
| 439 | + return -EOPNOTSUPP; | |
| 440 | +} | |
| 441 | + | |
| 442 | +static inline const char *fscrypt_get_symlink(struct inode *inode, | |
| 443 | + const void *caddr, | |
| 444 | + unsigned int max_size, | |
| 445 | + struct delayed_call *done) | |
| 446 | +{ | |
| 447 | + return ERR_PTR(-EOPNOTSUPP); | |
| 448 | +} | |
| 449 | +#endif /* !CONFIG_FS_ENCRYPTION */ | |
| 50 | 450 | |
| 51 | 451 | /** |
| 52 | 452 | * fscrypt_require_key - require an inode's encryption key |
| @@ -1,231 +0,0 @@ | ||
| 1 | −/* SPDX-License-Identifier: GPL-2.0 */ | |
| 2 | −/* | |
| 3 | − * fscrypt_notsupp.h | |
| 4 | − * | |
| 5 | − * This stubs out the fscrypt functions for filesystems configured without | |
| 6 | − * encryption support. | |
| 7 | − * | |
| 8 | − * Do not include this file directly. Use fscrypt.h instead! | |
| 9 | − */ | |
| 10 | −#ifndef _LINUX_FSCRYPT_H | |
| 11 | −#error "Incorrect include of linux/fscrypt_notsupp.h!" | |
| 12 | −#endif | |
| 13 | − | |
| 14 | −#ifndef _LINUX_FSCRYPT_NOTSUPP_H | |
| 15 | −#define _LINUX_FSCRYPT_NOTSUPP_H | |
| 16 | − | |
| 17 | −static inline bool fscrypt_has_encryption_key(const struct inode *inode) | |
| 18 | −{ | |
| 19 | − return false; | |
| 20 | −} | |
| 21 | − | |
| 22 | −static inline bool fscrypt_dummy_context_enabled(struct inode *inode) | |
| 23 | −{ | |
| 24 | − return false; | |
| 25 | −} | |
| 26 | − | |
| 27 | −/* crypto.c */ | |
| 28 | −static inline void fscrypt_enqueue_decrypt_work(struct work_struct *work) | |
| 29 | −{ | |
| 30 | −} | |
| 31 | − | |
| 32 | −static inline struct fscrypt_ctx *fscrypt_get_ctx(const struct inode *inode, | |
| 33 | − gfp_t gfp_flags) | |
| 34 | −{ | |
| 35 | − return ERR_PTR(-EOPNOTSUPP); | |
| 36 | −} | |
| 37 | − | |
| 38 | −static inline void fscrypt_release_ctx(struct fscrypt_ctx *ctx) | |
| 39 | −{ | |
| 40 | − return; | |
| 41 | −} | |
| 42 | − | |
| 43 | −static inline struct page *fscrypt_encrypt_page(const struct inode *inode, | |
| 44 | − struct page *page, | |
| 45 | − unsigned int len, | |
| 46 | − unsigned int offs, | |
| 47 | − u64 lblk_num, gfp_t gfp_flags) | |
| 48 | −{ | |
| 49 | − return ERR_PTR(-EOPNOTSUPP); | |
| 50 | −} | |
| 51 | − | |
| 52 | −static inline int fscrypt_decrypt_page(const struct inode *inode, | |
| 53 | − struct page *page, | |
| 54 | − unsigned int len, unsigned int offs, | |
| 55 | − u64 lblk_num) | |
| 56 | −{ | |
| 57 | − return -EOPNOTSUPP; | |
| 58 | −} | |
| 59 | − | |
| 60 | −static inline struct page *fscrypt_control_page(struct page *page) | |
| 61 | −{ | |
| 62 | − WARN_ON_ONCE(1); | |
| 63 | − return ERR_PTR(-EINVAL); | |
| 64 | −} | |
| 65 | − | |
| 66 | −static inline void fscrypt_restore_control_page(struct page *page) | |
| 67 | −{ | |
| 68 | − return; | |
| 69 | −} | |
| 70 | − | |
| 71 | −/* policy.c */ | |
| 72 | −static inline int fscrypt_ioctl_set_policy(struct file *filp, | |
| 73 | − const void __user *arg) | |
| 74 | −{ | |
| 75 | − return -EOPNOTSUPP; | |
| 76 | −} | |
| 77 | − | |
| 78 | −static inline int fscrypt_ioctl_get_policy(struct file *filp, void __user *arg) | |
| 79 | −{ | |
| 80 | − return -EOPNOTSUPP; | |
| 81 | −} | |
| 82 | − | |
| 83 | −static inline int fscrypt_has_permitted_context(struct inode *parent, | |
| 84 | − struct inode *child) | |
| 85 | −{ | |
| 86 | − return 0; | |
| 87 | −} | |
| 88 | − | |
| 89 | −static inline int fscrypt_inherit_context(struct inode *parent, | |
| 90 | − struct inode *child, | |
| 91 | − void *fs_data, bool preload) | |
| 92 | −{ | |
| 93 | − return -EOPNOTSUPP; | |
| 94 | −} | |
| 95 | − | |
| 96 | −/* keyinfo.c */ | |
| 97 | −static inline int fscrypt_get_encryption_info(struct inode *inode) | |
| 98 | −{ | |
| 99 | − return -EOPNOTSUPP; | |
| 100 | −} | |
| 101 | − | |
| 102 | −static inline void fscrypt_put_encryption_info(struct inode *inode) | |
| 103 | −{ | |
| 104 | − return; | |
| 105 | −} | |
| 106 | − | |
| 107 | − /* fname.c */ | |
| 108 | −static inline int fscrypt_setup_filename(struct inode *dir, | |
| 109 | − const struct qstr *iname, | |
| 110 | − int lookup, struct fscrypt_name *fname) | |
| 111 | −{ | |
| 112 | − if (IS_ENCRYPTED(dir)) | |
| 113 | − return -EOPNOTSUPP; | |
| 114 | − | |
| 115 | − memset(fname, 0, sizeof(struct fscrypt_name)); | |
| 116 | − fname->usr_fname = iname; | |
| 117 | − fname->disk_name.name = (unsigned char *)iname->name; | |
| 118 | − fname->disk_name.len = iname->len; | |
| 119 | − return 0; | |
| 120 | −} | |
| 121 | − | |
| 122 | −static inline void fscrypt_free_filename(struct fscrypt_name *fname) | |
| 123 | −{ | |
| 124 | − return; | |
| 125 | −} | |
| 126 | − | |
| 127 | −static inline int fscrypt_fname_alloc_buffer(const struct inode *inode, | |
| 128 | − u32 max_encrypted_len, | |
| 129 | − struct fscrypt_str *crypto_str) | |
| 130 | −{ | |
| 131 | − return -EOPNOTSUPP; | |
| 132 | −} | |
| 133 | − | |
| 134 | −static inline void fscrypt_fname_free_buffer(struct fscrypt_str *crypto_str) | |
| 135 | −{ | |
| 136 | − return; | |
| 137 | −} | |
| 138 | − | |
| 139 | −static inline int fscrypt_fname_disk_to_usr(struct inode *inode, | |
| 140 | − u32 hash, u32 minor_hash, | |
| 141 | − const struct fscrypt_str *iname, | |
| 142 | − struct fscrypt_str *oname) | |
| 143 | −{ | |
| 144 | − return -EOPNOTSUPP; | |
| 145 | −} | |
| 146 | − | |
| 147 | −static inline bool fscrypt_match_name(const struct fscrypt_name *fname, | |
| 148 | − const u8 *de_name, u32 de_name_len) | |
| 149 | −{ | |
| 150 | − /* Encryption support disabled; use standard comparison */ | |
| 151 | − if (de_name_len != fname->disk_name.len) | |
| 152 | − return false; | |
| 153 | − return !memcmp(de_name, fname->disk_name.name, fname->disk_name.len); | |
| 154 | −} | |
| 155 | − | |
| 156 | −/* bio.c */ | |
| 157 | −static inline void fscrypt_decrypt_bio(struct bio *bio) | |
| 158 | −{ | |
| 159 | −} | |
| 160 | − | |
| 161 | −static inline void fscrypt_enqueue_decrypt_bio(struct fscrypt_ctx *ctx, | |
| 162 | − struct bio *bio) | |
| 163 | −{ | |
| 164 | −} | |
| 165 | − | |
| 166 | −static inline void fscrypt_pullback_bio_page(struct page **page, bool restore) | |
| 167 | −{ | |
| 168 | − return; | |
| 169 | −} | |
| 170 | − | |
| 171 | −static inline int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk, | |
| 172 | − sector_t pblk, unsigned int len) | |
| 173 | −{ | |
| 174 | − return -EOPNOTSUPP; | |
| 175 | −} | |
| 176 | − | |
| 177 | −/* hooks.c */ | |
| 178 | − | |
| 179 | −static inline int fscrypt_file_open(struct inode *inode, struct file *filp) | |
| 180 | −{ | |
| 181 | − if (IS_ENCRYPTED(inode)) | |
| 182 | − return -EOPNOTSUPP; | |
| 183 | − return 0; | |
| 184 | −} | |
| 185 | − | |
| 186 | −static inline int __fscrypt_prepare_link(struct inode *inode, | |
| 187 | − struct inode *dir) | |
| 188 | −{ | |
| 189 | − return -EOPNOTSUPP; | |
| 190 | −} | |
| 191 | − | |
| 192 | −static inline int __fscrypt_prepare_rename(struct inode *old_dir, | |
| 193 | − struct dentry *old_dentry, | |
| 194 | − struct inode *new_dir, | |
| 195 | − struct dentry *new_dentry, | |
| 196 | − unsigned int flags) | |
| 197 | −{ | |
| 198 | − return -EOPNOTSUPP; | |
| 199 | −} | |
| 200 | − | |
| 201 | −static inline int __fscrypt_prepare_lookup(struct inode *dir, | |
| 202 | − struct dentry *dentry) | |
| 203 | −{ | |
| 204 | − return -EOPNOTSUPP; | |
| 205 | −} | |
| 206 | − | |
| 207 | −static inline int __fscrypt_prepare_symlink(struct inode *dir, | |
| 208 | − unsigned int len, | |
| 209 | − unsigned int max_len, | |
| 210 | − struct fscrypt_str *disk_link) | |
| 211 | −{ | |
| 212 | − return -EOPNOTSUPP; | |
| 213 | −} | |
| 214 | − | |
| 215 | −static inline int __fscrypt_encrypt_symlink(struct inode *inode, | |
| 216 | − const char *target, | |
| 217 | − unsigned int len, | |
| 218 | − struct fscrypt_str *disk_link) | |
| 219 | −{ | |
| 220 | − return -EOPNOTSUPP; | |
| 221 | −} | |
| 222 | − | |
| 223 | −static inline const char *fscrypt_get_symlink(struct inode *inode, | |
| 224 | − const void *caddr, | |
| 225 | − unsigned int max_size, | |
| 226 | − struct delayed_call *done) | |
| 227 | −{ | |
| 228 | − return ERR_PTR(-EOPNOTSUPP); | |
| 229 | −} | |
| 230 | − | |
| 231 | −#endif /* _LINUX_FSCRYPT_NOTSUPP_H */ | |
| @@ -1,204 +0,0 @@ | ||
| 1 | −/* SPDX-License-Identifier: GPL-2.0 */ | |
| 2 | −/* | |
| 3 | − * fscrypt_supp.h | |
| 4 | − * | |
| 5 | − * Do not include this file directly. Use fscrypt.h instead! | |
| 6 | − */ | |
| 7 | −#ifndef _LINUX_FSCRYPT_H | |
| 8 | −#error "Incorrect include of linux/fscrypt_supp.h!" | |
| 9 | −#endif | |
| 10 | − | |
| 11 | −#ifndef _LINUX_FSCRYPT_SUPP_H | |
| 12 | −#define _LINUX_FSCRYPT_SUPP_H | |
| 13 | − | |
| 14 | −#include <linux/mm.h> | |
| 15 | −#include <linux/slab.h> | |
| 16 | − | |
| 17 | −/* | |
| 18 | − * fscrypt superblock flags | |
| 19 | − */ | |
| 20 | −#define FS_CFLG_OWN_PAGES (1U << 1) | |
| 21 | − | |
| 22 | −/* | |
| 23 | − * crypto operations for filesystems | |
| 24 | − */ | |
| 25 | −struct fscrypt_operations { | |
| 26 | − unsigned int flags; | |
| 27 | − const char *key_prefix; | |
| 28 | − int (*get_context)(struct inode *, void *, size_t); | |
| 29 | − int (*set_context)(struct inode *, const void *, size_t, void *); | |
| 30 | − bool (*dummy_context)(struct inode *); | |
| 31 | − bool (*empty_dir)(struct inode *); | |
| 32 | − unsigned int max_namelen; | |
| 33 | −}; | |
| 34 | − | |
| 35 | −struct fscrypt_ctx { | |
| 36 | − union { | |
| 37 | − struct { | |
| 38 | − struct page *bounce_page; /* Ciphertext page */ | |
| 39 | − struct page *control_page; /* Original page */ | |
| 40 | − } w; | |
| 41 | − struct { | |
| 42 | − struct bio *bio; | |
| 43 | − struct work_struct work; | |
| 44 | − } r; | |
| 45 | − struct list_head free_list; /* Free list */ | |
| 46 | − }; | |
| 47 | − u8 flags; /* Flags */ | |
| 48 | −}; | |
| 49 | − | |
| 50 | −static inline bool fscrypt_has_encryption_key(const struct inode *inode) | |
| 51 | −{ | |
| 52 | − return (inode->i_crypt_info != NULL); | |
| 53 | −} | |
| 54 | − | |
| 55 | −static inline bool fscrypt_dummy_context_enabled(struct inode *inode) | |
| 56 | −{ | |
| 57 | − return inode->i_sb->s_cop->dummy_context && | |
| 58 | − inode->i_sb->s_cop->dummy_context(inode); | |
| 59 | −} | |
| 60 | − | |
| 61 | −/* crypto.c */ | |
| 62 | −extern void fscrypt_enqueue_decrypt_work(struct work_struct *); | |
| 63 | −extern struct fscrypt_ctx *fscrypt_get_ctx(const struct inode *, gfp_t); | |
| 64 | −extern void fscrypt_release_ctx(struct fscrypt_ctx *); | |
| 65 | −extern struct page *fscrypt_encrypt_page(const struct inode *, struct page *, | |
| 66 | − unsigned int, unsigned int, | |
| 67 | − u64, gfp_t); | |
| 68 | −extern int fscrypt_decrypt_page(const struct inode *, struct page *, unsigned int, | |
| 69 | − unsigned int, u64); | |
| 70 | − | |
| 71 | −static inline struct page *fscrypt_control_page(struct page *page) | |
| 72 | −{ | |
| 73 | − return ((struct fscrypt_ctx *)page_private(page))->w.control_page; | |
| 74 | −} | |
| 75 | − | |
| 76 | −extern void fscrypt_restore_control_page(struct page *); | |
| 77 | − | |
| 78 | −/* policy.c */ | |
| 79 | −extern int fscrypt_ioctl_set_policy(struct file *, const void __user *); | |
| 80 | −extern int fscrypt_ioctl_get_policy(struct file *, void __user *); | |
| 81 | −extern int fscrypt_has_permitted_context(struct inode *, struct inode *); | |
| 82 | −extern int fscrypt_inherit_context(struct inode *, struct inode *, | |
| 83 | − void *, bool); | |
| 84 | −/* keyinfo.c */ | |
| 85 | −extern int fscrypt_get_encryption_info(struct inode *); | |
| 86 | −extern void fscrypt_put_encryption_info(struct inode *); | |
| 87 | − | |
| 88 | −/* fname.c */ | |
| 89 | −extern int fscrypt_setup_filename(struct inode *, const struct qstr *, | |
| 90 | − int lookup, struct fscrypt_name *); | |
| 91 | − | |
| 92 | −static inline void fscrypt_free_filename(struct fscrypt_name *fname) | |
| 93 | −{ | |
| 94 | − kfree(fname->crypto_buf.name); | |
| 95 | −} | |
| 96 | − | |
| 97 | −extern int fscrypt_fname_alloc_buffer(const struct inode *, u32, | |
| 98 | − struct fscrypt_str *); | |
| 99 | −extern void fscrypt_fname_free_buffer(struct fscrypt_str *); | |
| 100 | −extern int fscrypt_fname_disk_to_usr(struct inode *, u32, u32, | |
| 101 | − const struct fscrypt_str *, struct fscrypt_str *); | |
| 102 | − | |
| 103 | −#define FSCRYPT_FNAME_MAX_UNDIGESTED_SIZE 32 | |
| 104 | − | |
| 105 | −/* Extracts the second-to-last ciphertext block; see explanation below */ | |
| 106 | −#define FSCRYPT_FNAME_DIGEST(name, len) \ | |
| 107 | − ((name) + round_down((len) - FS_CRYPTO_BLOCK_SIZE - 1, \ | |
| 108 | − FS_CRYPTO_BLOCK_SIZE)) | |
| 109 | − | |
| 110 | −#define FSCRYPT_FNAME_DIGEST_SIZE FS_CRYPTO_BLOCK_SIZE | |
| 111 | − | |
| 112 | −/** | |
| 113 | − * fscrypt_digested_name - alternate identifier for an on-disk filename | |
| 114 | − * | |
| 115 | − * When userspace lists an encrypted directory without access to the key, | |
| 116 | − * filenames whose ciphertext is longer than FSCRYPT_FNAME_MAX_UNDIGESTED_SIZE | |
| 117 | − * bytes are shown in this abbreviated form (base64-encoded) rather than as the | |
| 118 | − * full ciphertext (base64-encoded). This is necessary to allow supporting | |
| 119 | − * filenames up to NAME_MAX bytes, since base64 encoding expands the length. | |
| 120 | − * | |
| 121 | − * To make it possible for filesystems to still find the correct directory entry | |
| 122 | − * despite not knowing the full on-disk name, we encode any filesystem-specific | |
| 123 | − * 'hash' and/or 'minor_hash' which the filesystem may need for its lookups, | |
| 124 | − * followed by the second-to-last ciphertext block of the filename. Due to the | |
| 125 | − * use of the CBC-CTS encryption mode, the second-to-last ciphertext block | |
| 126 | − * depends on the full plaintext. (Note that ciphertext stealing causes the | |
| 127 | − * last two blocks to appear "flipped".) This makes accidental collisions very | |
| 128 | − * unlikely: just a 1 in 2^128 chance for two filenames to collide even if they | |
| 129 | − * share the same filesystem-specific hashes. | |
| 130 | − * | |
| 131 | − * However, this scheme isn't immune to intentional collisions, which can be | |
| 132 | − * created by anyone able to create arbitrary plaintext filenames and view them | |
| 133 | − * without the key. Making the "digest" be a real cryptographic hash like | |
| 134 | − * SHA-256 over the full ciphertext would prevent this, although it would be | |
| 135 | − * less efficient and harder to implement, especially since the filesystem would | |
| 136 | − * need to calculate it for each directory entry examined during a search. | |
| 137 | − */ | |
| 138 | −struct fscrypt_digested_name { | |
| 139 | − u32 hash; | |
| 140 | − u32 minor_hash; | |
| 141 | − u8 digest[FSCRYPT_FNAME_DIGEST_SIZE]; | |
| 142 | −}; | |
| 143 | − | |
| 144 | −/** | |
| 145 | − * fscrypt_match_name() - test whether the given name matches a directory entry | |
| 146 | − * @fname: the name being searched for | |
| 147 | − * @de_name: the name from the directory entry | |
| 148 | − * @de_name_len: the length of @de_name in bytes | |
| 149 | − * | |
| 150 | − * Normally @fname->disk_name will be set, and in that case we simply compare | |
| 151 | − * that to the name stored in the directory entry. The only exception is that | |
| 152 | − * if we don't have the key for an encrypted directory and a filename in it is | |
| 153 | − * very long, then we won't have the full disk_name and we'll instead need to | |
| 154 | − * match against the fscrypt_digested_name. | |
| 155 | − * | |
| 156 | − * Return: %true if the name matches, otherwise %false. | |
| 157 | − */ | |
| 158 | −static inline bool fscrypt_match_name(const struct fscrypt_name *fname, | |
| 159 | − const u8 *de_name, u32 de_name_len) | |
| 160 | −{ | |
| 161 | − if (unlikely(!fname->disk_name.name)) { | |
| 162 | − const struct fscrypt_digested_name *n = | |
| 163 | − (const void *)fname->crypto_buf.name; | |
| 164 | − if (WARN_ON_ONCE(fname->usr_fname->name[0] != '_')) | |
| 165 | − return false; | |
| 166 | − if (de_name_len <= FSCRYPT_FNAME_MAX_UNDIGESTED_SIZE) | |
| 167 | − return false; | |
| 168 | − return !memcmp(FSCRYPT_FNAME_DIGEST(de_name, de_name_len), | |
| 169 | − n->digest, FSCRYPT_FNAME_DIGEST_SIZE); | |
| 170 | − } | |
| 171 | − | |
| 172 | − if (de_name_len != fname->disk_name.len) | |
| 173 | − return false; | |
| 174 | − return !memcmp(de_name, fname->disk_name.name, fname->disk_name.len); | |
| 175 | −} | |
| 176 | − | |
| 177 | −/* bio.c */ | |
| 178 | −extern void fscrypt_decrypt_bio(struct bio *); | |
| 179 | −extern void fscrypt_enqueue_decrypt_bio(struct fscrypt_ctx *ctx, | |
| 180 | − struct bio *bio); | |
| 181 | −extern void fscrypt_pullback_bio_page(struct page **, bool); | |
| 182 | −extern int fscrypt_zeroout_range(const struct inode *, pgoff_t, sector_t, | |
| 183 | − unsigned int); | |
| 184 | − | |
| 185 | −/* hooks.c */ | |
| 186 | −extern int fscrypt_file_open(struct inode *inode, struct file *filp); | |
| 187 | −extern int __fscrypt_prepare_link(struct inode *inode, struct inode *dir); | |
| 188 | −extern int __fscrypt_prepare_rename(struct inode *old_dir, | |
| 189 | − struct dentry *old_dentry, | |
| 190 | − struct inode *new_dir, | |
| 191 | − struct dentry *new_dentry, | |
| 192 | − unsigned int flags); | |
| 193 | −extern int __fscrypt_prepare_lookup(struct inode *dir, struct dentry *dentry); | |
| 194 | −extern int __fscrypt_prepare_symlink(struct inode *dir, unsigned int len, | |
| 195 | − unsigned int max_len, | |
| 196 | − struct fscrypt_str *disk_link); | |
| 197 | −extern int __fscrypt_encrypt_symlink(struct inode *inode, const char *target, | |
| 198 | − unsigned int len, | |
| 199 | − struct fscrypt_str *disk_link); | |
| 200 | −extern const char *fscrypt_get_symlink(struct inode *inode, const void *caddr, | |
| 201 | − unsigned int max_size, | |
| 202 | − struct delayed_call *done); | |
| 203 | − | |
| 204 | −#endif /* _LINUX_FSCRYPT_SUPP_H */ | |