1 /** 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. 6 * 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> 11 * 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. 16 * 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. 21 * 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 25 * 02111-1307, USA. 26 */ 27 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" 37 38 /** 39 * ecryptfs_get_locked_page 40 * 41 * Get one page from cache or lower f/s, return error otherwise. 42 * 43 * Returns locked and up-to-date page (if ok), with increased 44 * refcnt. 45 */ 46 struct page *ecryptfs_get_locked_page(struct file *file, loff_t index) 47 { 48 struct dentry *dentry; 49 struct inode *inode; 50 struct address_space *mapping; 51 struct page *page; 52 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); 57 if (!IS_ERR(page)) 58 lock_page(page); 59 return page; 60 } 61 62 /** 63 * ecryptfs_writepage 64 * @page: Page that is locked before this call is made 65 * 66 * Returns zero on success; non-zero otherwise 67 */ 68 static int ecryptfs_writepage(struct page *page, struct writeback_control *wbc) 69 { 70 int rc; 71 72 rc = ecryptfs_encrypt_page(page); 73 if (rc) { 74 ecryptfs_printk(KERN_WARNING, "Error encrypting " 75 "page (upper index [0x%.16x])\n", page->index); 76 ClearPageUptodate(page); 77 goto out; 78 } 79 SetPageUptodate(page); 80 unlock_page(page); 81 out: 82 return rc; 83 } 84 85 /** 86 * Header Extent: 87 * Octets 0-7: Unencrypted file size (big-endian) 88 * Octets 8-15: eCryptfs special marker 89 * Octets 16-19: Flags 90 * Octet 16: File format version number (between 0 and 255) 91 * Octets 17-18: Reserved 92 * Octet 19: Bit 1 (lsb): Reserved 93 * Bit 2: Encrypted? 94 * Bits 3-8: Reserved 95 * Octets 20-23: Header extent size (big-endian) 96 * Octets 24-25: Number of header extents at front of file 97 * (big-endian) 98 * Octet 26: Begin RFC 2440 authentication token packet set 99 */ 100 static void set_header_info(char *page_virt, 101 struct ecryptfs_crypt_stat *crypt_stat) 102 { 103 size_t written; 104 size_t save_num_header_bytes_at_front = 105 crypt_stat->num_header_bytes_at_front; 106 107 crypt_stat->num_header_bytes_at_front = 108 ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE; 109 ecryptfs_write_header_metadata(page_virt + 20, crypt_stat, &written); 110 crypt_stat->num_header_bytes_at_front = 111 save_num_header_bytes_at_front; 112 } 113 114 /** 115 * ecryptfs_copy_up_encrypted_with_header 116 * @page: Sort of a ``virtual'' representation of the encrypted lower 117 * file. The actual lower file does not have the metadata in 118 * the header. This is locked. 119 * @crypt_stat: The eCryptfs inode's cryptographic context 120 * 121 * The ``view'' is the version of the file that userspace winds up 122 * seeing, with the header information inserted. 123 */ 124 static int 125 ecryptfs_copy_up_encrypted_with_header(struct page *page, 126 struct ecryptfs_crypt_stat *crypt_stat) 127 { 128 loff_t extent_num_in_page = 0; 129 loff_t num_extents_per_page = (PAGE_CACHE_SIZE 130 / crypt_stat->extent_size); 131 int rc = 0; 132 133 while (extent_num_in_page < num_extents_per_page) { 134 loff_t view_extent_num = ((((loff_t)page->index) 135 * num_extents_per_page) 136 + extent_num_in_page); 137 size_t num_header_extents_at_front = 138 (crypt_stat->num_header_bytes_at_front 139 / crypt_stat->extent_size); 140 141 if (view_extent_num < num_header_extents_at_front) { 142 /* This is a header extent */ 143 char *page_virt; 144 145 page_virt = kmap_atomic(page, KM_USER0); 146 memset(page_virt, 0, PAGE_CACHE_SIZE); 147 /* TODO: Support more than one header extent */ 148 if (view_extent_num == 0) { 149 rc = ecryptfs_read_xattr_region( 150 page_virt, page->mapping->host); 151 set_header_info(page_virt, crypt_stat); 152 } 153 kunmap_atomic(page_virt, KM_USER0); 154 flush_dcache_page(page); 155 if (rc) { 156 printk(KERN_ERR "%s: Error reading xattr " 157 "region; rc = [%d]\n", __func__, rc); 158 goto out; 159 } 160 } else { 161 /* This is an encrypted data extent */ 162 loff_t lower_offset = 163 ((view_extent_num * crypt_stat->extent_size) 164 - crypt_stat->num_header_bytes_at_front); 165 166 rc = ecryptfs_read_lower_page_segment( 167 page, (lower_offset >> PAGE_CACHE_SHIFT), 168 (lower_offset & ~PAGE_CACHE_MASK), 169 crypt_stat->extent_size, page->mapping->host); 170 if (rc) { 171 printk(KERN_ERR "%s: Error attempting to read " 172 "extent at offset [%lld] in the lower " 173 "file; rc = [%d]\n", __func__, 174 lower_offset, rc); 175 goto out; 176 } 177 } 178 extent_num_in_page++; 179 } 180 out: 181 return rc; 182 } 183 184 /** 185 * ecryptfs_readpage 186 * @file: An eCryptfs file 187 * @page: Page from eCryptfs inode mapping into which to stick the read data 188 * 189 * Read in a page, decrypting if necessary. 190 * 191 * Returns zero on success; non-zero on error. 192 */ 193 static int ecryptfs_readpage(struct file *file, struct page *page) 194 { 195 struct ecryptfs_crypt_stat *crypt_stat = 196 &ecryptfs_inode_to_private(file->f_path.dentry->d_inode)->crypt_stat; 197 int rc = 0; 198 199 if (!crypt_stat 200 || !(crypt_stat->flags & ECRYPTFS_ENCRYPTED) 201 || (crypt_stat->flags & ECRYPTFS_NEW_FILE)) { 202 ecryptfs_printk(KERN_DEBUG, 203 "Passing through unencrypted page\n"); 204 rc = ecryptfs_read_lower_page_segment(page, page->index, 0, 205 PAGE_CACHE_SIZE, 206 page->mapping->host); 207 } else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) { 208 if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) { 209 rc = ecryptfs_copy_up_encrypted_with_header(page, 210 crypt_stat); 211 if (rc) { 212 printk(KERN_ERR "%s: Error attempting to copy " 213 "the encrypted content from the lower " 214 "file whilst inserting the metadata " 215 "from the xattr into the header; rc = " 216 "[%d]\n", __func__, rc); 217 goto out; 218 } 219 220 } else { 221 rc = ecryptfs_read_lower_page_segment( 222 page, page->index, 0, PAGE_CACHE_SIZE, 223 page->mapping->host); 224 if (rc) { 225 printk(KERN_ERR "Error reading page; rc = " 226 "[%d]\n", rc); 227 goto out; 228 } 229 } 230 } else { 231 rc = ecryptfs_decrypt_page(page); 232 if (rc) { 233 ecryptfs_printk(KERN_ERR, "Error decrypting page; " 234 "rc = [%d]\n", rc); 235 goto out; 236 } 237 } 238 out: 239 if (rc) 240 ClearPageUptodate(page); 241 else 242 SetPageUptodate(page); 243 ecryptfs_printk(KERN_DEBUG, "Unlocking page with index = [0x%.16x]\n", 244 page->index); 245 unlock_page(page); 246 return rc; 247 } 248 249 /** 250 * Called with lower inode mutex held. 251 */ 252 static int fill_zeros_to_end_of_page(struct page *page, unsigned int to) 253 { 254 struct inode *inode = page->mapping->host; 255 int end_byte_in_page; 256 257 if ((i_size_read(inode) / PAGE_CACHE_SIZE) != page->index) 258 goto out; 259 end_byte_in_page = i_size_read(inode) % PAGE_CACHE_SIZE; 260 if (to > end_byte_in_page) 261 end_byte_in_page = to; 262 zero_user_segment(page, end_byte_in_page, PAGE_CACHE_SIZE); 263 out: 264 return 0; 265 } 266 267 /** 268 * ecryptfs_write_begin 269 * @file: The eCryptfs file 270 * @mapping: The eCryptfs object 271 * @pos: The file offset at which to start writing 272 * @len: Length of the write 273 * @flags: Various flags 274 * @pagep: Pointer to return the page 275 * @fsdata: Pointer to return fs data (unused) 276 * 277 * This function must zero any hole we create 278 * 279 * Returns zero on success; non-zero otherwise 280 */ 281 static int ecryptfs_write_begin(struct file *file, 282 struct address_space *mapping, 283 loff_t pos, unsigned len, unsigned flags, 284 struct page **pagep, void **fsdata) 285 { 286 pgoff_t index = pos >> PAGE_CACHE_SHIFT; 287 struct page *page; 288 loff_t prev_page_end_size; 289 int rc = 0; 290 291 page = grab_cache_page_write_begin(mapping, index, flags); 292 if (!page) 293 return -ENOMEM; 294 *pagep = page; 295 296 if (!PageUptodate(page)) { 297 struct ecryptfs_crypt_stat *crypt_stat = 298 &ecryptfs_inode_to_private( 299 file->f_path.dentry->d_inode)->crypt_stat; 300 301 if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED) 302 || (crypt_stat->flags & ECRYPTFS_NEW_FILE)) { 303 rc = ecryptfs_read_lower_page_segment( 304 page, index, 0, PAGE_CACHE_SIZE, mapping->host); 305 if (rc) { 306 printk(KERN_ERR "%s: Error attemping to read " 307 "lower page segment; rc = [%d]\n", 308 __func__, rc); 309 ClearPageUptodate(page); 310 goto out; 311 } else 312 SetPageUptodate(page); 313 } else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) { 314 if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) { 315 rc = ecryptfs_copy_up_encrypted_with_header( 316 page, crypt_stat); 317 if (rc) { 318 printk(KERN_ERR "%s: Error attempting " 319 "to copy the encrypted content " 320 "from the lower file whilst " 321 "inserting the metadata from " 322 "the xattr into the header; rc " 323 "= [%d]\n", __func__, rc); 324 ClearPageUptodate(page); 325 goto out; 326 } 327 SetPageUptodate(page); 328 } else { 329 rc = ecryptfs_read_lower_page_segment( 330 page, index, 0, PAGE_CACHE_SIZE, 331 mapping->host); 332 if (rc) { 333 printk(KERN_ERR "%s: Error reading " 334 "page; rc = [%d]\n", 335 __func__, rc); 336 ClearPageUptodate(page); 337 goto out; 338 } 339 SetPageUptodate(page); 340 } 341 } else { 342 rc = ecryptfs_decrypt_page(page); 343 if (rc) { 344 printk(KERN_ERR "%s: Error decrypting page " 345 "at index [%ld]; rc = [%d]\n", 346 __func__, page->index, rc); 347 ClearPageUptodate(page); 348 goto out; 349 } 350 SetPageUptodate(page); 351 } 352 } 353 prev_page_end_size = ((loff_t)index << PAGE_CACHE_SHIFT); 354 /* If creating a page or more of holes, zero them out via truncate. 355 * Note, this will increase i_size. */ 356 if (index != 0) { 357 if (prev_page_end_size > i_size_read(page->mapping->host)) { 358 rc = ecryptfs_truncate(file->f_path.dentry, 359 prev_page_end_size); 360 if (rc) { 361 printk(KERN_ERR "%s: Error on attempt to " 362 "truncate to (higher) offset [%lld];" 363 " rc = [%d]\n", __func__, 364 prev_page_end_size, rc); 365 goto out; 366 } 367 } 368 } 369 /* Writing to a new page, and creating a small hole from start 370 * of page? Zero it out. */ 371 if ((i_size_read(mapping->host) == prev_page_end_size) 372 && (pos != 0)) 373 zero_user(page, 0, PAGE_CACHE_SIZE); 374 out: 375 return rc; 376 } 377 378 /** 379 * ecryptfs_write_inode_size_to_header 380 * 381 * Writes the lower file size to the first 8 bytes of the header. 382 * 383 * Returns zero on success; non-zero on error. 384 */ 385 static int ecryptfs_write_inode_size_to_header(struct inode *ecryptfs_inode) 386 { 387 char *file_size_virt; 388 int rc; 389 390 file_size_virt = kmalloc(sizeof(u64), GFP_KERNEL); 391 if (!file_size_virt) { 392 rc = -ENOMEM; 393 goto out; 394 } 395 put_unaligned_be64(i_size_read(ecryptfs_inode), file_size_virt); 396 rc = ecryptfs_write_lower(ecryptfs_inode, file_size_virt, 0, 397 sizeof(u64)); 398 kfree(file_size_virt); 399 if (rc < 0) 400 printk(KERN_ERR "%s: Error writing file size to header; " 401 "rc = [%d]\n", __func__, rc); 402 else 403 rc = 0; 404 out: 405 return rc; 406 } 407 408 struct kmem_cache *ecryptfs_xattr_cache; 409 410 static int ecryptfs_write_inode_size_to_xattr(struct inode *ecryptfs_inode) 411 { 412 ssize_t size; 413 void *xattr_virt; 414 struct dentry *lower_dentry = 415 ecryptfs_inode_to_private(ecryptfs_inode)->lower_file->f_dentry; 416 struct inode *lower_inode = lower_dentry->d_inode; 417 int rc; 418 419 if (!lower_inode->i_op->getxattr || !lower_inode->i_op->setxattr) { 420 printk(KERN_WARNING 421 "No support for setting xattr in lower filesystem\n"); 422 rc = -ENOSYS; 423 goto out; 424 } 425 xattr_virt = kmem_cache_alloc(ecryptfs_xattr_cache, GFP_KERNEL); 426 if (!xattr_virt) { 427 printk(KERN_ERR "Out of memory whilst attempting to write " 428 "inode size to xattr\n"); 429 rc = -ENOMEM; 430 goto out; 431 } 432 mutex_lock(&lower_inode->i_mutex); 433 size = lower_inode->i_op->getxattr(lower_dentry, ECRYPTFS_XATTR_NAME, 434 xattr_virt, PAGE_CACHE_SIZE); 435 if (size < 0) 436 size = 8; 437 put_unaligned_be64(i_size_read(ecryptfs_inode), xattr_virt); 438 rc = lower_inode->i_op->setxattr(lower_dentry, ECRYPTFS_XATTR_NAME, 439 xattr_virt, size, 0); 440 mutex_unlock(&lower_inode->i_mutex); 441 if (rc) 442 printk(KERN_ERR "Error whilst attempting to write inode size " 443 "to lower file xattr; rc = [%d]\n", rc); 444 kmem_cache_free(ecryptfs_xattr_cache, xattr_virt); 445 out: 446 return rc; 447 } 448 449 int ecryptfs_write_inode_size_to_metadata(struct inode *ecryptfs_inode) 450 { 451 struct ecryptfs_crypt_stat *crypt_stat; 452 453 crypt_stat = &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat; 454 BUG_ON(!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)); 455 if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) 456 return ecryptfs_write_inode_size_to_xattr(ecryptfs_inode); 457 else 458 return ecryptfs_write_inode_size_to_header(ecryptfs_inode); 459 } 460 461 /** 462 * ecryptfs_write_end 463 * @file: The eCryptfs file object 464 * @mapping: The eCryptfs object 465 * @pos: The file position 466 * @len: The length of the data (unused) 467 * @copied: The amount of data copied 468 * @page: The eCryptfs page 469 * @fsdata: The fsdata (unused) 470 * 471 * This is where we encrypt the data and pass the encrypted data to 472 * the lower filesystem. In OpenPGP-compatible mode, we operate on 473 * entire underlying packets. 474 */ 475 static int ecryptfs_write_end(struct file *file, 476 struct address_space *mapping, 477 loff_t pos, unsigned len, unsigned copied, 478 struct page *page, void *fsdata) 479 { 480 pgoff_t index = pos >> PAGE_CACHE_SHIFT; 481 unsigned from = pos & (PAGE_CACHE_SIZE - 1); 482 unsigned to = from + copied; 483 struct inode *ecryptfs_inode = mapping->host; 484 struct ecryptfs_crypt_stat *crypt_stat = 485 &ecryptfs_inode_to_private(file->f_path.dentry->d_inode)->crypt_stat; 486 int rc; 487 488 if (crypt_stat->flags & ECRYPTFS_NEW_FILE) { 489 ecryptfs_printk(KERN_DEBUG, "ECRYPTFS_NEW_FILE flag set in " 490 "crypt_stat at memory location [%p]\n", crypt_stat); 491 crypt_stat->flags &= ~(ECRYPTFS_NEW_FILE); 492 } else 493 ecryptfs_printk(KERN_DEBUG, "Not a new file\n"); 494 ecryptfs_printk(KERN_DEBUG, "Calling fill_zeros_to_end_of_page" 495 "(page w/ index = [0x%.16x], to = [%d])\n", index, to); 496 if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) { 497 rc = ecryptfs_write_lower_page_segment(ecryptfs_inode, page, 0, 498 to); 499 if (!rc) { 500 rc = copied; 501 fsstack_copy_inode_size(ecryptfs_inode, 502 ecryptfs_inode_to_lower(ecryptfs_inode)); 503 } 504 goto out; 505 } 506 /* Fills in zeros if 'to' goes beyond inode size */ 507 rc = fill_zeros_to_end_of_page(page, to); 508 if (rc) { 509 ecryptfs_printk(KERN_WARNING, "Error attempting to fill " 510 "zeros in page with index = [0x%.16x]\n", index); 511 goto out; 512 } 513 rc = ecryptfs_encrypt_page(page); 514 if (rc) { 515 ecryptfs_printk(KERN_WARNING, "Error encrypting page (upper " 516 "index [0x%.16x])\n", index); 517 goto out; 518 } 519 if (pos + copied > i_size_read(ecryptfs_inode)) { 520 i_size_write(ecryptfs_inode, pos + copied); 521 ecryptfs_printk(KERN_DEBUG, "Expanded file size to " 522 "[0x%.16x]\n", i_size_read(ecryptfs_inode)); 523 } 524 rc = ecryptfs_write_inode_size_to_metadata(ecryptfs_inode); 525 if (rc) 526 printk(KERN_ERR "Error writing inode size to metadata; " 527 "rc = [%d]\n", rc); 528 else 529 rc = copied; 530 out: 531 unlock_page(page); 532 page_cache_release(page); 533 return rc; 534 } 535 536 static sector_t ecryptfs_bmap(struct address_space *mapping, sector_t block) 537 { 538 int rc = 0; 539 struct inode *inode; 540 struct inode *lower_inode; 541 542 inode = (struct inode *)mapping->host; 543 lower_inode = ecryptfs_inode_to_lower(inode); 544 if (lower_inode->i_mapping->a_ops->bmap) 545 rc = lower_inode->i_mapping->a_ops->bmap(lower_inode->i_mapping, 546 block); 547 return rc; 548 } 549 550 const struct address_space_operations ecryptfs_aops = { 551 .writepage = ecryptfs_writepage, 552 .readpage = ecryptfs_readpage, 553 .write_begin = ecryptfs_write_begin, 554 .write_end = ecryptfs_write_end, 555 .bmap = ecryptfs_bmap, 556 }; 557