1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /**
3 * eCryptfs: Linux filesystem encryption layer
4 * Kernel declarations.
5 *
6 * Copyright (C) 1997-2003 Erez Zadok
7 * Copyright (C) 2001-2003 Stony Brook University
8 * Copyright (C) 2004-2008 International Business Machines Corp.
9 * Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
10 * Trevor S. Highland <trevor.highland@gmail.com>
11 * Tyler Hicks <code@tyhicks.com>
12 */
13
14 #ifndef ECRYPTFS_KERNEL_H
15 #define ECRYPTFS_KERNEL_H
16
17 #include <crypto/md5.h>
18 #include <crypto/skcipher.h>
19 #include <keys/user-type.h>
20 #include <keys/encrypted-type.h>
21 #include <linux/kernel.h>
22 #include <linux/fs.h>
23 #include <linux/fs_stack.h>
24 #include <linux/namei.h>
25 #include <linux/scatterlist.h>
26 #include <linux/hash.h>
27 #include <linux/nsproxy.h>
28 #include <linux/backing-dev.h>
29 #include <linux/ecryptfs.h>
30
31 #define ECRYPTFS_DEFAULT_IV_BYTES 16
32 #define ECRYPTFS_DEFAULT_EXTENT_SIZE 4096
33 #define ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE 8192
34 #define ECRYPTFS_DEFAULT_MSG_CTX_ELEMS 32
35 #define ECRYPTFS_DEFAULT_SEND_TIMEOUT HZ
36 #define ECRYPTFS_MAX_MSG_CTX_TTL (HZ*3)
37 #define ECRYPTFS_DEFAULT_NUM_USERS 4
38 #define ECRYPTFS_MAX_NUM_USERS 32768
39 #define ECRYPTFS_XATTR_NAME "user.ecryptfs"
40
41 void ecryptfs_dump_auth_tok(struct ecryptfs_auth_tok *auth_tok);
42 static inline void
ecryptfs_to_hex(char * dst,char * src,size_t src_size)43 ecryptfs_to_hex(char *dst, char *src, size_t src_size)
44 {
45 char *end = bin2hex(dst, src, src_size);
46 *end = '\0';
47 }
48
49 extern void ecryptfs_from_hex(char *dst, char *src, int dst_size);
50
51 struct ecryptfs_key_record {
52 unsigned char type;
53 size_t enc_key_size;
54 unsigned char sig[ECRYPTFS_SIG_SIZE];
55 unsigned char enc_key[ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES];
56 };
57
58 struct ecryptfs_auth_tok_list {
59 struct ecryptfs_auth_tok *auth_tok;
60 struct list_head list;
61 };
62
63 struct ecryptfs_crypt_stat;
64 struct ecryptfs_mount_crypt_stat;
65
66 struct ecryptfs_page_crypt_context {
67 struct page *page;
68 #define ECRYPTFS_PREPARE_COMMIT_MODE 0
69 #define ECRYPTFS_WRITEPAGE_MODE 1
70 unsigned int mode;
71 union {
72 struct file *lower_file;
73 struct writeback_control *wbc;
74 } param;
75 };
76
77 #if defined(CONFIG_ENCRYPTED_KEYS) || defined(CONFIG_ENCRYPTED_KEYS_MODULE)
78 static inline struct ecryptfs_auth_tok *
ecryptfs_get_encrypted_key_payload_data(struct key * key)79 ecryptfs_get_encrypted_key_payload_data(struct key *key)
80 {
81 struct encrypted_key_payload *payload;
82
83 if (key->type != &key_type_encrypted)
84 return NULL;
85
86 payload = key->payload.data[0];
87 if (!payload)
88 return ERR_PTR(-EKEYREVOKED);
89
90 return (struct ecryptfs_auth_tok *)payload->payload_data;
91 }
92
ecryptfs_get_encrypted_key(char * sig)93 static inline struct key *ecryptfs_get_encrypted_key(char *sig)
94 {
95 return request_key(&key_type_encrypted, sig, NULL);
96 }
97
98 #else
99 static inline struct ecryptfs_auth_tok *
ecryptfs_get_encrypted_key_payload_data(struct key * key)100 ecryptfs_get_encrypted_key_payload_data(struct key *key)
101 {
102 return NULL;
103 }
104
ecryptfs_get_encrypted_key(char * sig)105 static inline struct key *ecryptfs_get_encrypted_key(char *sig)
106 {
107 return ERR_PTR(-ENOKEY);
108 }
109
110 #endif /* CONFIG_ENCRYPTED_KEYS */
111
112 static inline struct ecryptfs_auth_tok *
ecryptfs_get_key_payload_data(struct key * key)113 ecryptfs_get_key_payload_data(struct key *key)
114 {
115 struct ecryptfs_auth_tok *auth_tok;
116 struct user_key_payload *ukp;
117
118 auth_tok = ecryptfs_get_encrypted_key_payload_data(key);
119 if (auth_tok)
120 return auth_tok;
121
122 ukp = user_key_payload_locked(key);
123 if (!ukp)
124 return ERR_PTR(-EKEYREVOKED);
125
126 return (struct ecryptfs_auth_tok *)ukp->data;
127 }
128
129 #define ECRYPTFS_MAX_KEYSET_SIZE 1024
130 #define ECRYPTFS_MAX_CIPHER_NAME_SIZE 31
131 #define ECRYPTFS_MAX_NUM_ENC_KEYS 64
132 #define ECRYPTFS_MAX_IV_BYTES 16 /* 128 bits */
133 #define ECRYPTFS_SALT_BYTES 2
134 #define MAGIC_ECRYPTFS_MARKER 0x3c81b7f5
135 #define MAGIC_ECRYPTFS_MARKER_SIZE_BYTES 8 /* 4*2 */
136 #define ECRYPTFS_FILE_SIZE_BYTES (sizeof(u64))
137 #define ECRYPTFS_SIZE_AND_MARKER_BYTES (ECRYPTFS_FILE_SIZE_BYTES \
138 + MAGIC_ECRYPTFS_MARKER_SIZE_BYTES)
139 #define ECRYPTFS_DEFAULT_CIPHER "aes"
140 #define ECRYPTFS_DEFAULT_KEY_BYTES 16
141 #define ECRYPTFS_TAG_1_PACKET_TYPE 0x01
142 #define ECRYPTFS_TAG_3_PACKET_TYPE 0x8C
143 #define ECRYPTFS_TAG_11_PACKET_TYPE 0xED
144 #define ECRYPTFS_TAG_64_PACKET_TYPE 0x40
145 #define ECRYPTFS_TAG_65_PACKET_TYPE 0x41
146 #define ECRYPTFS_TAG_66_PACKET_TYPE 0x42
147 #define ECRYPTFS_TAG_67_PACKET_TYPE 0x43
148 #define ECRYPTFS_TAG_70_PACKET_TYPE 0x46 /* FNEK-encrypted filename
149 * as dentry name */
150 #define ECRYPTFS_TAG_71_PACKET_TYPE 0x47 /* FNEK-encrypted filename in
151 * metadata */
152 #define ECRYPTFS_TAG_72_PACKET_TYPE 0x48 /* FEK-encrypted filename as
153 * dentry name */
154 #define ECRYPTFS_TAG_73_PACKET_TYPE 0x49 /* FEK-encrypted filename as
155 * metadata */
156 #define ECRYPTFS_MIN_PKT_LEN_SIZE 1 /* Min size to specify packet length */
157 #define ECRYPTFS_MAX_PKT_LEN_SIZE 2 /* Pass at least this many bytes to
158 * ecryptfs_parse_packet_length() and
159 * ecryptfs_write_packet_length()
160 */
161 /* Constraint: ECRYPTFS_FILENAME_MIN_RANDOM_PREPEND_BYTES >=
162 * ECRYPTFS_MAX_IV_BYTES */
163 #define ECRYPTFS_FILENAME_MIN_RANDOM_PREPEND_BYTES 16
164 #define ECRYPTFS_NON_NULL 0x42 /* A reasonable substitute for NULL */
165 #define ECRYPTFS_TAG_70_MIN_METADATA_SIZE (1 + ECRYPTFS_MIN_PKT_LEN_SIZE \
166 + ECRYPTFS_SIG_SIZE + 1 + 1)
167 #define ECRYPTFS_TAG_70_MAX_METADATA_SIZE (1 + ECRYPTFS_MAX_PKT_LEN_SIZE \
168 + ECRYPTFS_SIG_SIZE + 1 + 1)
169 #define ECRYPTFS_FEK_ENCRYPTED_FILENAME_PREFIX "ECRYPTFS_FEK_ENCRYPTED."
170 #define ECRYPTFS_FEK_ENCRYPTED_FILENAME_PREFIX_SIZE 23
171 #define ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX "ECRYPTFS_FNEK_ENCRYPTED."
172 #define ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE 24
173 #define ECRYPTFS_ENCRYPTED_DENTRY_NAME_LEN (18 + 1 + 4 + 1 + 32)
174
175 #ifdef CONFIG_ECRYPT_FS_MESSAGING
176 # define ECRYPTFS_VERSIONING_MASK_MESSAGING (ECRYPTFS_VERSIONING_DEVMISC \
177 | ECRYPTFS_VERSIONING_PUBKEY)
178 #else
179 # define ECRYPTFS_VERSIONING_MASK_MESSAGING 0
180 #endif
181
182 #define ECRYPTFS_VERSIONING_MASK (ECRYPTFS_VERSIONING_PASSPHRASE \
183 | ECRYPTFS_VERSIONING_PLAINTEXT_PASSTHROUGH \
184 | ECRYPTFS_VERSIONING_XATTR \
185 | ECRYPTFS_VERSIONING_MULTKEY \
186 | ECRYPTFS_VERSIONING_MASK_MESSAGING \
187 | ECRYPTFS_VERSIONING_FILENAME_ENCRYPTION)
188 struct ecryptfs_key_sig {
189 struct list_head crypt_stat_list;
190 char keysig[ECRYPTFS_SIG_SIZE_HEX + 1];
191 };
192
193 struct ecryptfs_filename {
194 struct list_head crypt_stat_list;
195 #define ECRYPTFS_FILENAME_CONTAINS_DECRYPTED 0x00000001
196 u32 flags;
197 u32 seq_no;
198 char *filename;
199 char *encrypted_filename;
200 size_t filename_size;
201 size_t encrypted_filename_size;
202 char fnek_sig[ECRYPTFS_SIG_SIZE_HEX];
203 char dentry_name[ECRYPTFS_ENCRYPTED_DENTRY_NAME_LEN + 1];
204 };
205
206 /**
207 * This is the primary struct associated with each encrypted file.
208 *
209 * TODO: cache align/pack?
210 */
211 struct ecryptfs_crypt_stat {
212 #define ECRYPTFS_STRUCT_INITIALIZED 0x00000001
213 #define ECRYPTFS_POLICY_APPLIED 0x00000002
214 #define ECRYPTFS_ENCRYPTED 0x00000004
215 #define ECRYPTFS_SECURITY_WARNING 0x00000008
216 #define ECRYPTFS_ENABLE_HMAC 0x00000010
217 #define ECRYPTFS_ENCRYPT_IV_PAGES 0x00000020
218 #define ECRYPTFS_KEY_VALID 0x00000040
219 #define ECRYPTFS_METADATA_IN_XATTR 0x00000080
220 #define ECRYPTFS_VIEW_AS_ENCRYPTED 0x00000100
221 #define ECRYPTFS_KEY_SET 0x00000200
222 #define ECRYPTFS_ENCRYPT_FILENAMES 0x00000400
223 #define ECRYPTFS_ENCFN_USE_MOUNT_FNEK 0x00000800
224 #define ECRYPTFS_ENCFN_USE_FEK 0x00001000
225 #define ECRYPTFS_UNLINK_SIGS 0x00002000
226 #define ECRYPTFS_I_SIZE_INITIALIZED 0x00004000
227 u32 flags;
228 unsigned int file_version;
229 size_t iv_bytes;
230 size_t metadata_size;
231 size_t extent_size; /* Data extent size; default is 4096 */
232 size_t key_size;
233 size_t extent_shift;
234 unsigned int extent_mask;
235 struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
236 struct crypto_skcipher *tfm;
237 unsigned char cipher[ECRYPTFS_MAX_CIPHER_NAME_SIZE + 1];
238 unsigned char key[ECRYPTFS_MAX_KEY_BYTES];
239 unsigned char root_iv[ECRYPTFS_MAX_IV_BYTES];
240 struct list_head keysig_list;
241 struct mutex keysig_list_mutex;
242 struct mutex cs_tfm_mutex;
243 struct mutex cs_mutex;
244 };
245
246 /* inode private data. */
247 struct ecryptfs_inode_info {
248 struct inode vfs_inode;
249 struct inode *wii_inode;
250 struct mutex lower_file_mutex;
251 atomic_t lower_file_count;
252 struct file *lower_file;
253 struct ecryptfs_crypt_stat crypt_stat;
254 };
255
256 /**
257 * ecryptfs_global_auth_tok - A key used to encrypt all new files under the mountpoint
258 * @flags: Status flags
259 * @mount_crypt_stat_list: These auth_toks hang off the mount-wide
260 * cryptographic context. Every time a new
261 * inode comes into existence, eCryptfs copies
262 * the auth_toks on that list to the set of
263 * auth_toks on the inode's crypt_stat
264 * @global_auth_tok_key: The key from the user's keyring for the sig
265 * @global_auth_tok: The key contents
266 * @sig: The key identifier
267 *
268 * ecryptfs_global_auth_tok structs refer to authentication token keys
269 * in the user keyring that apply to newly created files. A list of
270 * these objects hangs off of the mount_crypt_stat struct for any
271 * given eCryptfs mount. This struct maintains a reference to both the
272 * key contents and the key itself so that the key can be put on
273 * unmount.
274 */
275 struct ecryptfs_global_auth_tok {
276 #define ECRYPTFS_AUTH_TOK_INVALID 0x00000001
277 #define ECRYPTFS_AUTH_TOK_FNEK 0x00000002
278 u32 flags;
279 struct list_head mount_crypt_stat_list;
280 struct key *global_auth_tok_key;
281 unsigned char sig[ECRYPTFS_SIG_SIZE_HEX + 1];
282 };
283
284 /**
285 * ecryptfs_key_tfm - Persistent key tfm
286 * @key_tfm: crypto API handle to the key
287 * @key_size: Key size in bytes
288 * @key_tfm_mutex: Mutex to ensure only one operation in eCryptfs is
289 * using the persistent TFM at any point in time
290 * @key_tfm_list: Handle to hang this off the module-wide TFM list
291 * @cipher_name: String name for the cipher for this TFM
292 *
293 * Typically, eCryptfs will use the same ciphers repeatedly throughout
294 * the course of its operations. In order to avoid unnecessarily
295 * destroying and initializing the same cipher repeatedly, eCryptfs
296 * keeps a list of crypto API contexts around to use when needed.
297 */
298 struct ecryptfs_key_tfm {
299 struct crypto_skcipher *key_tfm;
300 size_t key_size;
301 struct mutex key_tfm_mutex;
302 struct list_head key_tfm_list;
303 unsigned char cipher_name[ECRYPTFS_MAX_CIPHER_NAME_SIZE + 1];
304 };
305
306 extern struct mutex key_tfm_list_mutex;
307
308 /**
309 * This struct is to enable a mount-wide passphrase/salt combo. This
310 * is more or less a stopgap to provide similar functionality to other
311 * crypto filesystems like EncFS or CFS until full policy support is
312 * implemented in eCryptfs.
313 */
314 struct ecryptfs_mount_crypt_stat {
315 /* Pointers to memory we do not own, do not free these */
316 #define ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED 0x00000001
317 #define ECRYPTFS_XATTR_METADATA_ENABLED 0x00000002
318 #define ECRYPTFS_ENCRYPTED_VIEW_ENABLED 0x00000004
319 #define ECRYPTFS_MOUNT_CRYPT_STAT_INITIALIZED 0x00000008
320 #define ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES 0x00000010
321 #define ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK 0x00000020
322 #define ECRYPTFS_GLOBAL_ENCFN_USE_FEK 0x00000040
323 #define ECRYPTFS_GLOBAL_MOUNT_AUTH_TOK_ONLY 0x00000080
324 u32 flags;
325 struct list_head global_auth_tok_list;
326 struct mutex global_auth_tok_list_mutex;
327 size_t global_default_cipher_key_size;
328 size_t global_default_fn_cipher_key_bytes;
329 unsigned char global_default_cipher_name[ECRYPTFS_MAX_CIPHER_NAME_SIZE
330 + 1];
331 unsigned char global_default_fn_cipher_name[
332 ECRYPTFS_MAX_CIPHER_NAME_SIZE + 1];
333 char global_default_fnek_sig[ECRYPTFS_SIG_SIZE_HEX + 1];
334 };
335
336 /* superblock private data. */
337 struct ecryptfs_sb_info {
338 struct super_block *wsi_sb;
339 struct vfsmount *lower_mnt;
340 struct ecryptfs_mount_crypt_stat mount_crypt_stat;
341 };
342
343 /* file private data. */
344 struct ecryptfs_file_info {
345 struct file *wfi_file;
346 struct ecryptfs_crypt_stat *crypt_stat;
347 };
348
349 /* auth_tok <=> encrypted_session_key mappings */
350 struct ecryptfs_auth_tok_list_item {
351 unsigned char encrypted_session_key[ECRYPTFS_MAX_KEY_BYTES];
352 struct list_head list;
353 struct ecryptfs_auth_tok auth_tok;
354 };
355
356 struct ecryptfs_message {
357 /* Can never be greater than ecryptfs_message_buf_len */
358 /* Used to find the parent msg_ctx */
359 /* Inherits from msg_ctx->index */
360 u32 index;
361 u32 data_len;
362 u8 data[];
363 };
364
365 struct ecryptfs_msg_ctx {
366 #define ECRYPTFS_MSG_CTX_STATE_FREE 0x01
367 #define ECRYPTFS_MSG_CTX_STATE_PENDING 0x02
368 #define ECRYPTFS_MSG_CTX_STATE_DONE 0x03
369 #define ECRYPTFS_MSG_CTX_STATE_NO_REPLY 0x04
370 u8 state;
371 #define ECRYPTFS_MSG_HELO 100
372 #define ECRYPTFS_MSG_QUIT 101
373 #define ECRYPTFS_MSG_REQUEST 102
374 #define ECRYPTFS_MSG_RESPONSE 103
375 u8 type;
376 u32 index;
377 /* Counter converts to a sequence number. Each message sent
378 * out for which we expect a response has an associated
379 * sequence number. The response must have the same sequence
380 * number as the counter for the msg_stc for the message to be
381 * valid. */
382 u32 counter;
383 size_t msg_size;
384 struct ecryptfs_message *msg;
385 struct task_struct *task;
386 struct list_head node;
387 struct list_head daemon_out_list;
388 struct mutex mux;
389 };
390
391 struct ecryptfs_daemon {
392 #define ECRYPTFS_DAEMON_IN_READ 0x00000001
393 #define ECRYPTFS_DAEMON_IN_POLL 0x00000002
394 #define ECRYPTFS_DAEMON_ZOMBIE 0x00000004
395 #define ECRYPTFS_DAEMON_MISCDEV_OPEN 0x00000008
396 u32 flags;
397 u32 num_queued_msg_ctx;
398 struct file *file;
399 struct mutex mux;
400 struct list_head msg_ctx_out_queue;
401 wait_queue_head_t wait;
402 struct hlist_node euid_chain;
403 };
404
405 #ifdef CONFIG_ECRYPT_FS_MESSAGING
406 extern struct mutex ecryptfs_daemon_hash_mux;
407 #endif
408
409 static inline size_t
ecryptfs_lower_header_size(struct ecryptfs_crypt_stat * crypt_stat)410 ecryptfs_lower_header_size(struct ecryptfs_crypt_stat *crypt_stat)
411 {
412 if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR)
413 return 0;
414 return crypt_stat->metadata_size;
415 }
416
417 static inline struct ecryptfs_file_info *
ecryptfs_file_to_private(struct file * file)418 ecryptfs_file_to_private(struct file *file)
419 {
420 return file->private_data;
421 }
422
423 static inline void
ecryptfs_set_file_private(struct file * file,struct ecryptfs_file_info * file_info)424 ecryptfs_set_file_private(struct file *file,
425 struct ecryptfs_file_info *file_info)
426 {
427 file->private_data = file_info;
428 }
429
ecryptfs_file_to_lower(struct file * file)430 static inline struct file *ecryptfs_file_to_lower(struct file *file)
431 {
432 return ((struct ecryptfs_file_info *)file->private_data)->wfi_file;
433 }
434
435 static inline void
ecryptfs_set_file_lower(struct file * file,struct file * lower_file)436 ecryptfs_set_file_lower(struct file *file, struct file *lower_file)
437 {
438 ((struct ecryptfs_file_info *)file->private_data)->wfi_file =
439 lower_file;
440 }
441
442 static inline struct ecryptfs_inode_info *
ecryptfs_inode_to_private(struct inode * inode)443 ecryptfs_inode_to_private(struct inode *inode)
444 {
445 return container_of(inode, struct ecryptfs_inode_info, vfs_inode);
446 }
447
ecryptfs_inode_to_lower(struct inode * inode)448 static inline struct inode *ecryptfs_inode_to_lower(struct inode *inode)
449 {
450 return ecryptfs_inode_to_private(inode)->wii_inode;
451 }
452
453 static inline void
ecryptfs_set_inode_lower(struct inode * inode,struct inode * lower_inode)454 ecryptfs_set_inode_lower(struct inode *inode, struct inode *lower_inode)
455 {
456 ecryptfs_inode_to_private(inode)->wii_inode = lower_inode;
457 }
458
459 static inline struct ecryptfs_sb_info *
ecryptfs_superblock_to_private(struct super_block * sb)460 ecryptfs_superblock_to_private(struct super_block *sb)
461 {
462 return (struct ecryptfs_sb_info *)sb->s_fs_info;
463 }
464
465 static inline void
ecryptfs_set_superblock_private(struct super_block * sb,struct ecryptfs_sb_info * sb_info)466 ecryptfs_set_superblock_private(struct super_block *sb,
467 struct ecryptfs_sb_info *sb_info)
468 {
469 sb->s_fs_info = sb_info;
470 }
471
472 static inline struct super_block *
ecryptfs_superblock_to_lower(struct super_block * sb)473 ecryptfs_superblock_to_lower(struct super_block *sb)
474 {
475 return ((struct ecryptfs_sb_info *)sb->s_fs_info)->wsi_sb;
476 }
477
478 static inline void
ecryptfs_set_superblock_lower(struct super_block * sb,struct super_block * lower_sb)479 ecryptfs_set_superblock_lower(struct super_block *sb,
480 struct super_block *lower_sb)
481 {
482 ((struct ecryptfs_sb_info *)sb->s_fs_info)->wsi_sb = lower_sb;
483 }
484
485 static inline void
ecryptfs_set_dentry_lower(struct dentry * dentry,struct dentry * lower_dentry)486 ecryptfs_set_dentry_lower(struct dentry *dentry,
487 struct dentry *lower_dentry)
488 {
489 dentry->d_fsdata = lower_dentry;
490 }
491
492 static inline struct dentry *
ecryptfs_dentry_to_lower(struct dentry * dentry)493 ecryptfs_dentry_to_lower(struct dentry *dentry)
494 {
495 return dentry->d_fsdata;
496 }
497
498 static inline struct path
ecryptfs_lower_path(struct dentry * dentry)499 ecryptfs_lower_path(struct dentry *dentry)
500 {
501 return (struct path){
502 .mnt = ecryptfs_superblock_to_private(dentry->d_sb)->lower_mnt,
503 .dentry = ecryptfs_dentry_to_lower(dentry)
504 };
505 }
506
507 #define ecryptfs_printk(type, fmt, arg...) \
508 __ecryptfs_printk(type "%s: " fmt, __func__, ## arg)
509 __printf(1, 2)
510 void __ecryptfs_printk(const char *fmt, ...);
511
512 extern const struct file_operations ecryptfs_main_fops;
513 extern const struct file_operations ecryptfs_dir_fops;
514 extern const struct inode_operations ecryptfs_main_iops;
515 extern const struct inode_operations ecryptfs_dir_iops;
516 extern const struct inode_operations ecryptfs_symlink_iops;
517 extern const struct super_operations ecryptfs_sops;
518 extern const struct dentry_operations ecryptfs_dops;
519 extern const struct address_space_operations ecryptfs_aops;
520 extern int ecryptfs_verbosity;
521 extern unsigned int ecryptfs_message_buf_len;
522 extern signed long ecryptfs_message_wait_timeout;
523 extern unsigned int ecryptfs_number_of_users;
524
525 extern struct kmem_cache *ecryptfs_auth_tok_list_item_cache;
526 extern struct kmem_cache *ecryptfs_file_info_cache;
527 extern struct kmem_cache *ecryptfs_inode_info_cache;
528 extern struct kmem_cache *ecryptfs_sb_info_cache;
529 extern struct kmem_cache *ecryptfs_header_cache;
530 extern struct kmem_cache *ecryptfs_xattr_cache;
531 extern struct kmem_cache *ecryptfs_key_record_cache;
532 extern struct kmem_cache *ecryptfs_key_sig_cache;
533 extern struct kmem_cache *ecryptfs_global_auth_tok_cache;
534 extern struct kmem_cache *ecryptfs_key_tfm_cache;
535
536 struct inode *ecryptfs_get_inode(struct inode *lower_inode,
537 struct super_block *sb);
538 void ecryptfs_i_size_init(const char *page_virt, struct inode *inode);
539 int ecryptfs_initialize_file(struct dentry *ecryptfs_dentry,
540 struct inode *ecryptfs_inode);
541 int ecryptfs_decode_and_decrypt_filename(char **decrypted_name,
542 size_t *decrypted_name_size,
543 struct super_block *sb,
544 const char *name, size_t name_size);
545 int ecryptfs_fill_zeros(struct file *file, loff_t new_length);
546 int ecryptfs_encrypt_and_encode_filename(
547 char **encoded_name,
548 size_t *encoded_name_size,
549 struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
550 const char *name, size_t name_size);
551 void ecryptfs_dump_hex(char *data, int bytes);
552 int virt_to_scatterlist(const void *addr, int size, struct scatterlist *sg,
553 int sg_size);
554 int ecryptfs_compute_root_iv(struct ecryptfs_crypt_stat *crypt_stat);
555 void ecryptfs_rotate_iv(unsigned char *iv);
556 void ecryptfs_init_crypt_stat(struct ecryptfs_crypt_stat *crypt_stat);
557 void ecryptfs_destroy_crypt_stat(struct ecryptfs_crypt_stat *crypt_stat);
558 void ecryptfs_destroy_mount_crypt_stat(
559 struct ecryptfs_mount_crypt_stat *mount_crypt_stat);
560 int ecryptfs_init_crypt_ctx(struct ecryptfs_crypt_stat *crypt_stat);
561 int ecryptfs_write_inode_size_to_metadata(struct inode *ecryptfs_inode);
562 int ecryptfs_encrypt_page(struct folio *folio);
563 int ecryptfs_decrypt_page(struct folio *folio);
564 int ecryptfs_write_metadata(struct dentry *ecryptfs_dentry,
565 struct inode *ecryptfs_inode);
566 int ecryptfs_read_metadata(struct dentry *ecryptfs_dentry);
567 int ecryptfs_new_file_context(struct inode *ecryptfs_inode);
568 void ecryptfs_write_crypt_stat_flags(char *page_virt,
569 struct ecryptfs_crypt_stat *crypt_stat,
570 size_t *written);
571 int ecryptfs_read_and_validate_header_region(struct inode *inode);
572 int ecryptfs_read_and_validate_xattr_region(struct dentry *dentry,
573 struct inode *inode);
574 u8 ecryptfs_code_for_cipher_string(char *cipher_name, size_t key_bytes);
575 int ecryptfs_cipher_code_to_string(char *str, u8 cipher_code);
576 void ecryptfs_set_default_sizes(struct ecryptfs_crypt_stat *crypt_stat);
577 int ecryptfs_generate_key_packet_set(char *dest_base,
578 struct ecryptfs_crypt_stat *crypt_stat,
579 struct dentry *ecryptfs_dentry,
580 size_t *len, size_t max);
581 int
582 ecryptfs_parse_packet_set(struct ecryptfs_crypt_stat *crypt_stat,
583 unsigned char *src, struct dentry *ecryptfs_dentry);
584 int ecryptfs_truncate(struct dentry *dentry, loff_t new_length);
585 ssize_t
586 ecryptfs_getxattr_lower(struct dentry *lower_dentry, struct inode *lower_inode,
587 const char *name, void *value, size_t size);
588 int
589 ecryptfs_setxattr(struct dentry *dentry, struct inode *inode, const char *name,
590 const void *value, size_t size, int flags);
591 int ecryptfs_read_xattr_region(char *page_virt, struct inode *ecryptfs_inode);
592 #ifdef CONFIG_ECRYPT_FS_MESSAGING
593 int ecryptfs_process_response(struct ecryptfs_daemon *daemon,
594 struct ecryptfs_message *msg, u32 seq);
595 int ecryptfs_send_message(char *data, int data_len,
596 struct ecryptfs_msg_ctx **msg_ctx);
597 int ecryptfs_wait_for_response(struct ecryptfs_msg_ctx *msg_ctx,
598 struct ecryptfs_message **emsg);
599 int ecryptfs_init_messaging(void);
600 void ecryptfs_release_messaging(void);
601 #else
ecryptfs_init_messaging(void)602 static inline int ecryptfs_init_messaging(void)
603 {
604 return 0;
605 }
ecryptfs_release_messaging(void)606 static inline void ecryptfs_release_messaging(void)
607 { }
ecryptfs_send_message(char * data,int data_len,struct ecryptfs_msg_ctx ** msg_ctx)608 static inline int ecryptfs_send_message(char *data, int data_len,
609 struct ecryptfs_msg_ctx **msg_ctx)
610 {
611 return -ENOTCONN;
612 }
ecryptfs_wait_for_response(struct ecryptfs_msg_ctx * msg_ctx,struct ecryptfs_message ** emsg)613 static inline int ecryptfs_wait_for_response(struct ecryptfs_msg_ctx *msg_ctx,
614 struct ecryptfs_message **emsg)
615 {
616 return -ENOMSG;
617 }
618 #endif
619
620 void
621 ecryptfs_write_header_metadata(char *virt,
622 struct ecryptfs_crypt_stat *crypt_stat,
623 size_t *written);
624 int ecryptfs_add_keysig(struct ecryptfs_crypt_stat *crypt_stat, char *sig);
625 int
626 ecryptfs_add_global_auth_tok(struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
627 char *sig, u32 global_auth_tok_flags);
628 int ecryptfs_get_global_auth_tok_for_sig(
629 struct ecryptfs_global_auth_tok **global_auth_tok,
630 struct ecryptfs_mount_crypt_stat *mount_crypt_stat, char *sig);
631 int
632 ecryptfs_add_new_key_tfm(struct ecryptfs_key_tfm **key_tfm, char *cipher_name,
633 size_t key_size);
634 int ecryptfs_init_crypto(void);
635 int ecryptfs_destroy_crypto(void);
636 int ecryptfs_tfm_exists(char *cipher_name, struct ecryptfs_key_tfm **key_tfm);
637 int ecryptfs_get_tfm_and_mutex_for_cipher_name(struct crypto_skcipher **tfm,
638 struct mutex **tfm_mutex,
639 char *cipher_name);
640 int ecryptfs_keyring_auth_tok_for_sig(struct key **auth_tok_key,
641 struct ecryptfs_auth_tok **auth_tok,
642 char *sig);
643 int ecryptfs_write_lower(struct inode *ecryptfs_inode, char *data,
644 loff_t offset, size_t size);
645 int ecryptfs_write_lower_page_segment(struct inode *ecryptfs_inode,
646 struct folio *folio_for_lower,
647 size_t offset_in_page, size_t size);
648 int ecryptfs_write(struct inode *inode, char *data, loff_t offset, size_t size);
649 int ecryptfs_read_lower(char *data, loff_t offset, size_t size,
650 struct inode *ecryptfs_inode);
651 int ecryptfs_read_lower_page_segment(struct folio *folio_for_ecryptfs,
652 pgoff_t page_index,
653 size_t offset_in_page, size_t size,
654 struct inode *ecryptfs_inode);
655 int ecryptfs_parse_packet_length(unsigned char *data, size_t *size,
656 size_t *length_size);
657 int ecryptfs_write_packet_length(char *dest, size_t size,
658 size_t *packet_size_length);
659 #ifdef CONFIG_ECRYPT_FS_MESSAGING
660 int ecryptfs_init_ecryptfs_miscdev(void);
661 void ecryptfs_destroy_ecryptfs_miscdev(void);
662 int ecryptfs_send_miscdev(char *data, size_t data_size,
663 struct ecryptfs_msg_ctx *msg_ctx, u8 msg_type,
664 u16 msg_flags, struct ecryptfs_daemon *daemon);
665 void ecryptfs_msg_ctx_alloc_to_free(struct ecryptfs_msg_ctx *msg_ctx);
666 int
667 ecryptfs_spawn_daemon(struct ecryptfs_daemon **daemon, struct file *file);
668 int ecryptfs_exorcise_daemon(struct ecryptfs_daemon *daemon);
669 int ecryptfs_find_daemon_by_euid(struct ecryptfs_daemon **daemon);
670 #endif
671 int ecryptfs_init_kthread(void);
672 void ecryptfs_destroy_kthread(void);
673 int ecryptfs_privileged_open(struct file **lower_file,
674 struct dentry *lower_dentry,
675 struct vfsmount *lower_mnt,
676 const struct cred *cred);
677 int ecryptfs_get_lower_file(struct dentry *dentry, struct inode *inode);
678 void ecryptfs_put_lower_file(struct inode *inode);
679 int
680 ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
681 size_t *packet_size,
682 struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
683 char *filename, size_t filename_size);
684 int
685 ecryptfs_parse_tag_70_packet(char **filename, size_t *filename_size,
686 size_t *packet_size,
687 struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
688 char *data, size_t max_packet_size);
689 int ecryptfs_set_f_namelen(long *namelen, long lower_namelen,
690 struct ecryptfs_mount_crypt_stat *mount_crypt_stat);
691 void ecryptfs_derive_iv(char *iv, struct ecryptfs_crypt_stat *crypt_stat,
692 loff_t offset);
693
694 extern const struct xattr_handler * const ecryptfs_xattr_handlers[];
695
696 #endif /* #ifndef ECRYPTFS_KERNEL_H */
697