2 * eCryptfs: Linux filesystem encryption layer
3 * This is where eCryptfs coordinates the symmetric encryption and
4 * decryption of the file data as it passes between the lower
5 * encrypted file and the upper decrypted file.
7 * Copyright (C) 1997-2003 Erez Zadok
8 * Copyright (C) 2001-2003 Stony Brook University
9 * Copyright (C) 2004-2007 International Business Machines Corp.
10 * Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License as
14 * published by the Free Software Foundation; either version 2 of the
15 * License, or (at your option) any later version.
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
28 #include <linux/pagemap.h>
29 #include <linux/writeback.h>
30 #include <linux/page-flags.h>
31 #include <linux/mount.h>
32 #include <linux/file.h>
33 #include <linux/crypto.h>
34 #include <linux/scatterlist.h>
35 #include <asm/unaligned.h>
36 #include "ecryptfs_kernel.h"
39 * ecryptfs_get_locked_page
41 * Get one page from cache or lower f/s, return error otherwise.
43 * Returns locked and up-to-date page (if ok), with increased
46 struct page *ecryptfs_get_locked_page(struct file *file, loff_t index)
48 struct dentry *dentry;
50 struct address_space *mapping;
53 dentry = file->f_path.dentry;
54 inode = dentry->d_inode;
55 mapping = inode->i_mapping;
56 page = read_mapping_page(mapping, index, (void *)file);
64 * @page: Page that is locked before this call is made
66 * Returns zero on success; non-zero otherwise
68 static int ecryptfs_writepage(struct page *page, struct writeback_control *wbc)
72 rc = ecryptfs_encrypt_page(page);
74 ecryptfs_printk(KERN_WARNING, "Error encrypting "
75 "page (upper index [0x%.16x])\n", page->index);
76 ClearPageUptodate(page);
79 SetPageUptodate(page);
87 * Octets 0-7: Unencrypted file size (big-endian)
88 * Octets 8-15: eCryptfs special marker
90 * Octet 16: File format version number (between 0 and 255)
91 * Octets 17-18: Reserved
92 * Octet 19: Bit 1 (lsb): Reserved
95 * Octets 20-23: Header extent size (big-endian)
96 * Octets 24-25: Number of header extents at front of file
98 * Octet 26: Begin RFC 2440 authentication token packet set
102 * ecryptfs_copy_up_encrypted_with_header
103 * @page: Sort of a ``virtual'' representation of the encrypted lower
104 * file. The actual lower file does not have the metadata in
105 * the header. This is locked.
106 * @crypt_stat: The eCryptfs inode's cryptographic context
108 * The ``view'' is the version of the file that userspace winds up
109 * seeing, with the header information inserted.
112 ecryptfs_copy_up_encrypted_with_header(struct page *page,
113 struct ecryptfs_crypt_stat *crypt_stat)
115 loff_t extent_num_in_page = 0;
116 loff_t num_extents_per_page = (PAGE_CACHE_SIZE
117 / crypt_stat->extent_size);
120 while (extent_num_in_page < num_extents_per_page) {
121 loff_t view_extent_num = ((((loff_t)page->index)
122 * num_extents_per_page)
123 + extent_num_in_page);
124 size_t num_header_extents_at_front =
125 (crypt_stat->metadata_size / crypt_stat->extent_size);
127 if (view_extent_num < num_header_extents_at_front) {
128 /* This is a header extent */
131 page_virt = kmap_atomic(page, KM_USER0);
132 memset(page_virt, 0, PAGE_CACHE_SIZE);
133 /* TODO: Support more than one header extent */
134 if (view_extent_num == 0) {
137 rc = ecryptfs_read_xattr_region(
138 page_virt, page->mapping->host);
139 ecryptfs_write_header_metadata(page_virt + 20,
143 kunmap_atomic(page_virt, KM_USER0);
144 flush_dcache_page(page);
146 printk(KERN_ERR "%s: Error reading xattr "
147 "region; rc = [%d]\n", __func__, rc);
151 /* This is an encrypted data extent */
152 loff_t lower_offset =
153 ((view_extent_num * crypt_stat->extent_size)
154 - crypt_stat->metadata_size);
156 rc = ecryptfs_read_lower_page_segment(
157 page, (lower_offset >> PAGE_CACHE_SHIFT),
158 (lower_offset & ~PAGE_CACHE_MASK),
159 crypt_stat->extent_size, page->mapping->host);
161 printk(KERN_ERR "%s: Error attempting to read "
162 "extent at offset [%lld] in the lower "
163 "file; rc = [%d]\n", __func__,
168 extent_num_in_page++;
176 * @file: An eCryptfs file
177 * @page: Page from eCryptfs inode mapping into which to stick the read data
179 * Read in a page, decrypting if necessary.
181 * Returns zero on success; non-zero on error.
183 static int ecryptfs_readpage(struct file *file, struct page *page)
185 struct ecryptfs_crypt_stat *crypt_stat =
186 &ecryptfs_inode_to_private(file->f_path.dentry->d_inode)->crypt_stat;
190 || !(crypt_stat->flags & ECRYPTFS_ENCRYPTED)
191 || (crypt_stat->flags & ECRYPTFS_NEW_FILE)) {
192 ecryptfs_printk(KERN_DEBUG,
193 "Passing through unencrypted page\n");
194 rc = ecryptfs_read_lower_page_segment(page, page->index, 0,
196 page->mapping->host);
197 } else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) {
198 if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
199 rc = ecryptfs_copy_up_encrypted_with_header(page,
202 printk(KERN_ERR "%s: Error attempting to copy "
203 "the encrypted content from the lower "
204 "file whilst inserting the metadata "
205 "from the xattr into the header; rc = "
206 "[%d]\n", __func__, rc);
211 rc = ecryptfs_read_lower_page_segment(
212 page, page->index, 0, PAGE_CACHE_SIZE,
213 page->mapping->host);
215 printk(KERN_ERR "Error reading page; rc = "
221 rc = ecryptfs_decrypt_page(page);
223 ecryptfs_printk(KERN_ERR, "Error decrypting page; "
230 ClearPageUptodate(page);
232 SetPageUptodate(page);
233 ecryptfs_printk(KERN_DEBUG, "Unlocking page with index = [0x%.16x]\n",
240 * Called with lower inode mutex held.
242 static int fill_zeros_to_end_of_page(struct page *page, unsigned int to)
244 struct inode *inode = page->mapping->host;
245 int end_byte_in_page;
247 if ((i_size_read(inode) / PAGE_CACHE_SIZE) != page->index)
249 end_byte_in_page = i_size_read(inode) % PAGE_CACHE_SIZE;
250 if (to > end_byte_in_page)
251 end_byte_in_page = to;
252 zero_user_segment(page, end_byte_in_page, PAGE_CACHE_SIZE);
258 * ecryptfs_write_begin
259 * @file: The eCryptfs file
260 * @mapping: The eCryptfs object
261 * @pos: The file offset at which to start writing
262 * @len: Length of the write
263 * @flags: Various flags
264 * @pagep: Pointer to return the page
265 * @fsdata: Pointer to return fs data (unused)
267 * This function must zero any hole we create
269 * Returns zero on success; non-zero otherwise
271 static int ecryptfs_write_begin(struct file *file,
272 struct address_space *mapping,
273 loff_t pos, unsigned len, unsigned flags,
274 struct page **pagep, void **fsdata)
276 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
278 loff_t prev_page_end_size;
281 page = grab_cache_page_write_begin(mapping, index, flags);
286 if (!PageUptodate(page)) {
287 struct ecryptfs_crypt_stat *crypt_stat =
288 &ecryptfs_inode_to_private(
289 file->f_path.dentry->d_inode)->crypt_stat;
291 if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)
292 || (crypt_stat->flags & ECRYPTFS_NEW_FILE)) {
293 rc = ecryptfs_read_lower_page_segment(
294 page, index, 0, PAGE_CACHE_SIZE, mapping->host);
296 printk(KERN_ERR "%s: Error attemping to read "
297 "lower page segment; rc = [%d]\n",
299 ClearPageUptodate(page);
302 SetPageUptodate(page);
303 } else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) {
304 if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
305 rc = ecryptfs_copy_up_encrypted_with_header(
308 printk(KERN_ERR "%s: Error attempting "
309 "to copy the encrypted content "
310 "from the lower file whilst "
311 "inserting the metadata from "
312 "the xattr into the header; rc "
313 "= [%d]\n", __func__, rc);
314 ClearPageUptodate(page);
317 SetPageUptodate(page);
319 rc = ecryptfs_read_lower_page_segment(
320 page, index, 0, PAGE_CACHE_SIZE,
323 printk(KERN_ERR "%s: Error reading "
326 ClearPageUptodate(page);
329 SetPageUptodate(page);
332 rc = ecryptfs_decrypt_page(page);
334 printk(KERN_ERR "%s: Error decrypting page "
335 "at index [%ld]; rc = [%d]\n",
336 __func__, page->index, rc);
337 ClearPageUptodate(page);
340 SetPageUptodate(page);
343 prev_page_end_size = ((loff_t)index << PAGE_CACHE_SHIFT);
344 /* If creating a page or more of holes, zero them out via truncate.
345 * Note, this will increase i_size. */
347 if (prev_page_end_size > i_size_read(page->mapping->host)) {
348 rc = ecryptfs_truncate(file->f_path.dentry,
351 printk(KERN_ERR "%s: Error on attempt to "
352 "truncate to (higher) offset [%lld];"
353 " rc = [%d]\n", __func__,
354 prev_page_end_size, rc);
359 /* Writing to a new page, and creating a small hole from start
360 * of page? Zero it out. */
361 if ((i_size_read(mapping->host) == prev_page_end_size)
363 zero_user(page, 0, PAGE_CACHE_SIZE);
369 * ecryptfs_write_inode_size_to_header
371 * Writes the lower file size to the first 8 bytes of the header.
373 * Returns zero on success; non-zero on error.
375 static int ecryptfs_write_inode_size_to_header(struct inode *ecryptfs_inode)
377 char *file_size_virt;
380 file_size_virt = kmalloc(sizeof(u64), GFP_KERNEL);
381 if (!file_size_virt) {
385 put_unaligned_be64(i_size_read(ecryptfs_inode), file_size_virt);
386 rc = ecryptfs_write_lower(ecryptfs_inode, file_size_virt, 0,
388 kfree(file_size_virt);
390 printk(KERN_ERR "%s: Error writing file size to header; "
391 "rc = [%d]\n", __func__, rc);
398 struct kmem_cache *ecryptfs_xattr_cache;
400 static int ecryptfs_write_inode_size_to_xattr(struct inode *ecryptfs_inode)
404 struct dentry *lower_dentry =
405 ecryptfs_inode_to_private(ecryptfs_inode)->lower_file->f_dentry;
406 struct inode *lower_inode = lower_dentry->d_inode;
409 if (!lower_inode->i_op->getxattr || !lower_inode->i_op->setxattr) {
411 "No support for setting xattr in lower filesystem\n");
415 xattr_virt = kmem_cache_alloc(ecryptfs_xattr_cache, GFP_KERNEL);
417 printk(KERN_ERR "Out of memory whilst attempting to write "
418 "inode size to xattr\n");
422 mutex_lock(&lower_inode->i_mutex);
423 size = lower_inode->i_op->getxattr(lower_dentry, ECRYPTFS_XATTR_NAME,
424 xattr_virt, PAGE_CACHE_SIZE);
427 put_unaligned_be64(i_size_read(ecryptfs_inode), xattr_virt);
428 rc = lower_inode->i_op->setxattr(lower_dentry, ECRYPTFS_XATTR_NAME,
429 xattr_virt, size, 0);
430 mutex_unlock(&lower_inode->i_mutex);
432 printk(KERN_ERR "Error whilst attempting to write inode size "
433 "to lower file xattr; rc = [%d]\n", rc);
434 kmem_cache_free(ecryptfs_xattr_cache, xattr_virt);
439 int ecryptfs_write_inode_size_to_metadata(struct inode *ecryptfs_inode)
441 struct ecryptfs_crypt_stat *crypt_stat;
443 crypt_stat = &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
444 BUG_ON(!(crypt_stat->flags & ECRYPTFS_ENCRYPTED));
445 if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR)
446 return ecryptfs_write_inode_size_to_xattr(ecryptfs_inode);
448 return ecryptfs_write_inode_size_to_header(ecryptfs_inode);
453 * @file: The eCryptfs file object
454 * @mapping: The eCryptfs object
455 * @pos: The file position
456 * @len: The length of the data (unused)
457 * @copied: The amount of data copied
458 * @page: The eCryptfs page
459 * @fsdata: The fsdata (unused)
461 * This is where we encrypt the data and pass the encrypted data to
462 * the lower filesystem. In OpenPGP-compatible mode, we operate on
463 * entire underlying packets.
465 static int ecryptfs_write_end(struct file *file,
466 struct address_space *mapping,
467 loff_t pos, unsigned len, unsigned copied,
468 struct page *page, void *fsdata)
470 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
471 unsigned from = pos & (PAGE_CACHE_SIZE - 1);
472 unsigned to = from + copied;
473 struct inode *ecryptfs_inode = mapping->host;
474 struct ecryptfs_crypt_stat *crypt_stat =
475 &ecryptfs_inode_to_private(file->f_path.dentry->d_inode)->crypt_stat;
478 if (crypt_stat->flags & ECRYPTFS_NEW_FILE) {
479 ecryptfs_printk(KERN_DEBUG, "ECRYPTFS_NEW_FILE flag set in "
480 "crypt_stat at memory location [%p]\n", crypt_stat);
481 crypt_stat->flags &= ~(ECRYPTFS_NEW_FILE);
483 ecryptfs_printk(KERN_DEBUG, "Not a new file\n");
484 ecryptfs_printk(KERN_DEBUG, "Calling fill_zeros_to_end_of_page"
485 "(page w/ index = [0x%.16x], to = [%d])\n", index, to);
486 if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
487 rc = ecryptfs_write_lower_page_segment(ecryptfs_inode, page, 0,
491 fsstack_copy_inode_size(ecryptfs_inode,
492 ecryptfs_inode_to_lower(ecryptfs_inode));
496 /* Fills in zeros if 'to' goes beyond inode size */
497 rc = fill_zeros_to_end_of_page(page, to);
499 ecryptfs_printk(KERN_WARNING, "Error attempting to fill "
500 "zeros in page with index = [0x%.16x]\n", index);
503 rc = ecryptfs_encrypt_page(page);
505 ecryptfs_printk(KERN_WARNING, "Error encrypting page (upper "
506 "index [0x%.16x])\n", index);
509 if (pos + copied > i_size_read(ecryptfs_inode)) {
510 i_size_write(ecryptfs_inode, pos + copied);
511 ecryptfs_printk(KERN_DEBUG, "Expanded file size to "
512 "[0x%.16x]\n", i_size_read(ecryptfs_inode));
514 rc = ecryptfs_write_inode_size_to_metadata(ecryptfs_inode);
516 printk(KERN_ERR "Error writing inode size to metadata; "
522 page_cache_release(page);
526 static sector_t ecryptfs_bmap(struct address_space *mapping, sector_t block)
530 struct inode *lower_inode;
532 inode = (struct inode *)mapping->host;
533 lower_inode = ecryptfs_inode_to_lower(inode);
534 if (lower_inode->i_mapping->a_ops->bmap)
535 rc = lower_inode->i_mapping->a_ops->bmap(lower_inode->i_mapping,
540 const struct address_space_operations ecryptfs_aops = {
541 .writepage = ecryptfs_writepage,
542 .readpage = ecryptfs_readpage,
543 .write_begin = ecryptfs_write_begin,
544 .write_end = ecryptfs_write_end,
545 .bmap = ecryptfs_bmap,