2 * eCryptfs: Linux filesystem encryption layer
4 * Copyright (C) 1997-2004 Erez Zadok
5 * Copyright (C) 2001-2004 Stony Brook University
6 * Copyright (C) 2004-2007 International Business Machines Corp.
7 * Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
8 * Michael C. Thompson <mcthomps@us.ibm.com>
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation; either version 2 of the
13 * License, or (at your option) any later version.
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
27 #include <linux/mount.h>
28 #include <linux/pagemap.h>
29 #include <linux/random.h>
30 #include <linux/compiler.h>
31 #include <linux/key.h>
32 #include <linux/namei.h>
33 #include <linux/crypto.h>
34 #include <linux/file.h>
35 #include <linux/scatterlist.h>
36 #include <linux/slab.h>
37 #include <asm/unaligned.h>
38 #include "ecryptfs_kernel.h"
41 ecryptfs_decrypt_page_offset(struct ecryptfs_crypt_stat
*crypt_stat
,
42 struct page
*dst_page
, int dst_offset
,
43 struct page
*src_page
, int src_offset
, int size
,
46 ecryptfs_encrypt_page_offset(struct ecryptfs_crypt_stat
*crypt_stat
,
47 struct page
*dst_page
, int dst_offset
,
48 struct page
*src_page
, int src_offset
, int size
,
53 * @dst: Buffer to take hex character representation of contents of
54 * src; must be at least of size (src_size * 2)
55 * @src: Buffer to be converted to a hex string respresentation
56 * @src_size: number of bytes to convert
58 void ecryptfs_to_hex(char *dst
, char *src
, size_t src_size
)
62 for (x
= 0; x
< src_size
; x
++)
63 sprintf(&dst
[x
* 2], "%.2x", (unsigned char)src
[x
]);
68 * @dst: Buffer to take the bytes from src hex; must be at least of
70 * @src: Buffer to be converted from a hex string respresentation to raw value
71 * @dst_size: size of dst buffer, or number of hex characters pairs to convert
73 void ecryptfs_from_hex(char *dst
, char *src
, int dst_size
)
78 for (x
= 0; x
< dst_size
; x
++) {
80 tmp
[1] = src
[x
* 2 + 1];
81 dst
[x
] = (unsigned char)simple_strtol(tmp
, NULL
, 16);
86 * ecryptfs_calculate_md5 - calculates the md5 of @src
87 * @dst: Pointer to 16 bytes of allocated memory
88 * @crypt_stat: Pointer to crypt_stat struct for the current inode
89 * @src: Data to be md5'd
90 * @len: Length of @src
92 * Uses the allocated crypto context that crypt_stat references to
93 * generate the MD5 sum of the contents of src.
95 static int ecryptfs_calculate_md5(char *dst
,
96 struct ecryptfs_crypt_stat
*crypt_stat
,
99 struct scatterlist sg
;
100 struct hash_desc desc
= {
101 .tfm
= crypt_stat
->hash_tfm
,
102 .flags
= CRYPTO_TFM_REQ_MAY_SLEEP
106 mutex_lock(&crypt_stat
->cs_hash_tfm_mutex
);
107 sg_init_one(&sg
, (u8
*)src
, len
);
109 desc
.tfm
= crypto_alloc_hash(ECRYPTFS_DEFAULT_HASH
, 0,
111 if (IS_ERR(desc
.tfm
)) {
112 rc
= PTR_ERR(desc
.tfm
);
113 ecryptfs_printk(KERN_ERR
, "Error attempting to "
114 "allocate crypto context; rc = [%d]\n",
118 crypt_stat
->hash_tfm
= desc
.tfm
;
120 rc
= crypto_hash_init(&desc
);
123 "%s: Error initializing crypto hash; rc = [%d]\n",
127 rc
= crypto_hash_update(&desc
, &sg
, len
);
130 "%s: Error updating crypto hash; rc = [%d]\n",
134 rc
= crypto_hash_final(&desc
, dst
);
137 "%s: Error finalizing crypto hash; rc = [%d]\n",
142 mutex_unlock(&crypt_stat
->cs_hash_tfm_mutex
);
146 static int ecryptfs_crypto_api_algify_cipher_name(char **algified_name
,
148 char *chaining_modifier
)
150 int cipher_name_len
= strlen(cipher_name
);
151 int chaining_modifier_len
= strlen(chaining_modifier
);
152 int algified_name_len
;
155 algified_name_len
= (chaining_modifier_len
+ cipher_name_len
+ 3);
156 (*algified_name
) = kmalloc(algified_name_len
, GFP_KERNEL
);
157 if (!(*algified_name
)) {
161 snprintf((*algified_name
), algified_name_len
, "%s(%s)",
162 chaining_modifier
, cipher_name
);
170 * @iv: destination for the derived iv vale
171 * @crypt_stat: Pointer to crypt_stat struct for the current inode
172 * @offset: Offset of the extent whose IV we are to derive
174 * Generate the initialization vector from the given root IV and page
177 * Returns zero on success; non-zero on error.
179 int ecryptfs_derive_iv(char *iv
, struct ecryptfs_crypt_stat
*crypt_stat
,
183 char dst
[MD5_DIGEST_SIZE
];
184 char src
[ECRYPTFS_MAX_IV_BYTES
+ 16];
186 if (unlikely(ecryptfs_verbosity
> 0)) {
187 ecryptfs_printk(KERN_DEBUG
, "root iv:\n");
188 ecryptfs_dump_hex(crypt_stat
->root_iv
, crypt_stat
->iv_bytes
);
190 /* TODO: It is probably secure to just cast the least
191 * significant bits of the root IV into an unsigned long and
192 * add the offset to that rather than go through all this
193 * hashing business. -Halcrow */
194 memcpy(src
, crypt_stat
->root_iv
, crypt_stat
->iv_bytes
);
195 memset((src
+ crypt_stat
->iv_bytes
), 0, 16);
196 snprintf((src
+ crypt_stat
->iv_bytes
), 16, "%lld", offset
);
197 if (unlikely(ecryptfs_verbosity
> 0)) {
198 ecryptfs_printk(KERN_DEBUG
, "source:\n");
199 ecryptfs_dump_hex(src
, (crypt_stat
->iv_bytes
+ 16));
201 rc
= ecryptfs_calculate_md5(dst
, crypt_stat
, src
,
202 (crypt_stat
->iv_bytes
+ 16));
204 ecryptfs_printk(KERN_WARNING
, "Error attempting to compute "
205 "MD5 while generating IV for a page\n");
208 memcpy(iv
, dst
, crypt_stat
->iv_bytes
);
209 if (unlikely(ecryptfs_verbosity
> 0)) {
210 ecryptfs_printk(KERN_DEBUG
, "derived iv:\n");
211 ecryptfs_dump_hex(iv
, crypt_stat
->iv_bytes
);
218 * ecryptfs_init_crypt_stat
219 * @crypt_stat: Pointer to the crypt_stat struct to initialize.
221 * Initialize the crypt_stat structure.
224 ecryptfs_init_crypt_stat(struct ecryptfs_crypt_stat
*crypt_stat
)
226 memset((void *)crypt_stat
, 0, sizeof(struct ecryptfs_crypt_stat
));
227 INIT_LIST_HEAD(&crypt_stat
->keysig_list
);
228 mutex_init(&crypt_stat
->keysig_list_mutex
);
229 mutex_init(&crypt_stat
->cs_mutex
);
230 mutex_init(&crypt_stat
->cs_tfm_mutex
);
231 mutex_init(&crypt_stat
->cs_hash_tfm_mutex
);
232 crypt_stat
->flags
|= ECRYPTFS_STRUCT_INITIALIZED
;
236 * ecryptfs_destroy_crypt_stat
237 * @crypt_stat: Pointer to the crypt_stat struct to initialize.
239 * Releases all memory associated with a crypt_stat struct.
241 void ecryptfs_destroy_crypt_stat(struct ecryptfs_crypt_stat
*crypt_stat
)
243 struct ecryptfs_key_sig
*key_sig
, *key_sig_tmp
;
246 crypto_free_ablkcipher(crypt_stat
->tfm
);
247 if (crypt_stat
->hash_tfm
)
248 crypto_free_hash(crypt_stat
->hash_tfm
);
249 list_for_each_entry_safe(key_sig
, key_sig_tmp
,
250 &crypt_stat
->keysig_list
, crypt_stat_list
) {
251 list_del(&key_sig
->crypt_stat_list
);
252 kmem_cache_free(ecryptfs_key_sig_cache
, key_sig
);
254 memset(crypt_stat
, 0, sizeof(struct ecryptfs_crypt_stat
));
257 void ecryptfs_destroy_mount_crypt_stat(
258 struct ecryptfs_mount_crypt_stat
*mount_crypt_stat
)
260 struct ecryptfs_global_auth_tok
*auth_tok
, *auth_tok_tmp
;
262 if (!(mount_crypt_stat
->flags
& ECRYPTFS_MOUNT_CRYPT_STAT_INITIALIZED
))
264 mutex_lock(&mount_crypt_stat
->global_auth_tok_list_mutex
);
265 list_for_each_entry_safe(auth_tok
, auth_tok_tmp
,
266 &mount_crypt_stat
->global_auth_tok_list
,
267 mount_crypt_stat_list
) {
268 list_del(&auth_tok
->mount_crypt_stat_list
);
269 if (auth_tok
->global_auth_tok_key
270 && !(auth_tok
->flags
& ECRYPTFS_AUTH_TOK_INVALID
))
271 key_put(auth_tok
->global_auth_tok_key
);
272 kmem_cache_free(ecryptfs_global_auth_tok_cache
, auth_tok
);
274 mutex_unlock(&mount_crypt_stat
->global_auth_tok_list_mutex
);
275 memset(mount_crypt_stat
, 0, sizeof(struct ecryptfs_mount_crypt_stat
));
279 * virt_to_scatterlist
280 * @addr: Virtual address
281 * @size: Size of data; should be an even multiple of the block size
282 * @sg: Pointer to scatterlist array; set to NULL to obtain only
283 * the number of scatterlist structs required in array
284 * @sg_size: Max array size
286 * Fills in a scatterlist array with page references for a passed
289 * Returns the number of scatterlist structs in array used
291 int virt_to_scatterlist(const void *addr
, int size
, struct scatterlist
*sg
,
297 int remainder_of_page
;
299 sg_init_table(sg
, sg_size
);
301 while (size
> 0 && i
< sg_size
) {
302 pg
= virt_to_page(addr
);
303 offset
= offset_in_page(addr
);
304 sg_set_page(&sg
[i
], pg
, 0, offset
);
305 remainder_of_page
= PAGE_CACHE_SIZE
- offset
;
306 if (size
>= remainder_of_page
) {
307 sg
[i
].length
= remainder_of_page
;
308 addr
+= remainder_of_page
;
309 size
-= remainder_of_page
;
322 struct extent_crypt_result
{
323 struct completion completion
;
327 static void extent_crypt_complete(struct crypto_async_request
*req
, int rc
)
329 struct extent_crypt_result
*ecr
= req
->data
;
331 if (rc
== -EINPROGRESS
)
335 complete(&ecr
->completion
);
339 * encrypt_scatterlist
340 * @crypt_stat: Pointer to the crypt_stat struct to initialize.
341 * @dest_sg: Destination of encrypted data
342 * @src_sg: Data to be encrypted
343 * @size: Length of data to be encrypted
344 * @iv: iv to use during encryption
346 * Returns the number of bytes encrypted; negative value on error
348 static int encrypt_scatterlist(struct ecryptfs_crypt_stat
*crypt_stat
,
349 struct scatterlist
*dest_sg
,
350 struct scatterlist
*src_sg
, int size
,
353 struct ablkcipher_request
*req
= NULL
;
354 struct extent_crypt_result ecr
;
357 BUG_ON(!crypt_stat
|| !crypt_stat
->tfm
358 || !(crypt_stat
->flags
& ECRYPTFS_STRUCT_INITIALIZED
));
359 if (unlikely(ecryptfs_verbosity
> 0)) {
360 ecryptfs_printk(KERN_DEBUG
, "Key size [%zd]; key:\n",
361 crypt_stat
->key_size
);
362 ecryptfs_dump_hex(crypt_stat
->key
,
363 crypt_stat
->key_size
);
366 init_completion(&ecr
.completion
);
368 mutex_lock(&crypt_stat
->cs_tfm_mutex
);
369 req
= ablkcipher_request_alloc(crypt_stat
->tfm
, GFP_NOFS
);
371 mutex_unlock(&crypt_stat
->cs_tfm_mutex
);
376 ablkcipher_request_set_callback(req
,
377 CRYPTO_TFM_REQ_MAY_BACKLOG
| CRYPTO_TFM_REQ_MAY_SLEEP
,
378 extent_crypt_complete
, &ecr
);
379 /* Consider doing this once, when the file is opened */
380 if (!(crypt_stat
->flags
& ECRYPTFS_KEY_SET
)) {
381 rc
= crypto_ablkcipher_setkey(crypt_stat
->tfm
, crypt_stat
->key
,
382 crypt_stat
->key_size
);
384 ecryptfs_printk(KERN_ERR
,
385 "Error setting key; rc = [%d]\n",
387 mutex_unlock(&crypt_stat
->cs_tfm_mutex
);
391 crypt_stat
->flags
|= ECRYPTFS_KEY_SET
;
393 mutex_unlock(&crypt_stat
->cs_tfm_mutex
);
394 ecryptfs_printk(KERN_DEBUG
, "Encrypting [%d] bytes.\n", size
);
395 ablkcipher_request_set_crypt(req
, src_sg
, dest_sg
, size
, iv
);
396 rc
= crypto_ablkcipher_encrypt(req
);
397 if (rc
== -EINPROGRESS
|| rc
== -EBUSY
) {
398 struct extent_crypt_result
*ecr
= req
->base
.data
;
400 wait_for_completion(&ecr
->completion
);
402 INIT_COMPLETION(ecr
->completion
);
405 ablkcipher_request_free(req
);
410 * ecryptfs_lower_offset_for_extent
412 * Convert an eCryptfs page index into a lower byte offset
414 static void ecryptfs_lower_offset_for_extent(loff_t
*offset
, loff_t extent_num
,
415 struct ecryptfs_crypt_stat
*crypt_stat
)
417 (*offset
) = ecryptfs_lower_header_size(crypt_stat
)
418 + (crypt_stat
->extent_size
* extent_num
);
422 * ecryptfs_encrypt_extent
423 * @enc_extent_page: Allocated page into which to encrypt the data in
425 * @crypt_stat: crypt_stat containing cryptographic context for the
426 * encryption operation
427 * @page: Page containing plaintext data extent to encrypt
428 * @extent_offset: Page extent offset for use in generating IV
430 * Encrypts one extent of data.
432 * Return zero on success; non-zero otherwise
434 static int ecryptfs_encrypt_extent(struct page
*enc_extent_page
,
435 struct ecryptfs_crypt_stat
*crypt_stat
,
437 unsigned long extent_offset
)
440 char extent_iv
[ECRYPTFS_MAX_IV_BYTES
];
443 extent_base
= (((loff_t
)page
->index
)
444 * (PAGE_CACHE_SIZE
/ crypt_stat
->extent_size
));
445 rc
= ecryptfs_derive_iv(extent_iv
, crypt_stat
,
446 (extent_base
+ extent_offset
));
448 ecryptfs_printk(KERN_ERR
, "Error attempting to derive IV for "
449 "extent [0x%.16llx]; rc = [%d]\n",
450 (unsigned long long)(extent_base
+ extent_offset
), rc
);
453 rc
= ecryptfs_encrypt_page_offset(crypt_stat
, enc_extent_page
, 0,
455 * crypt_stat
->extent_size
),
456 crypt_stat
->extent_size
, extent_iv
);
458 printk(KERN_ERR
"%s: Error attempting to encrypt page with "
459 "page->index = [%ld], extent_offset = [%ld]; "
460 "rc = [%d]\n", __func__
, page
->index
, extent_offset
,
470 * ecryptfs_encrypt_page
471 * @page: Page mapped from the eCryptfs inode for the file; contains
472 * decrypted content that needs to be encrypted (to a temporary
473 * page; not in place) and written out to the lower file
475 * Encrypt an eCryptfs page. This is done on a per-extent basis. Note
476 * that eCryptfs pages may straddle the lower pages -- for instance,
477 * if the file was created on a machine with an 8K page size
478 * (resulting in an 8K header), and then the file is copied onto a
479 * host with a 32K page size, then when reading page 0 of the eCryptfs
480 * file, 24K of page 0 of the lower file will be read and decrypted,
481 * and then 8K of page 1 of the lower file will be read and decrypted.
483 * Returns zero on success; negative on error
485 int ecryptfs_encrypt_page(struct page
*page
)
487 struct inode
*ecryptfs_inode
;
488 struct ecryptfs_crypt_stat
*crypt_stat
;
489 char *enc_extent_virt
;
490 struct page
*enc_extent_page
= NULL
;
491 loff_t extent_offset
;
494 ecryptfs_inode
= page
->mapping
->host
;
496 &(ecryptfs_inode_to_private(ecryptfs_inode
)->crypt_stat
);
497 BUG_ON(!(crypt_stat
->flags
& ECRYPTFS_ENCRYPTED
));
498 enc_extent_page
= alloc_page(GFP_USER
);
499 if (!enc_extent_page
) {
501 ecryptfs_printk(KERN_ERR
, "Error allocating memory for "
502 "encrypted extent\n");
505 enc_extent_virt
= kmap(enc_extent_page
);
506 for (extent_offset
= 0;
507 extent_offset
< (PAGE_CACHE_SIZE
/ crypt_stat
->extent_size
);
511 rc
= ecryptfs_encrypt_extent(enc_extent_page
, crypt_stat
, page
,
514 printk(KERN_ERR
"%s: Error encrypting extent; "
515 "rc = [%d]\n", __func__
, rc
);
518 ecryptfs_lower_offset_for_extent(
519 &offset
, ((((loff_t
)page
->index
)
521 / crypt_stat
->extent_size
))
522 + extent_offset
), crypt_stat
);
523 rc
= ecryptfs_write_lower(ecryptfs_inode
, enc_extent_virt
,
524 offset
, crypt_stat
->extent_size
);
526 ecryptfs_printk(KERN_ERR
, "Error attempting "
527 "to write lower page; rc = [%d]"
534 if (enc_extent_page
) {
535 kunmap(enc_extent_page
);
536 __free_page(enc_extent_page
);
541 static int ecryptfs_decrypt_extent(struct page
*page
,
542 struct ecryptfs_crypt_stat
*crypt_stat
,
543 struct page
*enc_extent_page
,
544 unsigned long extent_offset
)
547 char extent_iv
[ECRYPTFS_MAX_IV_BYTES
];
550 extent_base
= (((loff_t
)page
->index
)
551 * (PAGE_CACHE_SIZE
/ crypt_stat
->extent_size
));
552 rc
= ecryptfs_derive_iv(extent_iv
, crypt_stat
,
553 (extent_base
+ extent_offset
));
555 ecryptfs_printk(KERN_ERR
, "Error attempting to derive IV for "
556 "extent [0x%.16llx]; rc = [%d]\n",
557 (unsigned long long)(extent_base
+ extent_offset
), rc
);
560 rc
= ecryptfs_decrypt_page_offset(crypt_stat
, page
,
562 * crypt_stat
->extent_size
),
564 crypt_stat
->extent_size
, extent_iv
);
566 printk(KERN_ERR
"%s: Error attempting to decrypt to page with "
567 "page->index = [%ld], extent_offset = [%ld]; "
568 "rc = [%d]\n", __func__
, page
->index
, extent_offset
,
578 * ecryptfs_decrypt_page
579 * @page: Page mapped from the eCryptfs inode for the file; data read
580 * and decrypted from the lower file will be written into this
583 * Decrypt an eCryptfs page. This is done on a per-extent basis. Note
584 * that eCryptfs pages may straddle the lower pages -- for instance,
585 * if the file was created on a machine with an 8K page size
586 * (resulting in an 8K header), and then the file is copied onto a
587 * host with a 32K page size, then when reading page 0 of the eCryptfs
588 * file, 24K of page 0 of the lower file will be read and decrypted,
589 * and then 8K of page 1 of the lower file will be read and decrypted.
591 * Returns zero on success; negative on error
593 int ecryptfs_decrypt_page(struct page
*page
)
595 struct inode
*ecryptfs_inode
;
596 struct ecryptfs_crypt_stat
*crypt_stat
;
597 char *enc_extent_virt
;
598 struct page
*enc_extent_page
= NULL
;
599 unsigned long extent_offset
;
602 ecryptfs_inode
= page
->mapping
->host
;
604 &(ecryptfs_inode_to_private(ecryptfs_inode
)->crypt_stat
);
605 BUG_ON(!(crypt_stat
->flags
& ECRYPTFS_ENCRYPTED
));
606 enc_extent_page
= alloc_page(GFP_USER
);
607 if (!enc_extent_page
) {
609 ecryptfs_printk(KERN_ERR
, "Error allocating memory for "
610 "encrypted extent\n");
613 enc_extent_virt
= kmap(enc_extent_page
);
614 for (extent_offset
= 0;
615 extent_offset
< (PAGE_CACHE_SIZE
/ crypt_stat
->extent_size
);
619 ecryptfs_lower_offset_for_extent(
620 &offset
, ((page
->index
* (PAGE_CACHE_SIZE
621 / crypt_stat
->extent_size
))
622 + extent_offset
), crypt_stat
);
623 rc
= ecryptfs_read_lower(enc_extent_virt
, offset
,
624 crypt_stat
->extent_size
,
627 ecryptfs_printk(KERN_ERR
, "Error attempting "
628 "to read lower page; rc = [%d]"
632 rc
= ecryptfs_decrypt_extent(page
, crypt_stat
, enc_extent_page
,
635 printk(KERN_ERR
"%s: Error encrypting extent; "
636 "rc = [%d]\n", __func__
, rc
);
641 if (enc_extent_page
) {
642 kunmap(enc_extent_page
);
643 __free_page(enc_extent_page
);
649 * decrypt_scatterlist
650 * @crypt_stat: Cryptographic context
651 * @dest_sg: The destination scatterlist to decrypt into
652 * @src_sg: The source scatterlist to decrypt from
653 * @size: The number of bytes to decrypt
654 * @iv: The initialization vector to use for the decryption
656 * Returns the number of bytes decrypted; negative value on error
658 static int decrypt_scatterlist(struct ecryptfs_crypt_stat
*crypt_stat
,
659 struct scatterlist
*dest_sg
,
660 struct scatterlist
*src_sg
, int size
,
663 struct ablkcipher_request
*req
= NULL
;
664 struct extent_crypt_result ecr
;
667 BUG_ON(!crypt_stat
|| !crypt_stat
->tfm
668 || !(crypt_stat
->flags
& ECRYPTFS_STRUCT_INITIALIZED
));
669 if (unlikely(ecryptfs_verbosity
> 0)) {
670 ecryptfs_printk(KERN_DEBUG
, "Key size [%zd]; key:\n",
671 crypt_stat
->key_size
);
672 ecryptfs_dump_hex(crypt_stat
->key
,
673 crypt_stat
->key_size
);
676 init_completion(&ecr
.completion
);
678 mutex_lock(&crypt_stat
->cs_tfm_mutex
);
679 req
= ablkcipher_request_alloc(crypt_stat
->tfm
, GFP_NOFS
);
681 mutex_unlock(&crypt_stat
->cs_tfm_mutex
);
686 ablkcipher_request_set_callback(req
,
687 CRYPTO_TFM_REQ_MAY_BACKLOG
| CRYPTO_TFM_REQ_MAY_SLEEP
,
688 extent_crypt_complete
, &ecr
);
689 /* Consider doing this once, when the file is opened */
690 if (!(crypt_stat
->flags
& ECRYPTFS_KEY_SET
)) {
691 rc
= crypto_ablkcipher_setkey(crypt_stat
->tfm
, crypt_stat
->key
,
692 crypt_stat
->key_size
);
694 ecryptfs_printk(KERN_ERR
,
695 "Error setting key; rc = [%d]\n",
697 mutex_unlock(&crypt_stat
->cs_tfm_mutex
);
701 crypt_stat
->flags
|= ECRYPTFS_KEY_SET
;
703 mutex_unlock(&crypt_stat
->cs_tfm_mutex
);
704 ecryptfs_printk(KERN_DEBUG
, "Decrypting [%d] bytes.\n", size
);
705 ablkcipher_request_set_crypt(req
, src_sg
, dest_sg
, size
, iv
);
706 rc
= crypto_ablkcipher_decrypt(req
);
707 if (rc
== -EINPROGRESS
|| rc
== -EBUSY
) {
708 struct extent_crypt_result
*ecr
= req
->base
.data
;
710 wait_for_completion(&ecr
->completion
);
712 INIT_COMPLETION(ecr
->completion
);
715 ablkcipher_request_free(req
);
721 * ecryptfs_encrypt_page_offset
722 * @crypt_stat: The cryptographic context
723 * @dst_page: The page to encrypt into
724 * @dst_offset: The offset in the page to encrypt into
725 * @src_page: The page to encrypt from
726 * @src_offset: The offset in the page to encrypt from
727 * @size: The number of bytes to encrypt
728 * @iv: The initialization vector to use for the encryption
730 * Returns the number of bytes encrypted
733 ecryptfs_encrypt_page_offset(struct ecryptfs_crypt_stat
*crypt_stat
,
734 struct page
*dst_page
, int dst_offset
,
735 struct page
*src_page
, int src_offset
, int size
,
738 struct scatterlist src_sg
, dst_sg
;
740 sg_init_table(&src_sg
, 1);
741 sg_init_table(&dst_sg
, 1);
743 sg_set_page(&src_sg
, src_page
, size
, src_offset
);
744 sg_set_page(&dst_sg
, dst_page
, size
, dst_offset
);
745 return encrypt_scatterlist(crypt_stat
, &dst_sg
, &src_sg
, size
, iv
);
749 * ecryptfs_decrypt_page_offset
750 * @crypt_stat: The cryptographic context
751 * @dst_page: The page to decrypt into
752 * @dst_offset: The offset in the page to decrypt into
753 * @src_page: The page to decrypt from
754 * @src_offset: The offset in the page to decrypt from
755 * @size: The number of bytes to decrypt
756 * @iv: The initialization vector to use for the decryption
758 * Returns the number of bytes decrypted
761 ecryptfs_decrypt_page_offset(struct ecryptfs_crypt_stat
*crypt_stat
,
762 struct page
*dst_page
, int dst_offset
,
763 struct page
*src_page
, int src_offset
, int size
,
766 struct scatterlist src_sg
, dst_sg
;
768 sg_init_table(&src_sg
, 1);
769 sg_set_page(&src_sg
, src_page
, size
, src_offset
);
771 sg_init_table(&dst_sg
, 1);
772 sg_set_page(&dst_sg
, dst_page
, size
, dst_offset
);
774 return decrypt_scatterlist(crypt_stat
, &dst_sg
, &src_sg
, size
, iv
);
777 #define ECRYPTFS_MAX_SCATTERLIST_LEN 4
780 * ecryptfs_init_crypt_ctx
781 * @crypt_stat: Uninitialized crypt stats structure
783 * Initialize the crypto context.
785 * TODO: Performance: Keep a cache of initialized cipher contexts;
786 * only init if needed
788 int ecryptfs_init_crypt_ctx(struct ecryptfs_crypt_stat
*crypt_stat
)
793 if (!crypt_stat
->cipher
) {
794 ecryptfs_printk(KERN_ERR
, "No cipher specified\n");
797 ecryptfs_printk(KERN_DEBUG
,
798 "Initializing cipher [%s]; strlen = [%d]; "
799 "key_size_bits = [%zd]\n",
800 crypt_stat
->cipher
, (int)strlen(crypt_stat
->cipher
),
801 crypt_stat
->key_size
<< 3);
802 if (crypt_stat
->tfm
) {
806 mutex_lock(&crypt_stat
->cs_tfm_mutex
);
807 rc
= ecryptfs_crypto_api_algify_cipher_name(&full_alg_name
,
808 crypt_stat
->cipher
, "cbc");
811 crypt_stat
->tfm
= crypto_alloc_ablkcipher(full_alg_name
, 0, 0);
812 kfree(full_alg_name
);
813 if (IS_ERR(crypt_stat
->tfm
)) {
814 rc
= PTR_ERR(crypt_stat
->tfm
);
815 crypt_stat
->tfm
= NULL
;
816 ecryptfs_printk(KERN_ERR
, "cryptfs: init_crypt_ctx(): "
817 "Error initializing cipher [%s]\n",
821 crypto_ablkcipher_set_flags(crypt_stat
->tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
824 mutex_unlock(&crypt_stat
->cs_tfm_mutex
);
829 static void set_extent_mask_and_shift(struct ecryptfs_crypt_stat
*crypt_stat
)
833 crypt_stat
->extent_mask
= 0xFFFFFFFF;
834 crypt_stat
->extent_shift
= 0;
835 if (crypt_stat
->extent_size
== 0)
837 extent_size_tmp
= crypt_stat
->extent_size
;
838 while ((extent_size_tmp
& 0x01) == 0) {
839 extent_size_tmp
>>= 1;
840 crypt_stat
->extent_mask
<<= 1;
841 crypt_stat
->extent_shift
++;
845 void ecryptfs_set_default_sizes(struct ecryptfs_crypt_stat
*crypt_stat
)
847 /* Default values; may be overwritten as we are parsing the
849 crypt_stat
->extent_size
= ECRYPTFS_DEFAULT_EXTENT_SIZE
;
850 set_extent_mask_and_shift(crypt_stat
);
851 crypt_stat
->iv_bytes
= ECRYPTFS_DEFAULT_IV_BYTES
;
852 if (crypt_stat
->flags
& ECRYPTFS_METADATA_IN_XATTR
)
853 crypt_stat
->metadata_size
= ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE
;
855 if (PAGE_CACHE_SIZE
<= ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE
)
856 crypt_stat
->metadata_size
=
857 ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE
;
859 crypt_stat
->metadata_size
= PAGE_CACHE_SIZE
;
864 * ecryptfs_compute_root_iv
867 * On error, sets the root IV to all 0's.
869 int ecryptfs_compute_root_iv(struct ecryptfs_crypt_stat
*crypt_stat
)
872 char dst
[MD5_DIGEST_SIZE
];
874 BUG_ON(crypt_stat
->iv_bytes
> MD5_DIGEST_SIZE
);
875 BUG_ON(crypt_stat
->iv_bytes
<= 0);
876 if (!(crypt_stat
->flags
& ECRYPTFS_KEY_VALID
)) {
878 ecryptfs_printk(KERN_WARNING
, "Session key not valid; "
879 "cannot generate root IV\n");
882 rc
= ecryptfs_calculate_md5(dst
, crypt_stat
, crypt_stat
->key
,
883 crypt_stat
->key_size
);
885 ecryptfs_printk(KERN_WARNING
, "Error attempting to compute "
886 "MD5 while generating root IV\n");
889 memcpy(crypt_stat
->root_iv
, dst
, crypt_stat
->iv_bytes
);
892 memset(crypt_stat
->root_iv
, 0, crypt_stat
->iv_bytes
);
893 crypt_stat
->flags
|= ECRYPTFS_SECURITY_WARNING
;
898 static void ecryptfs_generate_new_key(struct ecryptfs_crypt_stat
*crypt_stat
)
900 get_random_bytes(crypt_stat
->key
, crypt_stat
->key_size
);
901 crypt_stat
->flags
|= ECRYPTFS_KEY_VALID
;
902 ecryptfs_compute_root_iv(crypt_stat
);
903 if (unlikely(ecryptfs_verbosity
> 0)) {
904 ecryptfs_printk(KERN_DEBUG
, "Generated new session key:\n");
905 ecryptfs_dump_hex(crypt_stat
->key
,
906 crypt_stat
->key_size
);
911 * ecryptfs_copy_mount_wide_flags_to_inode_flags
912 * @crypt_stat: The inode's cryptographic context
913 * @mount_crypt_stat: The mount point's cryptographic context
915 * This function propagates the mount-wide flags to individual inode
918 static void ecryptfs_copy_mount_wide_flags_to_inode_flags(
919 struct ecryptfs_crypt_stat
*crypt_stat
,
920 struct ecryptfs_mount_crypt_stat
*mount_crypt_stat
)
922 if (mount_crypt_stat
->flags
& ECRYPTFS_XATTR_METADATA_ENABLED
)
923 crypt_stat
->flags
|= ECRYPTFS_METADATA_IN_XATTR
;
924 if (mount_crypt_stat
->flags
& ECRYPTFS_ENCRYPTED_VIEW_ENABLED
)
925 crypt_stat
->flags
|= ECRYPTFS_VIEW_AS_ENCRYPTED
;
926 if (mount_crypt_stat
->flags
& ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES
) {
927 crypt_stat
->flags
|= ECRYPTFS_ENCRYPT_FILENAMES
;
928 if (mount_crypt_stat
->flags
929 & ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK
)
930 crypt_stat
->flags
|= ECRYPTFS_ENCFN_USE_MOUNT_FNEK
;
931 else if (mount_crypt_stat
->flags
932 & ECRYPTFS_GLOBAL_ENCFN_USE_FEK
)
933 crypt_stat
->flags
|= ECRYPTFS_ENCFN_USE_FEK
;
937 static int ecryptfs_copy_mount_wide_sigs_to_inode_sigs(
938 struct ecryptfs_crypt_stat
*crypt_stat
,
939 struct ecryptfs_mount_crypt_stat
*mount_crypt_stat
)
941 struct ecryptfs_global_auth_tok
*global_auth_tok
;
944 mutex_lock(&crypt_stat
->keysig_list_mutex
);
945 mutex_lock(&mount_crypt_stat
->global_auth_tok_list_mutex
);
947 list_for_each_entry(global_auth_tok
,
948 &mount_crypt_stat
->global_auth_tok_list
,
949 mount_crypt_stat_list
) {
950 if (global_auth_tok
->flags
& ECRYPTFS_AUTH_TOK_FNEK
)
952 rc
= ecryptfs_add_keysig(crypt_stat
, global_auth_tok
->sig
);
954 printk(KERN_ERR
"Error adding keysig; rc = [%d]\n", rc
);
960 mutex_unlock(&mount_crypt_stat
->global_auth_tok_list_mutex
);
961 mutex_unlock(&crypt_stat
->keysig_list_mutex
);
966 * ecryptfs_set_default_crypt_stat_vals
967 * @crypt_stat: The inode's cryptographic context
968 * @mount_crypt_stat: The mount point's cryptographic context
970 * Default values in the event that policy does not override them.
972 static void ecryptfs_set_default_crypt_stat_vals(
973 struct ecryptfs_crypt_stat
*crypt_stat
,
974 struct ecryptfs_mount_crypt_stat
*mount_crypt_stat
)
976 ecryptfs_copy_mount_wide_flags_to_inode_flags(crypt_stat
,
978 ecryptfs_set_default_sizes(crypt_stat
);
979 strcpy(crypt_stat
->cipher
, ECRYPTFS_DEFAULT_CIPHER
);
980 crypt_stat
->key_size
= ECRYPTFS_DEFAULT_KEY_BYTES
;
981 crypt_stat
->flags
&= ~(ECRYPTFS_KEY_VALID
);
982 crypt_stat
->file_version
= ECRYPTFS_FILE_VERSION
;
983 crypt_stat
->mount_crypt_stat
= mount_crypt_stat
;
987 * ecryptfs_new_file_context
988 * @ecryptfs_inode: The eCryptfs inode
990 * If the crypto context for the file has not yet been established,
991 * this is where we do that. Establishing a new crypto context
992 * involves the following decisions:
993 * - What cipher to use?
994 * - What set of authentication tokens to use?
995 * Here we just worry about getting enough information into the
996 * authentication tokens so that we know that they are available.
997 * We associate the available authentication tokens with the new file
998 * via the set of signatures in the crypt_stat struct. Later, when
999 * the headers are actually written out, we may again defer to
1000 * userspace to perform the encryption of the session key; for the
1001 * foreseeable future, this will be the case with public key packets.
1003 * Returns zero on success; non-zero otherwise
1005 int ecryptfs_new_file_context(struct inode
*ecryptfs_inode
)
1007 struct ecryptfs_crypt_stat
*crypt_stat
=
1008 &ecryptfs_inode_to_private(ecryptfs_inode
)->crypt_stat
;
1009 struct ecryptfs_mount_crypt_stat
*mount_crypt_stat
=
1010 &ecryptfs_superblock_to_private(
1011 ecryptfs_inode
->i_sb
)->mount_crypt_stat
;
1012 int cipher_name_len
;
1015 ecryptfs_set_default_crypt_stat_vals(crypt_stat
, mount_crypt_stat
);
1016 crypt_stat
->flags
|= (ECRYPTFS_ENCRYPTED
| ECRYPTFS_KEY_VALID
);
1017 ecryptfs_copy_mount_wide_flags_to_inode_flags(crypt_stat
,
1019 rc
= ecryptfs_copy_mount_wide_sigs_to_inode_sigs(crypt_stat
,
1022 printk(KERN_ERR
"Error attempting to copy mount-wide key sigs "
1023 "to the inode key sigs; rc = [%d]\n", rc
);
1027 strlen(mount_crypt_stat
->global_default_cipher_name
);
1028 memcpy(crypt_stat
->cipher
,
1029 mount_crypt_stat
->global_default_cipher_name
,
1031 crypt_stat
->cipher
[cipher_name_len
] = '\0';
1032 crypt_stat
->key_size
=
1033 mount_crypt_stat
->global_default_cipher_key_size
;
1034 ecryptfs_generate_new_key(crypt_stat
);
1035 rc
= ecryptfs_init_crypt_ctx(crypt_stat
);
1037 ecryptfs_printk(KERN_ERR
, "Error initializing cryptographic "
1038 "context for cipher [%s]: rc = [%d]\n",
1039 crypt_stat
->cipher
, rc
);
1045 * ecryptfs_validate_marker - check for the ecryptfs marker
1046 * @data: The data block in which to check
1048 * Returns zero if marker found; -EINVAL if not found
1050 static int ecryptfs_validate_marker(char *data
)
1054 m_1
= get_unaligned_be32(data
);
1055 m_2
= get_unaligned_be32(data
+ 4);
1056 if ((m_1
^ MAGIC_ECRYPTFS_MARKER
) == m_2
)
1058 ecryptfs_printk(KERN_DEBUG
, "m_1 = [0x%.8x]; m_2 = [0x%.8x]; "
1059 "MAGIC_ECRYPTFS_MARKER = [0x%.8x]\n", m_1
, m_2
,
1060 MAGIC_ECRYPTFS_MARKER
);
1061 ecryptfs_printk(KERN_DEBUG
, "(m_1 ^ MAGIC_ECRYPTFS_MARKER) = "
1062 "[0x%.8x]\n", (m_1
^ MAGIC_ECRYPTFS_MARKER
));
1066 struct ecryptfs_flag_map_elem
{
1071 /* Add support for additional flags by adding elements here. */
1072 static struct ecryptfs_flag_map_elem ecryptfs_flag_map
[] = {
1073 {0x00000001, ECRYPTFS_ENABLE_HMAC
},
1074 {0x00000002, ECRYPTFS_ENCRYPTED
},
1075 {0x00000004, ECRYPTFS_METADATA_IN_XATTR
},
1076 {0x00000008, ECRYPTFS_ENCRYPT_FILENAMES
}
1080 * ecryptfs_process_flags
1081 * @crypt_stat: The cryptographic context
1082 * @page_virt: Source data to be parsed
1083 * @bytes_read: Updated with the number of bytes read
1085 * Returns zero on success; non-zero if the flag set is invalid
1087 static int ecryptfs_process_flags(struct ecryptfs_crypt_stat
*crypt_stat
,
1088 char *page_virt
, int *bytes_read
)
1094 flags
= get_unaligned_be32(page_virt
);
1095 for (i
= 0; i
< ((sizeof(ecryptfs_flag_map
)
1096 / sizeof(struct ecryptfs_flag_map_elem
))); i
++)
1097 if (flags
& ecryptfs_flag_map
[i
].file_flag
) {
1098 crypt_stat
->flags
|= ecryptfs_flag_map
[i
].local_flag
;
1100 crypt_stat
->flags
&= ~(ecryptfs_flag_map
[i
].local_flag
);
1101 /* Version is in top 8 bits of the 32-bit flag vector */
1102 crypt_stat
->file_version
= ((flags
>> 24) & 0xFF);
1108 * write_ecryptfs_marker
1109 * @page_virt: The pointer to in a page to begin writing the marker
1110 * @written: Number of bytes written
1112 * Marker = 0x3c81b7f5
1114 static void write_ecryptfs_marker(char *page_virt
, size_t *written
)
1118 get_random_bytes(&m_1
, (MAGIC_ECRYPTFS_MARKER_SIZE_BYTES
/ 2));
1119 m_2
= (m_1
^ MAGIC_ECRYPTFS_MARKER
);
1120 put_unaligned_be32(m_1
, page_virt
);
1121 page_virt
+= (MAGIC_ECRYPTFS_MARKER_SIZE_BYTES
/ 2);
1122 put_unaligned_be32(m_2
, page_virt
);
1123 (*written
) = MAGIC_ECRYPTFS_MARKER_SIZE_BYTES
;
1126 void ecryptfs_write_crypt_stat_flags(char *page_virt
,
1127 struct ecryptfs_crypt_stat
*crypt_stat
,
1133 for (i
= 0; i
< ((sizeof(ecryptfs_flag_map
)
1134 / sizeof(struct ecryptfs_flag_map_elem
))); i
++)
1135 if (crypt_stat
->flags
& ecryptfs_flag_map
[i
].local_flag
)
1136 flags
|= ecryptfs_flag_map
[i
].file_flag
;
1137 /* Version is in top 8 bits of the 32-bit flag vector */
1138 flags
|= ((((u8
)crypt_stat
->file_version
) << 24) & 0xFF000000);
1139 put_unaligned_be32(flags
, page_virt
);
1143 struct ecryptfs_cipher_code_str_map_elem
{
1144 char cipher_str
[16];
1148 /* Add support for additional ciphers by adding elements here. The
1149 * cipher_code is whatever OpenPGP applicatoins use to identify the
1150 * ciphers. List in order of probability. */
1151 static struct ecryptfs_cipher_code_str_map_elem
1152 ecryptfs_cipher_code_str_map
[] = {
1153 {"aes",RFC2440_CIPHER_AES_128
},
1154 {"blowfish", RFC2440_CIPHER_BLOWFISH
},
1155 {"des3_ede", RFC2440_CIPHER_DES3_EDE
},
1156 {"cast5", RFC2440_CIPHER_CAST_5
},
1157 {"twofish", RFC2440_CIPHER_TWOFISH
},
1158 {"cast6", RFC2440_CIPHER_CAST_6
},
1159 {"aes", RFC2440_CIPHER_AES_192
},
1160 {"aes", RFC2440_CIPHER_AES_256
}
1164 * ecryptfs_code_for_cipher_string
1165 * @cipher_name: The string alias for the cipher
1166 * @key_bytes: Length of key in bytes; used for AES code selection
1168 * Returns zero on no match, or the cipher code on match
1170 u8
ecryptfs_code_for_cipher_string(char *cipher_name
, size_t key_bytes
)
1174 struct ecryptfs_cipher_code_str_map_elem
*map
=
1175 ecryptfs_cipher_code_str_map
;
1177 if (strcmp(cipher_name
, "aes") == 0) {
1178 switch (key_bytes
) {
1180 code
= RFC2440_CIPHER_AES_128
;
1183 code
= RFC2440_CIPHER_AES_192
;
1186 code
= RFC2440_CIPHER_AES_256
;
1189 for (i
= 0; i
< ARRAY_SIZE(ecryptfs_cipher_code_str_map
); i
++)
1190 if (strcmp(cipher_name
, map
[i
].cipher_str
) == 0) {
1191 code
= map
[i
].cipher_code
;
1199 * ecryptfs_cipher_code_to_string
1200 * @str: Destination to write out the cipher name
1201 * @cipher_code: The code to convert to cipher name string
1203 * Returns zero on success
1205 int ecryptfs_cipher_code_to_string(char *str
, u8 cipher_code
)
1211 for (i
= 0; i
< ARRAY_SIZE(ecryptfs_cipher_code_str_map
); i
++)
1212 if (cipher_code
== ecryptfs_cipher_code_str_map
[i
].cipher_code
)
1213 strcpy(str
, ecryptfs_cipher_code_str_map
[i
].cipher_str
);
1214 if (str
[0] == '\0') {
1215 ecryptfs_printk(KERN_WARNING
, "Cipher code not recognized: "
1216 "[%d]\n", cipher_code
);
1222 int ecryptfs_read_and_validate_header_region(struct inode
*inode
)
1224 u8 file_size
[ECRYPTFS_SIZE_AND_MARKER_BYTES
];
1225 u8
*marker
= file_size
+ ECRYPTFS_FILE_SIZE_BYTES
;
1228 rc
= ecryptfs_read_lower(file_size
, 0, ECRYPTFS_SIZE_AND_MARKER_BYTES
,
1230 if (rc
< ECRYPTFS_SIZE_AND_MARKER_BYTES
)
1231 return rc
>= 0 ? -EINVAL
: rc
;
1232 rc
= ecryptfs_validate_marker(marker
);
1234 ecryptfs_i_size_init(file_size
, inode
);
1239 ecryptfs_write_header_metadata(char *virt
,
1240 struct ecryptfs_crypt_stat
*crypt_stat
,
1243 u32 header_extent_size
;
1244 u16 num_header_extents_at_front
;
1246 header_extent_size
= (u32
)crypt_stat
->extent_size
;
1247 num_header_extents_at_front
=
1248 (u16
)(crypt_stat
->metadata_size
/ crypt_stat
->extent_size
);
1249 put_unaligned_be32(header_extent_size
, virt
);
1251 put_unaligned_be16(num_header_extents_at_front
, virt
);
1255 struct kmem_cache
*ecryptfs_header_cache
;
1258 * ecryptfs_write_headers_virt
1259 * @page_virt: The virtual address to write the headers to
1260 * @max: The size of memory allocated at page_virt
1261 * @size: Set to the number of bytes written by this function
1262 * @crypt_stat: The cryptographic context
1263 * @ecryptfs_dentry: The eCryptfs dentry
1268 * Octets 0-7: Unencrypted file size (big-endian)
1269 * Octets 8-15: eCryptfs special marker
1270 * Octets 16-19: Flags
1271 * Octet 16: File format version number (between 0 and 255)
1272 * Octets 17-18: Reserved
1273 * Octet 19: Bit 1 (lsb): Reserved
1275 * Bits 3-8: Reserved
1276 * Octets 20-23: Header extent size (big-endian)
1277 * Octets 24-25: Number of header extents at front of file
1279 * Octet 26: Begin RFC 2440 authentication token packet set
1281 * Lower data (CBC encrypted)
1283 * Lower data (CBC encrypted)
1286 * Returns zero on success
1288 static int ecryptfs_write_headers_virt(char *page_virt
, size_t max
,
1290 struct ecryptfs_crypt_stat
*crypt_stat
,
1291 struct dentry
*ecryptfs_dentry
)
1297 offset
= ECRYPTFS_FILE_SIZE_BYTES
;
1298 write_ecryptfs_marker((page_virt
+ offset
), &written
);
1300 ecryptfs_write_crypt_stat_flags((page_virt
+ offset
), crypt_stat
,
1303 ecryptfs_write_header_metadata((page_virt
+ offset
), crypt_stat
,
1306 rc
= ecryptfs_generate_key_packet_set((page_virt
+ offset
), crypt_stat
,
1307 ecryptfs_dentry
, &written
,
1310 ecryptfs_printk(KERN_WARNING
, "Error generating key packet "
1311 "set; rc = [%d]\n", rc
);
1320 ecryptfs_write_metadata_to_contents(struct inode
*ecryptfs_inode
,
1321 char *virt
, size_t virt_len
)
1325 rc
= ecryptfs_write_lower(ecryptfs_inode
, virt
,
1328 printk(KERN_ERR
"%s: Error attempting to write header "
1329 "information to lower file; rc = [%d]\n", __func__
, rc
);
1336 ecryptfs_write_metadata_to_xattr(struct dentry
*ecryptfs_dentry
,
1337 char *page_virt
, size_t size
)
1341 rc
= ecryptfs_setxattr(ecryptfs_dentry
, ECRYPTFS_XATTR_NAME
, page_virt
,
1346 static unsigned long ecryptfs_get_zeroed_pages(gfp_t gfp_mask
,
1351 page
= alloc_pages(gfp_mask
| __GFP_ZERO
, order
);
1353 return (unsigned long) page_address(page
);
1358 * ecryptfs_write_metadata
1359 * @ecryptfs_dentry: The eCryptfs dentry, which should be negative
1360 * @ecryptfs_inode: The newly created eCryptfs inode
1362 * Write the file headers out. This will likely involve a userspace
1363 * callout, in which the session key is encrypted with one or more
1364 * public keys and/or the passphrase necessary to do the encryption is
1365 * retrieved via a prompt. Exactly what happens at this point should
1366 * be policy-dependent.
1368 * Returns zero on success; non-zero on error
1370 int ecryptfs_write_metadata(struct dentry
*ecryptfs_dentry
,
1371 struct inode
*ecryptfs_inode
)
1373 struct ecryptfs_crypt_stat
*crypt_stat
=
1374 &ecryptfs_inode_to_private(ecryptfs_inode
)->crypt_stat
;
1381 if (likely(crypt_stat
->flags
& ECRYPTFS_ENCRYPTED
)) {
1382 if (!(crypt_stat
->flags
& ECRYPTFS_KEY_VALID
)) {
1383 printk(KERN_ERR
"Key is invalid; bailing out\n");
1388 printk(KERN_WARNING
"%s: Encrypted flag not set\n",
1393 virt_len
= crypt_stat
->metadata_size
;
1394 order
= get_order(virt_len
);
1395 /* Released in this function */
1396 virt
= (char *)ecryptfs_get_zeroed_pages(GFP_KERNEL
, order
);
1398 printk(KERN_ERR
"%s: Out of memory\n", __func__
);
1402 /* Zeroed page ensures the in-header unencrypted i_size is set to 0 */
1403 rc
= ecryptfs_write_headers_virt(virt
, virt_len
, &size
, crypt_stat
,
1406 printk(KERN_ERR
"%s: Error whilst writing headers; rc = [%d]\n",
1410 if (crypt_stat
->flags
& ECRYPTFS_METADATA_IN_XATTR
)
1411 rc
= ecryptfs_write_metadata_to_xattr(ecryptfs_dentry
, virt
,
1414 rc
= ecryptfs_write_metadata_to_contents(ecryptfs_inode
, virt
,
1417 printk(KERN_ERR
"%s: Error writing metadata out to lower file; "
1418 "rc = [%d]\n", __func__
, rc
);
1422 free_pages((unsigned long)virt
, order
);
1427 #define ECRYPTFS_DONT_VALIDATE_HEADER_SIZE 0
1428 #define ECRYPTFS_VALIDATE_HEADER_SIZE 1
1429 static int parse_header_metadata(struct ecryptfs_crypt_stat
*crypt_stat
,
1430 char *virt
, int *bytes_read
,
1431 int validate_header_size
)
1434 u32 header_extent_size
;
1435 u16 num_header_extents_at_front
;
1437 header_extent_size
= get_unaligned_be32(virt
);
1438 virt
+= sizeof(__be32
);
1439 num_header_extents_at_front
= get_unaligned_be16(virt
);
1440 crypt_stat
->metadata_size
= (((size_t)num_header_extents_at_front
1441 * (size_t)header_extent_size
));
1442 (*bytes_read
) = (sizeof(__be32
) + sizeof(__be16
));
1443 if ((validate_header_size
== ECRYPTFS_VALIDATE_HEADER_SIZE
)
1444 && (crypt_stat
->metadata_size
1445 < ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE
)) {
1447 printk(KERN_WARNING
"Invalid header size: [%zd]\n",
1448 crypt_stat
->metadata_size
);
1454 * set_default_header_data
1455 * @crypt_stat: The cryptographic context
1457 * For version 0 file format; this function is only for backwards
1458 * compatibility for files created with the prior versions of
1461 static void set_default_header_data(struct ecryptfs_crypt_stat
*crypt_stat
)
1463 crypt_stat
->metadata_size
= ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE
;
1466 void ecryptfs_i_size_init(const char *page_virt
, struct inode
*inode
)
1468 struct ecryptfs_mount_crypt_stat
*mount_crypt_stat
;
1469 struct ecryptfs_crypt_stat
*crypt_stat
;
1472 crypt_stat
= &ecryptfs_inode_to_private(inode
)->crypt_stat
;
1474 &ecryptfs_superblock_to_private(inode
->i_sb
)->mount_crypt_stat
;
1475 if (mount_crypt_stat
->flags
& ECRYPTFS_ENCRYPTED_VIEW_ENABLED
) {
1476 file_size
= i_size_read(ecryptfs_inode_to_lower(inode
));
1477 if (crypt_stat
->flags
& ECRYPTFS_METADATA_IN_XATTR
)
1478 file_size
+= crypt_stat
->metadata_size
;
1480 file_size
= get_unaligned_be64(page_virt
);
1481 i_size_write(inode
, (loff_t
)file_size
);
1482 crypt_stat
->flags
|= ECRYPTFS_I_SIZE_INITIALIZED
;
1486 * ecryptfs_read_headers_virt
1487 * @page_virt: The virtual address into which to read the headers
1488 * @crypt_stat: The cryptographic context
1489 * @ecryptfs_dentry: The eCryptfs dentry
1490 * @validate_header_size: Whether to validate the header size while reading
1492 * Read/parse the header data. The header format is detailed in the
1493 * comment block for the ecryptfs_write_headers_virt() function.
1495 * Returns zero on success
1497 static int ecryptfs_read_headers_virt(char *page_virt
,
1498 struct ecryptfs_crypt_stat
*crypt_stat
,
1499 struct dentry
*ecryptfs_dentry
,
1500 int validate_header_size
)
1506 ecryptfs_set_default_sizes(crypt_stat
);
1507 crypt_stat
->mount_crypt_stat
= &ecryptfs_superblock_to_private(
1508 ecryptfs_dentry
->d_sb
)->mount_crypt_stat
;
1509 offset
= ECRYPTFS_FILE_SIZE_BYTES
;
1510 rc
= ecryptfs_validate_marker(page_virt
+ offset
);
1513 if (!(crypt_stat
->flags
& ECRYPTFS_I_SIZE_INITIALIZED
))
1514 ecryptfs_i_size_init(page_virt
, ecryptfs_dentry
->d_inode
);
1515 offset
+= MAGIC_ECRYPTFS_MARKER_SIZE_BYTES
;
1516 rc
= ecryptfs_process_flags(crypt_stat
, (page_virt
+ offset
),
1519 ecryptfs_printk(KERN_WARNING
, "Error processing flags\n");
1522 if (crypt_stat
->file_version
> ECRYPTFS_SUPPORTED_FILE_VERSION
) {
1523 ecryptfs_printk(KERN_WARNING
, "File version is [%d]; only "
1524 "file version [%d] is supported by this "
1525 "version of eCryptfs\n",
1526 crypt_stat
->file_version
,
1527 ECRYPTFS_SUPPORTED_FILE_VERSION
);
1531 offset
+= bytes_read
;
1532 if (crypt_stat
->file_version
>= 1) {
1533 rc
= parse_header_metadata(crypt_stat
, (page_virt
+ offset
),
1534 &bytes_read
, validate_header_size
);
1536 ecryptfs_printk(KERN_WARNING
, "Error reading header "
1537 "metadata; rc = [%d]\n", rc
);
1539 offset
+= bytes_read
;
1541 set_default_header_data(crypt_stat
);
1542 rc
= ecryptfs_parse_packet_set(crypt_stat
, (page_virt
+ offset
),
1549 * ecryptfs_read_xattr_region
1550 * @page_virt: The vitual address into which to read the xattr data
1551 * @ecryptfs_inode: The eCryptfs inode
1553 * Attempts to read the crypto metadata from the extended attribute
1554 * region of the lower file.
1556 * Returns zero on success; non-zero on error
1558 int ecryptfs_read_xattr_region(char *page_virt
, struct inode
*ecryptfs_inode
)
1560 struct dentry
*lower_dentry
=
1561 ecryptfs_inode_to_private(ecryptfs_inode
)->lower_file
->f_dentry
;
1565 size
= ecryptfs_getxattr_lower(lower_dentry
, ECRYPTFS_XATTR_NAME
,
1566 page_virt
, ECRYPTFS_DEFAULT_EXTENT_SIZE
);
1568 if (unlikely(ecryptfs_verbosity
> 0))
1569 printk(KERN_INFO
"Error attempting to read the [%s] "
1570 "xattr from the lower file; return value = "
1571 "[%zd]\n", ECRYPTFS_XATTR_NAME
, size
);
1579 int ecryptfs_read_and_validate_xattr_region(struct dentry
*dentry
,
1580 struct inode
*inode
)
1582 u8 file_size
[ECRYPTFS_SIZE_AND_MARKER_BYTES
];
1583 u8
*marker
= file_size
+ ECRYPTFS_FILE_SIZE_BYTES
;
1586 rc
= ecryptfs_getxattr_lower(ecryptfs_dentry_to_lower(dentry
),
1587 ECRYPTFS_XATTR_NAME
, file_size
,
1588 ECRYPTFS_SIZE_AND_MARKER_BYTES
);
1589 if (rc
< ECRYPTFS_SIZE_AND_MARKER_BYTES
)
1590 return rc
>= 0 ? -EINVAL
: rc
;
1591 rc
= ecryptfs_validate_marker(marker
);
1593 ecryptfs_i_size_init(file_size
, inode
);
1598 * ecryptfs_read_metadata
1600 * Common entry point for reading file metadata. From here, we could
1601 * retrieve the header information from the header region of the file,
1602 * the xattr region of the file, or some other repostory that is
1603 * stored separately from the file itself. The current implementation
1604 * supports retrieving the metadata information from the file contents
1605 * and from the xattr region.
1607 * Returns zero if valid headers found and parsed; non-zero otherwise
1609 int ecryptfs_read_metadata(struct dentry
*ecryptfs_dentry
)
1613 struct inode
*ecryptfs_inode
= ecryptfs_dentry
->d_inode
;
1614 struct ecryptfs_crypt_stat
*crypt_stat
=
1615 &ecryptfs_inode_to_private(ecryptfs_inode
)->crypt_stat
;
1616 struct ecryptfs_mount_crypt_stat
*mount_crypt_stat
=
1617 &ecryptfs_superblock_to_private(
1618 ecryptfs_dentry
->d_sb
)->mount_crypt_stat
;
1620 ecryptfs_copy_mount_wide_flags_to_inode_flags(crypt_stat
,
1622 /* Read the first page from the underlying file */
1623 page_virt
= kmem_cache_alloc(ecryptfs_header_cache
, GFP_USER
);
1626 printk(KERN_ERR
"%s: Unable to allocate page_virt\n",
1630 rc
= ecryptfs_read_lower(page_virt
, 0, crypt_stat
->extent_size
,
1633 rc
= ecryptfs_read_headers_virt(page_virt
, crypt_stat
,
1635 ECRYPTFS_VALIDATE_HEADER_SIZE
);
1637 /* metadata is not in the file header, so try xattrs */
1638 memset(page_virt
, 0, PAGE_CACHE_SIZE
);
1639 rc
= ecryptfs_read_xattr_region(page_virt
, ecryptfs_inode
);
1641 printk(KERN_DEBUG
"Valid eCryptfs headers not found in "
1642 "file header region or xattr region, inode %lu\n",
1643 ecryptfs_inode
->i_ino
);
1647 rc
= ecryptfs_read_headers_virt(page_virt
, crypt_stat
,
1649 ECRYPTFS_DONT_VALIDATE_HEADER_SIZE
);
1651 printk(KERN_DEBUG
"Valid eCryptfs headers not found in "
1652 "file xattr region either, inode %lu\n",
1653 ecryptfs_inode
->i_ino
);
1656 if (crypt_stat
->mount_crypt_stat
->flags
1657 & ECRYPTFS_XATTR_METADATA_ENABLED
) {
1658 crypt_stat
->flags
|= ECRYPTFS_METADATA_IN_XATTR
;
1660 printk(KERN_WARNING
"Attempt to access file with "
1661 "crypto metadata only in the extended attribute "
1662 "region, but eCryptfs was mounted without "
1663 "xattr support enabled. eCryptfs will not treat "
1664 "this like an encrypted file, inode %lu\n",
1665 ecryptfs_inode
->i_ino
);
1671 memset(page_virt
, 0, PAGE_CACHE_SIZE
);
1672 kmem_cache_free(ecryptfs_header_cache
, page_virt
);
1678 * ecryptfs_encrypt_filename - encrypt filename
1680 * CBC-encrypts the filename. We do not want to encrypt the same
1681 * filename with the same key and IV, which may happen with hard
1682 * links, so we prepend random bits to each filename.
1684 * Returns zero on success; non-zero otherwise
1687 ecryptfs_encrypt_filename(struct ecryptfs_filename
*filename
,
1688 struct ecryptfs_crypt_stat
*crypt_stat
,
1689 struct ecryptfs_mount_crypt_stat
*mount_crypt_stat
)
1693 filename
->encrypted_filename
= NULL
;
1694 filename
->encrypted_filename_size
= 0;
1695 if ((crypt_stat
&& (crypt_stat
->flags
& ECRYPTFS_ENCFN_USE_MOUNT_FNEK
))
1696 || (mount_crypt_stat
&& (mount_crypt_stat
->flags
1697 & ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK
))) {
1699 size_t remaining_bytes
;
1701 rc
= ecryptfs_write_tag_70_packet(
1703 &filename
->encrypted_filename_size
,
1704 mount_crypt_stat
, NULL
,
1705 filename
->filename_size
);
1707 printk(KERN_ERR
"%s: Error attempting to get packet "
1708 "size for tag 72; rc = [%d]\n", __func__
,
1710 filename
->encrypted_filename_size
= 0;
1713 filename
->encrypted_filename
=
1714 kmalloc(filename
->encrypted_filename_size
, GFP_KERNEL
);
1715 if (!filename
->encrypted_filename
) {
1716 printk(KERN_ERR
"%s: Out of memory whilst attempting "
1717 "to kmalloc [%zd] bytes\n", __func__
,
1718 filename
->encrypted_filename_size
);
1722 remaining_bytes
= filename
->encrypted_filename_size
;
1723 rc
= ecryptfs_write_tag_70_packet(filename
->encrypted_filename
,
1728 filename
->filename_size
);
1730 printk(KERN_ERR
"%s: Error attempting to generate "
1731 "tag 70 packet; rc = [%d]\n", __func__
,
1733 kfree(filename
->encrypted_filename
);
1734 filename
->encrypted_filename
= NULL
;
1735 filename
->encrypted_filename_size
= 0;
1738 filename
->encrypted_filename_size
= packet_size
;
1740 printk(KERN_ERR
"%s: No support for requested filename "
1741 "encryption method in this release\n", __func__
);
1749 static int ecryptfs_copy_filename(char **copied_name
, size_t *copied_name_size
,
1750 const char *name
, size_t name_size
)
1754 (*copied_name
) = kmalloc((name_size
+ 1), GFP_KERNEL
);
1755 if (!(*copied_name
)) {
1759 memcpy((void *)(*copied_name
), (void *)name
, name_size
);
1760 (*copied_name
)[(name_size
)] = '\0'; /* Only for convenience
1761 * in printing out the
1764 (*copied_name_size
) = name_size
;
1770 * ecryptfs_process_key_cipher - Perform key cipher initialization.
1771 * @key_tfm: Crypto context for key material, set by this function
1772 * @cipher_name: Name of the cipher
1773 * @key_size: Size of the key in bytes
1775 * Returns zero on success. Any crypto_tfm structs allocated here
1776 * should be released by other functions, such as on a superblock put
1777 * event, regardless of whether this function succeeds for fails.
1780 ecryptfs_process_key_cipher(struct crypto_blkcipher
**key_tfm
,
1781 char *cipher_name
, size_t *key_size
)
1783 char dummy_key
[ECRYPTFS_MAX_KEY_BYTES
];
1784 char *full_alg_name
= NULL
;
1788 if (*key_size
> ECRYPTFS_MAX_KEY_BYTES
) {
1790 printk(KERN_ERR
"Requested key size is [%zd] bytes; maximum "
1791 "allowable is [%d]\n", *key_size
, ECRYPTFS_MAX_KEY_BYTES
);
1794 rc
= ecryptfs_crypto_api_algify_cipher_name(&full_alg_name
, cipher_name
,
1798 *key_tfm
= crypto_alloc_blkcipher(full_alg_name
, 0, CRYPTO_ALG_ASYNC
);
1799 if (IS_ERR(*key_tfm
)) {
1800 rc
= PTR_ERR(*key_tfm
);
1801 printk(KERN_ERR
"Unable to allocate crypto cipher with name "
1802 "[%s]; rc = [%d]\n", full_alg_name
, rc
);
1805 crypto_blkcipher_set_flags(*key_tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
1806 if (*key_size
== 0) {
1807 struct blkcipher_alg
*alg
= crypto_blkcipher_alg(*key_tfm
);
1809 *key_size
= alg
->max_keysize
;
1811 get_random_bytes(dummy_key
, *key_size
);
1812 rc
= crypto_blkcipher_setkey(*key_tfm
, dummy_key
, *key_size
);
1814 printk(KERN_ERR
"Error attempting to set key of size [%zd] for "
1815 "cipher [%s]; rc = [%d]\n", *key_size
, full_alg_name
,
1821 kfree(full_alg_name
);
1825 struct kmem_cache
*ecryptfs_key_tfm_cache
;
1826 static struct list_head key_tfm_list
;
1827 struct mutex key_tfm_list_mutex
;
1829 int __init
ecryptfs_init_crypto(void)
1831 mutex_init(&key_tfm_list_mutex
);
1832 INIT_LIST_HEAD(&key_tfm_list
);
1837 * ecryptfs_destroy_crypto - free all cached key_tfms on key_tfm_list
1839 * Called only at module unload time
1841 int ecryptfs_destroy_crypto(void)
1843 struct ecryptfs_key_tfm
*key_tfm
, *key_tfm_tmp
;
1845 mutex_lock(&key_tfm_list_mutex
);
1846 list_for_each_entry_safe(key_tfm
, key_tfm_tmp
, &key_tfm_list
,
1848 list_del(&key_tfm
->key_tfm_list
);
1849 if (key_tfm
->key_tfm
)
1850 crypto_free_blkcipher(key_tfm
->key_tfm
);
1851 kmem_cache_free(ecryptfs_key_tfm_cache
, key_tfm
);
1853 mutex_unlock(&key_tfm_list_mutex
);
1858 ecryptfs_add_new_key_tfm(struct ecryptfs_key_tfm
**key_tfm
, char *cipher_name
,
1861 struct ecryptfs_key_tfm
*tmp_tfm
;
1864 BUG_ON(!mutex_is_locked(&key_tfm_list_mutex
));
1866 tmp_tfm
= kmem_cache_alloc(ecryptfs_key_tfm_cache
, GFP_KERNEL
);
1867 if (key_tfm
!= NULL
)
1868 (*key_tfm
) = tmp_tfm
;
1871 printk(KERN_ERR
"Error attempting to allocate from "
1872 "ecryptfs_key_tfm_cache\n");
1875 mutex_init(&tmp_tfm
->key_tfm_mutex
);
1876 strncpy(tmp_tfm
->cipher_name
, cipher_name
,
1877 ECRYPTFS_MAX_CIPHER_NAME_SIZE
);
1878 tmp_tfm
->cipher_name
[ECRYPTFS_MAX_CIPHER_NAME_SIZE
] = '\0';
1879 tmp_tfm
->key_size
= key_size
;
1880 rc
= ecryptfs_process_key_cipher(&tmp_tfm
->key_tfm
,
1881 tmp_tfm
->cipher_name
,
1882 &tmp_tfm
->key_size
);
1884 printk(KERN_ERR
"Error attempting to initialize key TFM "
1885 "cipher with name = [%s]; rc = [%d]\n",
1886 tmp_tfm
->cipher_name
, rc
);
1887 kmem_cache_free(ecryptfs_key_tfm_cache
, tmp_tfm
);
1888 if (key_tfm
!= NULL
)
1892 list_add(&tmp_tfm
->key_tfm_list
, &key_tfm_list
);
1898 * ecryptfs_tfm_exists - Search for existing tfm for cipher_name.
1899 * @cipher_name: the name of the cipher to search for
1900 * @key_tfm: set to corresponding tfm if found
1902 * Searches for cached key_tfm matching @cipher_name
1903 * Must be called with &key_tfm_list_mutex held
1904 * Returns 1 if found, with @key_tfm set
1905 * Returns 0 if not found, with @key_tfm set to NULL
1907 int ecryptfs_tfm_exists(char *cipher_name
, struct ecryptfs_key_tfm
**key_tfm
)
1909 struct ecryptfs_key_tfm
*tmp_key_tfm
;
1911 BUG_ON(!mutex_is_locked(&key_tfm_list_mutex
));
1913 list_for_each_entry(tmp_key_tfm
, &key_tfm_list
, key_tfm_list
) {
1914 if (strcmp(tmp_key_tfm
->cipher_name
, cipher_name
) == 0) {
1916 (*key_tfm
) = tmp_key_tfm
;
1926 * ecryptfs_get_tfm_and_mutex_for_cipher_name
1928 * @tfm: set to cached tfm found, or new tfm created
1929 * @tfm_mutex: set to mutex for cached tfm found, or new tfm created
1930 * @cipher_name: the name of the cipher to search for and/or add
1932 * Sets pointers to @tfm & @tfm_mutex matching @cipher_name.
1933 * Searches for cached item first, and creates new if not found.
1934 * Returns 0 on success, non-zero if adding new cipher failed
1936 int ecryptfs_get_tfm_and_mutex_for_cipher_name(struct crypto_blkcipher
**tfm
,
1937 struct mutex
**tfm_mutex
,
1940 struct ecryptfs_key_tfm
*key_tfm
;
1944 (*tfm_mutex
) = NULL
;
1946 mutex_lock(&key_tfm_list_mutex
);
1947 if (!ecryptfs_tfm_exists(cipher_name
, &key_tfm
)) {
1948 rc
= ecryptfs_add_new_key_tfm(&key_tfm
, cipher_name
, 0);
1950 printk(KERN_ERR
"Error adding new key_tfm to list; "
1955 (*tfm
) = key_tfm
->key_tfm
;
1956 (*tfm_mutex
) = &key_tfm
->key_tfm_mutex
;
1958 mutex_unlock(&key_tfm_list_mutex
);
1962 /* 64 characters forming a 6-bit target field */
1963 static unsigned char *portable_filename_chars
= ("-.0123456789ABCD"
1966 "klmnopqrstuvwxyz");
1968 /* We could either offset on every reverse map or just pad some 0x00's
1969 * at the front here */
1970 static const unsigned char filename_rev_map
[256] = {
1971 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 7 */
1972 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 15 */
1973 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 23 */
1974 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 31 */
1975 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 39 */
1976 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, /* 47 */
1977 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, /* 55 */
1978 0x0A, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 63 */
1979 0x00, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, /* 71 */
1980 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, /* 79 */
1981 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, /* 87 */
1982 0x23, 0x24, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, /* 95 */
1983 0x00, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, /* 103 */
1984 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, /* 111 */
1985 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, /* 119 */
1986 0x3D, 0x3E, 0x3F /* 123 - 255 initialized to 0x00 */
1990 * ecryptfs_encode_for_filename
1991 * @dst: Destination location for encoded filename
1992 * @dst_size: Size of the encoded filename in bytes
1993 * @src: Source location for the filename to encode
1994 * @src_size: Size of the source in bytes
1996 static void ecryptfs_encode_for_filename(unsigned char *dst
, size_t *dst_size
,
1997 unsigned char *src
, size_t src_size
)
2000 size_t block_num
= 0;
2001 size_t dst_offset
= 0;
2002 unsigned char last_block
[3];
2004 if (src_size
== 0) {
2008 num_blocks
= (src_size
/ 3);
2009 if ((src_size
% 3) == 0) {
2010 memcpy(last_block
, (&src
[src_size
- 3]), 3);
2013 last_block
[2] = 0x00;
2014 switch (src_size
% 3) {
2016 last_block
[0] = src
[src_size
- 1];
2017 last_block
[1] = 0x00;
2020 last_block
[0] = src
[src_size
- 2];
2021 last_block
[1] = src
[src_size
- 1];
2024 (*dst_size
) = (num_blocks
* 4);
2027 while (block_num
< num_blocks
) {
2028 unsigned char *src_block
;
2029 unsigned char dst_block
[4];
2031 if (block_num
== (num_blocks
- 1))
2032 src_block
= last_block
;
2034 src_block
= &src
[block_num
* 3];
2035 dst_block
[0] = ((src_block
[0] >> 2) & 0x3F);
2036 dst_block
[1] = (((src_block
[0] << 4) & 0x30)
2037 | ((src_block
[1] >> 4) & 0x0F));
2038 dst_block
[2] = (((src_block
[1] << 2) & 0x3C)
2039 | ((src_block
[2] >> 6) & 0x03));
2040 dst_block
[3] = (src_block
[2] & 0x3F);
2041 dst
[dst_offset
++] = portable_filename_chars
[dst_block
[0]];
2042 dst
[dst_offset
++] = portable_filename_chars
[dst_block
[1]];
2043 dst
[dst_offset
++] = portable_filename_chars
[dst_block
[2]];
2044 dst
[dst_offset
++] = portable_filename_chars
[dst_block
[3]];
2051 static size_t ecryptfs_max_decoded_size(size_t encoded_size
)
2053 /* Not exact; conservatively long. Every block of 4
2054 * encoded characters decodes into a block of 3
2055 * decoded characters. This segment of code provides
2056 * the caller with the maximum amount of allocated
2057 * space that @dst will need to point to in a
2058 * subsequent call. */
2059 return ((encoded_size
+ 1) * 3) / 4;
2063 * ecryptfs_decode_from_filename
2064 * @dst: If NULL, this function only sets @dst_size and returns. If
2065 * non-NULL, this function decodes the encoded octets in @src
2066 * into the memory that @dst points to.
2067 * @dst_size: Set to the size of the decoded string.
2068 * @src: The encoded set of octets to decode.
2069 * @src_size: The size of the encoded set of octets to decode.
2072 ecryptfs_decode_from_filename(unsigned char *dst
, size_t *dst_size
,
2073 const unsigned char *src
, size_t src_size
)
2075 u8 current_bit_offset
= 0;
2076 size_t src_byte_offset
= 0;
2077 size_t dst_byte_offset
= 0;
2080 (*dst_size
) = ecryptfs_max_decoded_size(src_size
);
2083 while (src_byte_offset
< src_size
) {
2084 unsigned char src_byte
=
2085 filename_rev_map
[(int)src
[src_byte_offset
]];
2087 switch (current_bit_offset
) {
2089 dst
[dst_byte_offset
] = (src_byte
<< 2);
2090 current_bit_offset
= 6;
2093 dst
[dst_byte_offset
++] |= (src_byte
>> 4);
2094 dst
[dst_byte_offset
] = ((src_byte
& 0xF)
2096 current_bit_offset
= 4;
2099 dst
[dst_byte_offset
++] |= (src_byte
>> 2);
2100 dst
[dst_byte_offset
] = (src_byte
<< 6);
2101 current_bit_offset
= 2;
2104 dst
[dst_byte_offset
++] |= (src_byte
);
2105 current_bit_offset
= 0;
2110 (*dst_size
) = dst_byte_offset
;
2116 * ecryptfs_encrypt_and_encode_filename - converts a plaintext file name to cipher text
2117 * @crypt_stat: The crypt_stat struct associated with the file anem to encode
2118 * @name: The plaintext name
2119 * @length: The length of the plaintext
2120 * @encoded_name: The encypted name
2122 * Encrypts and encodes a filename into something that constitutes a
2123 * valid filename for a filesystem, with printable characters.
2125 * We assume that we have a properly initialized crypto context,
2126 * pointed to by crypt_stat->tfm.
2128 * Returns zero on success; non-zero on otherwise
2130 int ecryptfs_encrypt_and_encode_filename(
2131 char **encoded_name
,
2132 size_t *encoded_name_size
,
2133 struct ecryptfs_crypt_stat
*crypt_stat
,
2134 struct ecryptfs_mount_crypt_stat
*mount_crypt_stat
,
2135 const char *name
, size_t name_size
)
2137 size_t encoded_name_no_prefix_size
;
2140 (*encoded_name
) = NULL
;
2141 (*encoded_name_size
) = 0;
2142 if ((crypt_stat
&& (crypt_stat
->flags
& ECRYPTFS_ENCRYPT_FILENAMES
))
2143 || (mount_crypt_stat
&& (mount_crypt_stat
->flags
2144 & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES
))) {
2145 struct ecryptfs_filename
*filename
;
2147 filename
= kzalloc(sizeof(*filename
), GFP_KERNEL
);
2149 printk(KERN_ERR
"%s: Out of memory whilst attempting "
2150 "to kzalloc [%zd] bytes\n", __func__
,
2155 filename
->filename
= (char *)name
;
2156 filename
->filename_size
= name_size
;
2157 rc
= ecryptfs_encrypt_filename(filename
, crypt_stat
,
2160 printk(KERN_ERR
"%s: Error attempting to encrypt "
2161 "filename; rc = [%d]\n", __func__
, rc
);
2165 ecryptfs_encode_for_filename(
2166 NULL
, &encoded_name_no_prefix_size
,
2167 filename
->encrypted_filename
,
2168 filename
->encrypted_filename_size
);
2169 if ((crypt_stat
&& (crypt_stat
->flags
2170 & ECRYPTFS_ENCFN_USE_MOUNT_FNEK
))
2171 || (mount_crypt_stat
2172 && (mount_crypt_stat
->flags
2173 & ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK
)))
2174 (*encoded_name_size
) =
2175 (ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE
2176 + encoded_name_no_prefix_size
);
2178 (*encoded_name_size
) =
2179 (ECRYPTFS_FEK_ENCRYPTED_FILENAME_PREFIX_SIZE
2180 + encoded_name_no_prefix_size
);
2181 (*encoded_name
) = kmalloc((*encoded_name_size
) + 1, GFP_KERNEL
);
2182 if (!(*encoded_name
)) {
2183 printk(KERN_ERR
"%s: Out of memory whilst attempting "
2184 "to kzalloc [%zd] bytes\n", __func__
,
2185 (*encoded_name_size
));
2187 kfree(filename
->encrypted_filename
);
2191 if ((crypt_stat
&& (crypt_stat
->flags
2192 & ECRYPTFS_ENCFN_USE_MOUNT_FNEK
))
2193 || (mount_crypt_stat
2194 && (mount_crypt_stat
->flags
2195 & ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK
))) {
2196 memcpy((*encoded_name
),
2197 ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX
,
2198 ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE
);
2199 ecryptfs_encode_for_filename(
2201 + ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE
),
2202 &encoded_name_no_prefix_size
,
2203 filename
->encrypted_filename
,
2204 filename
->encrypted_filename_size
);
2205 (*encoded_name_size
) =
2206 (ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE
2207 + encoded_name_no_prefix_size
);
2208 (*encoded_name
)[(*encoded_name_size
)] = '\0';
2213 printk(KERN_ERR
"%s: Error attempting to encode "
2214 "encrypted filename; rc = [%d]\n", __func__
,
2216 kfree((*encoded_name
));
2217 (*encoded_name
) = NULL
;
2218 (*encoded_name_size
) = 0;
2220 kfree(filename
->encrypted_filename
);
2223 rc
= ecryptfs_copy_filename(encoded_name
,
2232 * ecryptfs_decode_and_decrypt_filename - converts the encoded cipher text name to decoded plaintext
2233 * @plaintext_name: The plaintext name
2234 * @plaintext_name_size: The plaintext name size
2235 * @ecryptfs_dir_dentry: eCryptfs directory dentry
2236 * @name: The filename in cipher text
2237 * @name_size: The cipher text name size
2239 * Decrypts and decodes the filename.
2241 * Returns zero on error; non-zero otherwise
2243 int ecryptfs_decode_and_decrypt_filename(char **plaintext_name
,
2244 size_t *plaintext_name_size
,
2245 struct dentry
*ecryptfs_dir_dentry
,
2246 const char *name
, size_t name_size
)
2248 struct ecryptfs_mount_crypt_stat
*mount_crypt_stat
=
2249 &ecryptfs_superblock_to_private(
2250 ecryptfs_dir_dentry
->d_sb
)->mount_crypt_stat
;
2252 size_t decoded_name_size
;
2256 if ((mount_crypt_stat
->flags
& ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES
)
2257 && !(mount_crypt_stat
->flags
& ECRYPTFS_ENCRYPTED_VIEW_ENABLED
)
2258 && (name_size
> ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE
)
2259 && (strncmp(name
, ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX
,
2260 ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE
) == 0)) {
2261 const char *orig_name
= name
;
2262 size_t orig_name_size
= name_size
;
2264 name
+= ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE
;
2265 name_size
-= ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE
;
2266 ecryptfs_decode_from_filename(NULL
, &decoded_name_size
,
2268 decoded_name
= kmalloc(decoded_name_size
, GFP_KERNEL
);
2269 if (!decoded_name
) {
2270 printk(KERN_ERR
"%s: Out of memory whilst attempting "
2271 "to kmalloc [%zd] bytes\n", __func__
,
2276 ecryptfs_decode_from_filename(decoded_name
, &decoded_name_size
,
2278 rc
= ecryptfs_parse_tag_70_packet(plaintext_name
,
2279 plaintext_name_size
,
2285 printk(KERN_INFO
"%s: Could not parse tag 70 packet "
2286 "from filename; copying through filename "
2287 "as-is\n", __func__
);
2288 rc
= ecryptfs_copy_filename(plaintext_name
,
2289 plaintext_name_size
,
2290 orig_name
, orig_name_size
);
2294 rc
= ecryptfs_copy_filename(plaintext_name
,
2295 plaintext_name_size
,
2300 kfree(decoded_name
);
2305 #define ENC_NAME_MAX_BLOCKLEN_8_OR_16 143
2307 int ecryptfs_set_f_namelen(long *namelen
, long lower_namelen
,
2308 struct ecryptfs_mount_crypt_stat
*mount_crypt_stat
)
2310 struct blkcipher_desc desc
;
2311 struct mutex
*tfm_mutex
;
2312 size_t cipher_blocksize
;
2315 if (!(mount_crypt_stat
->flags
& ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES
)) {
2316 (*namelen
) = lower_namelen
;
2320 rc
= ecryptfs_get_tfm_and_mutex_for_cipher_name(&desc
.tfm
, &tfm_mutex
,
2321 mount_crypt_stat
->global_default_fn_cipher_name
);
2327 mutex_lock(tfm_mutex
);
2328 cipher_blocksize
= crypto_blkcipher_blocksize(desc
.tfm
);
2329 mutex_unlock(tfm_mutex
);
2331 /* Return an exact amount for the common cases */
2332 if (lower_namelen
== NAME_MAX
2333 && (cipher_blocksize
== 8 || cipher_blocksize
== 16)) {
2334 (*namelen
) = ENC_NAME_MAX_BLOCKLEN_8_OR_16
;
2338 /* Return a safe estimate for the uncommon cases */
2339 (*namelen
) = lower_namelen
;
2340 (*namelen
) -= ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE
;
2341 /* Since this is the max decoded size, subtract 1 "decoded block" len */
2342 (*namelen
) = ecryptfs_max_decoded_size(*namelen
) - 3;
2343 (*namelen
) -= ECRYPTFS_TAG_70_MAX_METADATA_SIZE
;
2344 (*namelen
) -= ECRYPTFS_FILENAME_MIN_RANDOM_PREPEND_BYTES
;
2345 /* Worst case is that the filename is padded nearly a full block size */
2346 (*namelen
) -= cipher_blocksize
- 1;