Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit 298647e31af52e795867a399fa049cebd88067ff

Authored by Linus Torvalds 2014-12-20 10:15:12 +0800

2 parents 5c68eac68b 942080643b

Exists in ti-lsk-linux-4.1.y and in 10 other branches

Merge tag 'ecryptfs-3.19-rc1-fixes' of git://git.kernel.org/pub/scm/linux/kernel…

…/git/tyhicks/ecryptfs

Pull eCryptfs fixes from Tyler Hicks:
 "Fixes for filename decryption and encrypted view plus a cleanup

   - The filename decryption routines were, at times, writing a zero
     byte one character past the end of the filename buffer

   - The encrypted view feature attempted, and failed, to roll its own
     form of enforcing a read-only mount instead of letting the VFS
     enforce it"

* tag 'ecryptfs-3.19-rc1-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/tyhicks/ecryptfs:
  eCryptfs: Remove buggy and unnecessary write in file name decode routine
  eCryptfs: Remove unnecessary casts when parsing packet lengths
  eCryptfs: Force RO mount when encrypted view is enabled

Showing 4 changed files Inline Diff

fs/ecryptfs/crypto.c
fs/ecryptfs/file.c
fs/ecryptfs/keystore.c
fs/ecryptfs/main.c

fs/ecryptfs/crypto.c

Diff comments View file @ 298647e

 /**
  * eCryptfs: Linux filesystem encryption layer
  *
  * Copyright (C) 1997-2004 Erez Zadok
  * Copyright (C) 2001-2004 Stony Brook University
  * Copyright (C) 2004-2007 International Business Machines Corp.
  *   Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
  *   		Michael C. Thompson <mcthomps@us.ibm.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  * 02111-1307, USA.
  */
 #include <linux/fs.h>
 #include <linux/mount.h>
 #include <linux/pagemap.h>
 #include <linux/random.h>
 #include <linux/compiler.h>
 #include <linux/key.h>
 #include <linux/namei.h>
 #include <linux/crypto.h>
 #include <linux/file.h>
 #include <linux/scatterlist.h>
 #include <linux/slab.h>
 #include <asm/unaligned.h>
 #include "ecryptfs_kernel.h"
 #define DECRYPT		0
 #define ENCRYPT		1
 /**
  * ecryptfs_to_hex
  * @dst: Buffer to take hex character representation of contents of
  *       src; must be at least of size (src_size * 2)
  * @src: Buffer to be converted to a hex string respresentation
  * @src_size: number of bytes to convert
  */
 void ecryptfs_to_hex(char *dst, char *src, size_t src_size)
 {
 	int x;
 	for (x = 0; x < src_size; x++)
 		sprintf(&dst[x * 2], "%.2x", (unsigned char)src[x]);
 }
 /**
  * ecryptfs_from_hex
  * @dst: Buffer to take the bytes from src hex; must be at least of
  *       size (src_size / 2)
  * @src: Buffer to be converted from a hex string respresentation to raw value
  * @dst_size: size of dst buffer, or number of hex characters pairs to convert
  */
 void ecryptfs_from_hex(char *dst, char *src, int dst_size)
 {
 	int x;
 	char tmp[3] = { 0, };
 	for (x = 0; x < dst_size; x++) {
 		tmp[0] = src[x * 2];
 		tmp[1] = src[x * 2 + 1];
 		dst[x] = (unsigned char)simple_strtol(tmp, NULL, 16);
 	}
 }
 /**
  * ecryptfs_calculate_md5 - calculates the md5 of @src
  * @dst: Pointer to 16 bytes of allocated memory
  * @crypt_stat: Pointer to crypt_stat struct for the current inode
  * @src: Data to be md5'd
  * @len: Length of @src
  *
  * Uses the allocated crypto context that crypt_stat references to
  * generate the MD5 sum of the contents of src.
  */
 static int ecryptfs_calculate_md5(char *dst,
 				  struct ecryptfs_crypt_stat *crypt_stat,
 				  char *src, int len)
 {
 	struct scatterlist sg;
 	struct hash_desc desc = {
 		.tfm = crypt_stat->hash_tfm,
 		.flags = CRYPTO_TFM_REQ_MAY_SLEEP
 	};
 	int rc = 0;
 	mutex_lock(&crypt_stat->cs_hash_tfm_mutex);
 	sg_init_one(&sg, (u8 *)src, len);
 	if (!desc.tfm) {
 		desc.tfm = crypto_alloc_hash(ECRYPTFS_DEFAULT_HASH, 0,
 					     CRYPTO_ALG_ASYNC);
 		if (IS_ERR(desc.tfm)) {
 			rc = PTR_ERR(desc.tfm);
 			ecryptfs_printk(KERN_ERR, "Error attempting to "
 					"allocate crypto context; rc = [%d]\n",
 					rc);
 			goto out;
 		}
 		crypt_stat->hash_tfm = desc.tfm;
 	}
 	rc = crypto_hash_init(&desc);
 	if (rc) {
 		printk(KERN_ERR
 		       "%s: Error initializing crypto hash; rc = [%d]\n",
 		       __func__, rc);
 		goto out;
 	}
 	rc = crypto_hash_update(&desc, &sg, len);
 	if (rc) {
 		printk(KERN_ERR
 		       "%s: Error updating crypto hash; rc = [%d]\n",
 		       __func__, rc);
 		goto out;
 	}
 	rc = crypto_hash_final(&desc, dst);
 	if (rc) {
 		printk(KERN_ERR
 		       "%s: Error finalizing crypto hash; rc = [%d]\n",
 		       __func__, rc);
 		goto out;
 	}
 out:
 	mutex_unlock(&crypt_stat->cs_hash_tfm_mutex);
 	return rc;
 }
 static int ecryptfs_crypto_api_algify_cipher_name(char **algified_name,
 						  char *cipher_name,
 						  char *chaining_modifier)
 {
 	int cipher_name_len = strlen(cipher_name);
 	int chaining_modifier_len = strlen(chaining_modifier);
 	int algified_name_len;
 	int rc;
 	algified_name_len = (chaining_modifier_len + cipher_name_len + 3);
 	(*algified_name) = kmalloc(algified_name_len, GFP_KERNEL);
 	if (!(*algified_name)) {
 		rc = -ENOMEM;
 		goto out;
 	}
 	snprintf((*algified_name), algified_name_len, "%s(%s)",
 		 chaining_modifier, cipher_name);
 	rc = 0;
 out:
 	return rc;
 }
 /**
  * ecryptfs_derive_iv
  * @iv: destination for the derived iv vale
  * @crypt_stat: Pointer to crypt_stat struct for the current inode
  * @offset: Offset of the extent whose IV we are to derive
  *
  * Generate the initialization vector from the given root IV and page
  * offset.
  *
  * Returns zero on success; non-zero on error.
  */
 int ecryptfs_derive_iv(char *iv, struct ecryptfs_crypt_stat *crypt_stat,
 		       loff_t offset)
 {
 	int rc = 0;
 	char dst[MD5_DIGEST_SIZE];
 	char src[ECRYPTFS_MAX_IV_BYTES + 16];
 	if (unlikely(ecryptfs_verbosity > 0)) {
 		ecryptfs_printk(KERN_DEBUG, "root iv:\n");
 		ecryptfs_dump_hex(crypt_stat->root_iv, crypt_stat->iv_bytes);
 	}
 	/* TODO: It is probably secure to just cast the least
 	 * significant bits of the root IV into an unsigned long and
 	 * add the offset to that rather than go through all this
 	 * hashing business. -Halcrow */
 	memcpy(src, crypt_stat->root_iv, crypt_stat->iv_bytes);
 	memset((src + crypt_stat->iv_bytes), 0, 16);
 	snprintf((src + crypt_stat->iv_bytes), 16, "%lld", offset);
 	if (unlikely(ecryptfs_verbosity > 0)) {
 		ecryptfs_printk(KERN_DEBUG, "source:\n");
 		ecryptfs_dump_hex(src, (crypt_stat->iv_bytes + 16));
 	}
 	rc = ecryptfs_calculate_md5(dst, crypt_stat, src,
 				    (crypt_stat->iv_bytes + 16));
 	if (rc) {
 		ecryptfs_printk(KERN_WARNING, "Error attempting to compute "
 				"MD5 while generating IV for a page\n");
 		goto out;
 	}
 	memcpy(iv, dst, crypt_stat->iv_bytes);
 	if (unlikely(ecryptfs_verbosity > 0)) {
 		ecryptfs_printk(KERN_DEBUG, "derived iv:\n");
 		ecryptfs_dump_hex(iv, crypt_stat->iv_bytes);
 	}
 out:
 	return rc;
 }
 /**
  * ecryptfs_init_crypt_stat
  * @crypt_stat: Pointer to the crypt_stat struct to initialize.
  *
  * Initialize the crypt_stat structure.
  */
 void
 ecryptfs_init_crypt_stat(struct ecryptfs_crypt_stat *crypt_stat)
 {
 	memset((void *)crypt_stat, 0, sizeof(struct ecryptfs_crypt_stat));
 	INIT_LIST_HEAD(&crypt_stat->keysig_list);
 	mutex_init(&crypt_stat->keysig_list_mutex);
 	mutex_init(&crypt_stat->cs_mutex);
 	mutex_init(&crypt_stat->cs_tfm_mutex);
 	mutex_init(&crypt_stat->cs_hash_tfm_mutex);
 	crypt_stat->flags |= ECRYPTFS_STRUCT_INITIALIZED;
 }
 /**
  * ecryptfs_destroy_crypt_stat
  * @crypt_stat: Pointer to the crypt_stat struct to initialize.
  *
  * Releases all memory associated with a crypt_stat struct.
  */
 void ecryptfs_destroy_crypt_stat(struct ecryptfs_crypt_stat *crypt_stat)
 {
 	struct ecryptfs_key_sig *key_sig, *key_sig_tmp;
 	if (crypt_stat->tfm)
 		crypto_free_ablkcipher(crypt_stat->tfm);
 	if (crypt_stat->hash_tfm)
 		crypto_free_hash(crypt_stat->hash_tfm);
 	list_for_each_entry_safe(key_sig, key_sig_tmp,
 				 &crypt_stat->keysig_list, crypt_stat_list) {
 		list_del(&key_sig->crypt_stat_list);
 		kmem_cache_free(ecryptfs_key_sig_cache, key_sig);
 	}
 	memset(crypt_stat, 0, sizeof(struct ecryptfs_crypt_stat));
 }
 void ecryptfs_destroy_mount_crypt_stat(
 	struct ecryptfs_mount_crypt_stat *mount_crypt_stat)
 {
 	struct ecryptfs_global_auth_tok *auth_tok, *auth_tok_tmp;
 	if (!(mount_crypt_stat->flags & ECRYPTFS_MOUNT_CRYPT_STAT_INITIALIZED))
 		return;
 	mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex);
 	list_for_each_entry_safe(auth_tok, auth_tok_tmp,
 				 &mount_crypt_stat->global_auth_tok_list,
 				 mount_crypt_stat_list) {
 		list_del(&auth_tok->mount_crypt_stat_list);
 		if (auth_tok->global_auth_tok_key
 		    && !(auth_tok->flags & ECRYPTFS_AUTH_TOK_INVALID))
 			key_put(auth_tok->global_auth_tok_key);
 		kmem_cache_free(ecryptfs_global_auth_tok_cache, auth_tok);
 	}
 	mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex);
 	memset(mount_crypt_stat, 0, sizeof(struct ecryptfs_mount_crypt_stat));
 }
 /**
  * virt_to_scatterlist
  * @addr: Virtual address
  * @size: Size of data; should be an even multiple of the block size
  * @sg: Pointer to scatterlist array; set to NULL to obtain only
  *      the number of scatterlist structs required in array
  * @sg_size: Max array size
  *
  * Fills in a scatterlist array with page references for a passed
  * virtual address.
  *
  * Returns the number of scatterlist structs in array used
  */
 int virt_to_scatterlist(const void *addr, int size, struct scatterlist *sg,
 			int sg_size)
 {
 	int i = 0;
 	struct page *pg;
 	int offset;
 	int remainder_of_page;
 	sg_init_table(sg, sg_size);
 	while (size > 0 && i < sg_size) {
 		pg = virt_to_page(addr);
 		offset = offset_in_page(addr);
 		sg_set_page(&sg[i], pg, 0, offset);
 		remainder_of_page = PAGE_CACHE_SIZE - offset;
 		if (size >= remainder_of_page) {
 			sg[i].length = remainder_of_page;
 			addr += remainder_of_page;
 			size -= remainder_of_page;
 		} else {
 			sg[i].length = size;
 			addr += size;
 			size = 0;
 		}
 		i++;
 	}
 	if (size > 0)
 		return -ENOMEM;
 	return i;
 }
 struct extent_crypt_result {
 	struct completion completion;
 	int rc;
 };
 static void extent_crypt_complete(struct crypto_async_request *req, int rc)
 {
 	struct extent_crypt_result *ecr = req->data;
 	if (rc == -EINPROGRESS)
 		return;
 	ecr->rc = rc;
 	complete(&ecr->completion);
 }
 /**
  * crypt_scatterlist
  * @crypt_stat: Pointer to the crypt_stat struct to initialize.
  * @dst_sg: Destination of the data after performing the crypto operation
  * @src_sg: Data to be encrypted or decrypted
  * @size: Length of data
  * @iv: IV to use
  * @op: ENCRYPT or DECRYPT to indicate the desired operation
  *
  * Returns the number of bytes encrypted or decrypted; negative value on error
  */
 static int crypt_scatterlist(struct ecryptfs_crypt_stat *crypt_stat,
 			     struct scatterlist *dst_sg,
 			     struct scatterlist *src_sg, int size,
 			     unsigned char *iv, int op)
 {
 	struct ablkcipher_request *req = NULL;
 	struct extent_crypt_result ecr;
 	int rc = 0;
 	BUG_ON(!crypt_stat || !crypt_stat->tfm
 	       || !(crypt_stat->flags & ECRYPTFS_STRUCT_INITIALIZED));
 	if (unlikely(ecryptfs_verbosity > 0)) {
 		ecryptfs_printk(KERN_DEBUG, "Key size [%zd]; key:\n",
 				crypt_stat->key_size);
 		ecryptfs_dump_hex(crypt_stat->key,
 				  crypt_stat->key_size);
 	}
 	init_completion(&ecr.completion);
 	mutex_lock(&crypt_stat->cs_tfm_mutex);
 	req = ablkcipher_request_alloc(crypt_stat->tfm, GFP_NOFS);
 	if (!req) {
 		mutex_unlock(&crypt_stat->cs_tfm_mutex);
 		rc = -ENOMEM;
 		goto out;
 	}
 	ablkcipher_request_set_callback(req,
 			CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,
 			extent_crypt_complete, &ecr);
 	/* Consider doing this once, when the file is opened */
 	if (!(crypt_stat->flags & ECRYPTFS_KEY_SET)) {
 		rc = crypto_ablkcipher_setkey(crypt_stat->tfm, crypt_stat->key,
 					      crypt_stat->key_size);
 		if (rc) {
 			ecryptfs_printk(KERN_ERR,
 					"Error setting key; rc = [%d]\n",
 					rc);
 			mutex_unlock(&crypt_stat->cs_tfm_mutex);
 			rc = -EINVAL;
 			goto out;
 		}
 		crypt_stat->flags |= ECRYPTFS_KEY_SET;
 	}
 	mutex_unlock(&crypt_stat->cs_tfm_mutex);
 	ablkcipher_request_set_crypt(req, src_sg, dst_sg, size, iv);
 	rc = op == ENCRYPT ? crypto_ablkcipher_encrypt(req) :
 			     crypto_ablkcipher_decrypt(req);
 	if (rc == -EINPROGRESS || rc == -EBUSY) {
 		struct extent_crypt_result *ecr = req->base.data;
 		wait_for_completion(&ecr->completion);
 		rc = ecr->rc;
 		reinit_completion(&ecr->completion);
 	}
 out:
 	ablkcipher_request_free(req);
 	return rc;
 }
 /**
  * lower_offset_for_page
  *
  * Convert an eCryptfs page index into a lower byte offset
  */
 static loff_t lower_offset_for_page(struct ecryptfs_crypt_stat *crypt_stat,
 				    struct page *page)
 {
 	return ecryptfs_lower_header_size(crypt_stat) +
 	       ((loff_t)page->index << PAGE_CACHE_SHIFT);
 }
 /**
  * crypt_extent
  * @crypt_stat: crypt_stat containing cryptographic context for the
  *              encryption operation
  * @dst_page: The page to write the result into
  * @src_page: The page to read from
  * @extent_offset: Page extent offset for use in generating IV
  * @op: ENCRYPT or DECRYPT to indicate the desired operation
  *
  * Encrypts or decrypts one extent of data.
  *
  * Return zero on success; non-zero otherwise
  */
 static int crypt_extent(struct ecryptfs_crypt_stat *crypt_stat,
 			struct page *dst_page,
 			struct page *src_page,
 			unsigned long extent_offset, int op)
 {
 	pgoff_t page_index = op == ENCRYPT ? src_page->index : dst_page->index;
 	loff_t extent_base;
 	char extent_iv[ECRYPTFS_MAX_IV_BYTES];
 	struct scatterlist src_sg, dst_sg;
 	size_t extent_size = crypt_stat->extent_size;
 	int rc;
 	extent_base = (((loff_t)page_index) * (PAGE_CACHE_SIZE / extent_size));
 	rc = ecryptfs_derive_iv(extent_iv, crypt_stat,
 				(extent_base + extent_offset));
 	if (rc) {
 		ecryptfs_printk(KERN_ERR, "Error attempting to derive IV for "
 			"extent [0x%.16llx]; rc = [%d]\n",
 			(unsigned long long)(extent_base + extent_offset), rc);
 		goto out;
 	}
 	sg_init_table(&src_sg, 1);
 	sg_init_table(&dst_sg, 1);
 	sg_set_page(&src_sg, src_page, extent_size,
 		    extent_offset * extent_size);
 	sg_set_page(&dst_sg, dst_page, extent_size,
 		    extent_offset * extent_size);
 	rc = crypt_scatterlist(crypt_stat, &dst_sg, &src_sg, extent_size,
 			       extent_iv, op);
 	if (rc < 0) {
 		printk(KERN_ERR "%s: Error attempting to crypt page with "
 		       "page_index = [%ld], extent_offset = [%ld]; "
 		       "rc = [%d]\n", __func__, page_index, extent_offset, rc);
 		goto out;
 	}
 	rc = 0;
 out:
 	return rc;
 }
 /**
  * ecryptfs_encrypt_page
  * @page: Page mapped from the eCryptfs inode for the file; contains
  *        decrypted content that needs to be encrypted (to a temporary
  *        page; not in place) and written out to the lower file
  *
  * Encrypt an eCryptfs page. This is done on a per-extent basis. Note
  * that eCryptfs pages may straddle the lower pages -- for instance,
  * if the file was created on a machine with an 8K page size
  * (resulting in an 8K header), and then the file is copied onto a
  * host with a 32K page size, then when reading page 0 of the eCryptfs
  * file, 24K of page 0 of the lower file will be read and decrypted,
  * and then 8K of page 1 of the lower file will be read and decrypted.
  *
  * Returns zero on success; negative on error
  */
 int ecryptfs_encrypt_page(struct page *page)
 {
 	struct inode *ecryptfs_inode;
 	struct ecryptfs_crypt_stat *crypt_stat;
 	char *enc_extent_virt;
 	struct page *enc_extent_page = NULL;
 	loff_t extent_offset;
 	loff_t lower_offset;
 	int rc = 0;
 	ecryptfs_inode = page->mapping->host;
 	crypt_stat =
 		&(ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat);
 	BUG_ON(!(crypt_stat->flags & ECRYPTFS_ENCRYPTED));
 	enc_extent_page = alloc_page(GFP_USER);
 	if (!enc_extent_page) {
 		rc = -ENOMEM;
 		ecryptfs_printk(KERN_ERR, "Error allocating memory for "
 				"encrypted extent\n");
 		goto out;
 	}
 	for (extent_offset = 0;
 	     extent_offset < (PAGE_CACHE_SIZE / crypt_stat->extent_size);
 	     extent_offset++) {
 		rc = crypt_extent(crypt_stat, enc_extent_page, page,
 				  extent_offset, ENCRYPT);
 		if (rc) {
 			printk(KERN_ERR "%s: Error encrypting extent; "
 			       "rc = [%d]\n", __func__, rc);
 			goto out;
 		}
 	}
 	lower_offset = lower_offset_for_page(crypt_stat, page);
 	enc_extent_virt = kmap(enc_extent_page);
 	rc = ecryptfs_write_lower(ecryptfs_inode, enc_extent_virt, lower_offset,
 				  PAGE_CACHE_SIZE);
 	kunmap(enc_extent_page);
 	if (rc < 0) {
 		ecryptfs_printk(KERN_ERR,
 			"Error attempting to write lower page; rc = [%d]\n",
 			rc);
 		goto out;
 	}
 	rc = 0;
 out:
 	if (enc_extent_page) {
 		__free_page(enc_extent_page);
 	}
 	return rc;
 }
 /**
  * ecryptfs_decrypt_page
  * @page: Page mapped from the eCryptfs inode for the file; data read
  *        and decrypted from the lower file will be written into this
  *        page
  *
  * Decrypt an eCryptfs page. This is done on a per-extent basis. Note
  * that eCryptfs pages may straddle the lower pages -- for instance,
  * if the file was created on a machine with an 8K page size
  * (resulting in an 8K header), and then the file is copied onto a
  * host with a 32K page size, then when reading page 0 of the eCryptfs
  * file, 24K of page 0 of the lower file will be read and decrypted,
  * and then 8K of page 1 of the lower file will be read and decrypted.
  *
  * Returns zero on success; negative on error
  */
 int ecryptfs_decrypt_page(struct page *page)
 {
 	struct inode *ecryptfs_inode;
 	struct ecryptfs_crypt_stat *crypt_stat;
 	char *page_virt;
 	unsigned long extent_offset;
 	loff_t lower_offset;
 	int rc = 0;
 	ecryptfs_inode = page->mapping->host;
 	crypt_stat =
 		&(ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat);
 	BUG_ON(!(crypt_stat->flags & ECRYPTFS_ENCRYPTED));
 	lower_offset = lower_offset_for_page(crypt_stat, page);
 	page_virt = kmap(page);
 	rc = ecryptfs_read_lower(page_virt, lower_offset, PAGE_CACHE_SIZE,
 				 ecryptfs_inode);
 	kunmap(page);
 	if (rc < 0) {
 		ecryptfs_printk(KERN_ERR,
 			"Error attempting to read lower page; rc = [%d]\n",
 			rc);
 		goto out;
 	}
 	for (extent_offset = 0;
 	     extent_offset < (PAGE_CACHE_SIZE / crypt_stat->extent_size);
 	     extent_offset++) {
 		rc = crypt_extent(crypt_stat, page, page,
 				  extent_offset, DECRYPT);
 		if (rc) {
 			printk(KERN_ERR "%s: Error encrypting extent; "
 			       "rc = [%d]\n", __func__, rc);
 			goto out;
 		}
 	}
 out:
 	return rc;
 }
 #define ECRYPTFS_MAX_SCATTERLIST_LEN 4
 /**
  * ecryptfs_init_crypt_ctx
  * @crypt_stat: Uninitialized crypt stats structure
  *
  * Initialize the crypto context.
  *
  * TODO: Performance: Keep a cache of initialized cipher contexts;
  * only init if needed
  */
 int ecryptfs_init_crypt_ctx(struct ecryptfs_crypt_stat *crypt_stat)
 {
 	char *full_alg_name;
 	int rc = -EINVAL;
 	ecryptfs_printk(KERN_DEBUG,
 			"Initializing cipher [%s]; strlen = [%d]; "
 			"key_size_bits = [%zd]\n",
 			crypt_stat->cipher, (int)strlen(crypt_stat->cipher),
 			crypt_stat->key_size << 3);
 	mutex_lock(&crypt_stat->cs_tfm_mutex);
 	if (crypt_stat->tfm) {
 		rc = 0;
 		goto out_unlock;
 	}
 	rc = ecryptfs_crypto_api_algify_cipher_name(&full_alg_name,
 						    crypt_stat->cipher, "cbc");
 	if (rc)
 		goto out_unlock;
 	crypt_stat->tfm = crypto_alloc_ablkcipher(full_alg_name, 0, 0);
 	if (IS_ERR(crypt_stat->tfm)) {
 		rc = PTR_ERR(crypt_stat->tfm);
 		crypt_stat->tfm = NULL;
 		ecryptfs_printk(KERN_ERR, "cryptfs: init_crypt_ctx(): "
 				"Error initializing cipher [%s]\n",
 				full_alg_name);
 		goto out_free;
 	}
 	crypto_ablkcipher_set_flags(crypt_stat->tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 	rc = 0;
 out_free:
 	kfree(full_alg_name);
 out_unlock:
 	mutex_unlock(&crypt_stat->cs_tfm_mutex);
 	return rc;
 }
 static void set_extent_mask_and_shift(struct ecryptfs_crypt_stat *crypt_stat)
 {
 	int extent_size_tmp;
 	crypt_stat->extent_mask = 0xFFFFFFFF;
 	crypt_stat->extent_shift = 0;
 	if (crypt_stat->extent_size == 0)
 		return;
 	extent_size_tmp = crypt_stat->extent_size;
 	while ((extent_size_tmp & 0x01) == 0) {
 		extent_size_tmp >>= 1;
 		crypt_stat->extent_mask <<= 1;
 		crypt_stat->extent_shift++;
 	}
 }
 void ecryptfs_set_default_sizes(struct ecryptfs_crypt_stat *crypt_stat)
 {
 	/* Default values; may be overwritten as we are parsing the
 	 * packets. */
 	crypt_stat->extent_size = ECRYPTFS_DEFAULT_EXTENT_SIZE;
 	set_extent_mask_and_shift(crypt_stat);
 	crypt_stat->iv_bytes = ECRYPTFS_DEFAULT_IV_BYTES;
 	if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR)
 		crypt_stat->metadata_size = ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE;
 	else {
 		if (PAGE_CACHE_SIZE <= ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE)
 			crypt_stat->metadata_size =
 				ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE;
 		else
 			crypt_stat->metadata_size = PAGE_CACHE_SIZE;
 	}
 }
 /**
  * ecryptfs_compute_root_iv
  * @crypt_stats
  *
  * On error, sets the root IV to all 0's.
  */
 int ecryptfs_compute_root_iv(struct ecryptfs_crypt_stat *crypt_stat)
 {
 	int rc = 0;
 	char dst[MD5_DIGEST_SIZE];
 	BUG_ON(crypt_stat->iv_bytes > MD5_DIGEST_SIZE);
 	BUG_ON(crypt_stat->iv_bytes <= 0);
 	if (!(crypt_stat->flags & ECRYPTFS_KEY_VALID)) {
 		rc = -EINVAL;
 		ecryptfs_printk(KERN_WARNING, "Session key not valid; "
 				"cannot generate root IV\n");
 		goto out;
 	}
 	rc = ecryptfs_calculate_md5(dst, crypt_stat, crypt_stat->key,
 				    crypt_stat->key_size);
 	if (rc) {
 		ecryptfs_printk(KERN_WARNING, "Error attempting to compute "
 				"MD5 while generating root IV\n");
 		goto out;
 	}
 	memcpy(crypt_stat->root_iv, dst, crypt_stat->iv_bytes);
 out:
 	if (rc) {
 		memset(crypt_stat->root_iv, 0, crypt_stat->iv_bytes);
 		crypt_stat->flags |= ECRYPTFS_SECURITY_WARNING;
 	}
 	return rc;
 }
 static void ecryptfs_generate_new_key(struct ecryptfs_crypt_stat *crypt_stat)
 {
 	get_random_bytes(crypt_stat->key, crypt_stat->key_size);
 	crypt_stat->flags |= ECRYPTFS_KEY_VALID;
 	ecryptfs_compute_root_iv(crypt_stat);
 	if (unlikely(ecryptfs_verbosity > 0)) {
 		ecryptfs_printk(KERN_DEBUG, "Generated new session key:\n");
 		ecryptfs_dump_hex(crypt_stat->key,
 				  crypt_stat->key_size);
 	}
 }
 /**
  * ecryptfs_copy_mount_wide_flags_to_inode_flags
  * @crypt_stat: The inode's cryptographic context
  * @mount_crypt_stat: The mount point's cryptographic context
  *
  * This function propagates the mount-wide flags to individual inode
  * flags.
  */
 static void ecryptfs_copy_mount_wide_flags_to_inode_flags(
 	struct ecryptfs_crypt_stat *crypt_stat,
 	struct ecryptfs_mount_crypt_stat *mount_crypt_stat)
 {
 	if (mount_crypt_stat->flags & ECRYPTFS_XATTR_METADATA_ENABLED)
 		crypt_stat->flags |= ECRYPTFS_METADATA_IN_XATTR;
 	if (mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED)
 		crypt_stat->flags |= ECRYPTFS_VIEW_AS_ENCRYPTED;
 	if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) {
 		crypt_stat->flags |= ECRYPTFS_ENCRYPT_FILENAMES;
 		if (mount_crypt_stat->flags
 		    & ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK)
 			crypt_stat->flags |= ECRYPTFS_ENCFN_USE_MOUNT_FNEK;
 		else if (mount_crypt_stat->flags
 			 & ECRYPTFS_GLOBAL_ENCFN_USE_FEK)
 			crypt_stat->flags |= ECRYPTFS_ENCFN_USE_FEK;
 	}
 }
 static int ecryptfs_copy_mount_wide_sigs_to_inode_sigs(
 	struct ecryptfs_crypt_stat *crypt_stat,
 	struct ecryptfs_mount_crypt_stat *mount_crypt_stat)
 {
 	struct ecryptfs_global_auth_tok *global_auth_tok;
 	int rc = 0;
 	mutex_lock(&crypt_stat->keysig_list_mutex);
 	mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex);
 	list_for_each_entry(global_auth_tok,
 			    &mount_crypt_stat->global_auth_tok_list,
 			    mount_crypt_stat_list) {
 		if (global_auth_tok->flags & ECRYPTFS_AUTH_TOK_FNEK)
 			continue;
 		rc = ecryptfs_add_keysig(crypt_stat, global_auth_tok->sig);
 		if (rc) {
 			printk(KERN_ERR "Error adding keysig; rc = [%d]\n", rc);
 			goto out;
 		}
 	}
 out:
 	mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex);
 	mutex_unlock(&crypt_stat->keysig_list_mutex);
 	return rc;
 }
 /**
  * ecryptfs_set_default_crypt_stat_vals
  * @crypt_stat: The inode's cryptographic context
  * @mount_crypt_stat: The mount point's cryptographic context
  *
  * Default values in the event that policy does not override them.
  */
 static void ecryptfs_set_default_crypt_stat_vals(
 	struct ecryptfs_crypt_stat *crypt_stat,
 	struct ecryptfs_mount_crypt_stat *mount_crypt_stat)
 {
 	ecryptfs_copy_mount_wide_flags_to_inode_flags(crypt_stat,
 						      mount_crypt_stat);
 	ecryptfs_set_default_sizes(crypt_stat);
 	strcpy(crypt_stat->cipher, ECRYPTFS_DEFAULT_CIPHER);
 	crypt_stat->key_size = ECRYPTFS_DEFAULT_KEY_BYTES;
 	crypt_stat->flags &= ~(ECRYPTFS_KEY_VALID);
 	crypt_stat->file_version = ECRYPTFS_FILE_VERSION;
 	crypt_stat->mount_crypt_stat = mount_crypt_stat;
 }
 /**
  * ecryptfs_new_file_context
  * @ecryptfs_inode: The eCryptfs inode
  *
  * If the crypto context for the file has not yet been established,
  * this is where we do that.  Establishing a new crypto context
  * involves the following decisions:
  *  - What cipher to use?
  *  - What set of authentication tokens to use?
  * Here we just worry about getting enough information into the
  * authentication tokens so that we know that they are available.
  * We associate the available authentication tokens with the new file
  * via the set of signatures in the crypt_stat struct.  Later, when
  * the headers are actually written out, we may again defer to
  * userspace to perform the encryption of the session key; for the
  * foreseeable future, this will be the case with public key packets.
  *
  * Returns zero on success; non-zero otherwise
  */
 int ecryptfs_new_file_context(struct inode *ecryptfs_inode)
 {
 	struct ecryptfs_crypt_stat *crypt_stat =
 	    &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
 	struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
 	    &ecryptfs_superblock_to_private(
 		    ecryptfs_inode->i_sb)->mount_crypt_stat;
 	int cipher_name_len;
 	int rc = 0;
 	ecryptfs_set_default_crypt_stat_vals(crypt_stat, mount_crypt_stat);
 	crypt_stat->flags |= (ECRYPTFS_ENCRYPTED | ECRYPTFS_KEY_VALID);
 	ecryptfs_copy_mount_wide_flags_to_inode_flags(crypt_stat,
 						      mount_crypt_stat);
 	rc = ecryptfs_copy_mount_wide_sigs_to_inode_sigs(crypt_stat,
 							 mount_crypt_stat);
 	if (rc) {
 		printk(KERN_ERR "Error attempting to copy mount-wide key sigs "
 		       "to the inode key sigs; rc = [%d]\n", rc);
 		goto out;
 	}
 	cipher_name_len =
 		strlen(mount_crypt_stat->global_default_cipher_name);
 	memcpy(crypt_stat->cipher,
 	       mount_crypt_stat->global_default_cipher_name,
 	       cipher_name_len);
 	crypt_stat->cipher[cipher_name_len] = '\0';
 	crypt_stat->key_size =
 		mount_crypt_stat->global_default_cipher_key_size;
 	ecryptfs_generate_new_key(crypt_stat);
 	rc = ecryptfs_init_crypt_ctx(crypt_stat);
 	if (rc)
 		ecryptfs_printk(KERN_ERR, "Error initializing cryptographic "
 				"context for cipher [%s]: rc = [%d]\n",
 				crypt_stat->cipher, rc);
 out:
 	return rc;
 }
 /**
  * ecryptfs_validate_marker - check for the ecryptfs marker
  * @data: The data block in which to check
  *
  * Returns zero if marker found; -EINVAL if not found
  */
 static int ecryptfs_validate_marker(char *data)
 {
 	u32 m_1, m_2;
 	m_1 = get_unaligned_be32(data);
 	m_2 = get_unaligned_be32(data + 4);
 	if ((m_1 ^ MAGIC_ECRYPTFS_MARKER) == m_2)
 		return 0;
 	ecryptfs_printk(KERN_DEBUG, "m_1 = [0x%.8x]; m_2 = [0x%.8x]; "
 			"MAGIC_ECRYPTFS_MARKER = [0x%.8x]\n", m_1, m_2,
 			MAGIC_ECRYPTFS_MARKER);
 	ecryptfs_printk(KERN_DEBUG, "(m_1 ^ MAGIC_ECRYPTFS_MARKER) = "
 			"[0x%.8x]\n", (m_1 ^ MAGIC_ECRYPTFS_MARKER));
 	return -EINVAL;
 }
 struct ecryptfs_flag_map_elem {
 	u32 file_flag;
 	u32 local_flag;
 };
 /* Add support for additional flags by adding elements here. */
 static struct ecryptfs_flag_map_elem ecryptfs_flag_map[] = {
 	{0x00000001, ECRYPTFS_ENABLE_HMAC},
 	{0x00000002, ECRYPTFS_ENCRYPTED},
 	{0x00000004, ECRYPTFS_METADATA_IN_XATTR},
 	{0x00000008, ECRYPTFS_ENCRYPT_FILENAMES}
 };
 /**
  * ecryptfs_process_flags
  * @crypt_stat: The cryptographic context
  * @page_virt: Source data to be parsed
  * @bytes_read: Updated with the number of bytes read
  *
  * Returns zero on success; non-zero if the flag set is invalid
  */
 static int ecryptfs_process_flags(struct ecryptfs_crypt_stat *crypt_stat,
 				  char *page_virt, int *bytes_read)
 {
 	int rc = 0;
 	int i;
 	u32 flags;
 	flags = get_unaligned_be32(page_virt);
 	for (i = 0; i < ((sizeof(ecryptfs_flag_map)
 			  / sizeof(struct ecryptfs_flag_map_elem))); i++)
 		if (flags & ecryptfs_flag_map[i].file_flag) {
 			crypt_stat->flags |= ecryptfs_flag_map[i].local_flag;
 		} else
 			crypt_stat->flags &= ~(ecryptfs_flag_map[i].local_flag);
 	/* Version is in top 8 bits of the 32-bit flag vector */
 	crypt_stat->file_version = ((flags >> 24) & 0xFF);
 	(*bytes_read) = 4;
 	return rc;
 }
 /**
  * write_ecryptfs_marker
  * @page_virt: The pointer to in a page to begin writing the marker
  * @written: Number of bytes written
  *
  * Marker = 0x3c81b7f5
  */
 static void write_ecryptfs_marker(char *page_virt, size_t *written)
 {
 	u32 m_1, m_2;
 	get_random_bytes(&m_1, (MAGIC_ECRYPTFS_MARKER_SIZE_BYTES / 2));
 	m_2 = (m_1 ^ MAGIC_ECRYPTFS_MARKER);
 	put_unaligned_be32(m_1, page_virt);
 	page_virt += (MAGIC_ECRYPTFS_MARKER_SIZE_BYTES / 2);
 	put_unaligned_be32(m_2, page_virt);
 	(*written) = MAGIC_ECRYPTFS_MARKER_SIZE_BYTES;
 }
 void ecryptfs_write_crypt_stat_flags(char *page_virt,
 				     struct ecryptfs_crypt_stat *crypt_stat,
 				     size_t *written)
 {
 	u32 flags = 0;
 	int i;
 	for (i = 0; i < ((sizeof(ecryptfs_flag_map)
 			  / sizeof(struct ecryptfs_flag_map_elem))); i++)
 		if (crypt_stat->flags & ecryptfs_flag_map[i].local_flag)
 			flags |= ecryptfs_flag_map[i].file_flag;
 	/* Version is in top 8 bits of the 32-bit flag vector */
 	flags |= ((((u8)crypt_stat->file_version) << 24) & 0xFF000000);
 	put_unaligned_be32(flags, page_virt);
 	(*written) = 4;
 }
 struct ecryptfs_cipher_code_str_map_elem {
 	char cipher_str[16];
 	u8 cipher_code;
 };
 /* Add support for additional ciphers by adding elements here. The
  * cipher_code is whatever OpenPGP applicatoins use to identify the
  * ciphers. List in order of probability. */
 static struct ecryptfs_cipher_code_str_map_elem
 ecryptfs_cipher_code_str_map[] = {
 	{"aes",RFC2440_CIPHER_AES_128 },
 	{"blowfish", RFC2440_CIPHER_BLOWFISH},
 	{"des3_ede", RFC2440_CIPHER_DES3_EDE},
 	{"cast5", RFC2440_CIPHER_CAST_5},
 	{"twofish", RFC2440_CIPHER_TWOFISH},
 	{"cast6", RFC2440_CIPHER_CAST_6},
 	{"aes", RFC2440_CIPHER_AES_192},
 	{"aes", RFC2440_CIPHER_AES_256}
 };
 /**
  * ecryptfs_code_for_cipher_string
  * @cipher_name: The string alias for the cipher
  * @key_bytes: Length of key in bytes; used for AES code selection
  *
  * Returns zero on no match, or the cipher code on match
  */
 u8 ecryptfs_code_for_cipher_string(char *cipher_name, size_t key_bytes)
 {
 	int i;
 	u8 code = 0;
 	struct ecryptfs_cipher_code_str_map_elem *map =
 		ecryptfs_cipher_code_str_map;
 	if (strcmp(cipher_name, "aes") == 0) {
 		switch (key_bytes) {
 		case 16:
 			code = RFC2440_CIPHER_AES_128;
 			break;
 		case 24:
 			code = RFC2440_CIPHER_AES_192;
 			break;
 		case 32:
 			code = RFC2440_CIPHER_AES_256;
 		}
 	} else {
 		for (i = 0; i < ARRAY_SIZE(ecryptfs_cipher_code_str_map); i++)
 			if (strcmp(cipher_name, map[i].cipher_str) == 0) {
 				code = map[i].cipher_code;
 				break;
 			}
 	}
 	return code;
 }
 /**
  * ecryptfs_cipher_code_to_string
  * @str: Destination to write out the cipher name
  * @cipher_code: The code to convert to cipher name string
  *
  * Returns zero on success
  */
 int ecryptfs_cipher_code_to_string(char *str, u8 cipher_code)
 {
 	int rc = 0;
 	int i;
 	str[0] = '\0';
 	for (i = 0; i < ARRAY_SIZE(ecryptfs_cipher_code_str_map); i++)
 		if (cipher_code == ecryptfs_cipher_code_str_map[i].cipher_code)
 			strcpy(str, ecryptfs_cipher_code_str_map[i].cipher_str);
 	if (str[0] == '\0') {
 		ecryptfs_printk(KERN_WARNING, "Cipher code not recognized: "
 				"[%d]\n", cipher_code);
 		rc = -EINVAL;
 	}
 	return rc;
 }
 int ecryptfs_read_and_validate_header_region(struct inode *inode)
 {
 	u8 file_size[ECRYPTFS_SIZE_AND_MARKER_BYTES];
 	u8 *marker = file_size + ECRYPTFS_FILE_SIZE_BYTES;
 	int rc;
 	rc = ecryptfs_read_lower(file_size, 0, ECRYPTFS_SIZE_AND_MARKER_BYTES,
 				 inode);
 	if (rc < ECRYPTFS_SIZE_AND_MARKER_BYTES)
 		return rc >= 0 ? -EINVAL : rc;
 	rc = ecryptfs_validate_marker(marker);
 	if (!rc)
 		ecryptfs_i_size_init(file_size, inode);
 	return rc;
 }
 void
 ecryptfs_write_header_metadata(char *virt,
 			       struct ecryptfs_crypt_stat *crypt_stat,
 			       size_t *written)
 {
 	u32 header_extent_size;
 	u16 num_header_extents_at_front;
 	header_extent_size = (u32)crypt_stat->extent_size;
 	num_header_extents_at_front =
 		(u16)(crypt_stat->metadata_size / crypt_stat->extent_size);
 	put_unaligned_be32(header_extent_size, virt);
 	virt += 4;
 	put_unaligned_be16(num_header_extents_at_front, virt);
 	(*written) = 6;
 }
 struct kmem_cache *ecryptfs_header_cache;
 /**
  * ecryptfs_write_headers_virt
  * @page_virt: The virtual address to write the headers to
  * @max: The size of memory allocated at page_virt
  * @size: Set to the number of bytes written by this function
  * @crypt_stat: The cryptographic context
  * @ecryptfs_dentry: The eCryptfs dentry
  *
  * Format version: 1
  *
  *   Header Extent:
  *     Octets 0-7:        Unencrypted file size (big-endian)
  *     Octets 8-15:       eCryptfs special marker
  *     Octets 16-19:      Flags
  *      Octet 16:         File format version number (between 0 and 255)
  *      Octets 17-18:     Reserved
  *      Octet 19:         Bit 1 (lsb): Reserved
  *                        Bit 2: Encrypted?
  *                        Bits 3-8: Reserved
  *     Octets 20-23:      Header extent size (big-endian)
  *     Octets 24-25:      Number of header extents at front of file
  *                        (big-endian)
  *     Octet  26:         Begin RFC 2440 authentication token packet set
  *   Data Extent 0:
  *     Lower data (CBC encrypted)
  *   Data Extent 1:
  *     Lower data (CBC encrypted)
  *   ...
  *
  * Returns zero on success
  */
 static int ecryptfs_write_headers_virt(char *page_virt, size_t max,
 				       size_t *size,
 				       struct ecryptfs_crypt_stat *crypt_stat,
 				       struct dentry *ecryptfs_dentry)
 {
 	int rc;
 	size_t written;
 	size_t offset;
 	offset = ECRYPTFS_FILE_SIZE_BYTES;
 	write_ecryptfs_marker((page_virt + offset), &written);
 	offset += written;
 	ecryptfs_write_crypt_stat_flags((page_virt + offset), crypt_stat,
 					&written);
 	offset += written;
 	ecryptfs_write_header_metadata((page_virt + offset), crypt_stat,
 				       &written);
 	offset += written;
 	rc = ecryptfs_generate_key_packet_set((page_virt + offset), crypt_stat,
 					      ecryptfs_dentry, &written,
 					      max - offset);
 	if (rc)
 		ecryptfs_printk(KERN_WARNING, "Error generating key packet "
 				"set; rc = [%d]\n", rc);
 	if (size) {
 		offset += written;
 		*size = offset;
 	}
 	return rc;
 }
 static int
 ecryptfs_write_metadata_to_contents(struct inode *ecryptfs_inode,
 				    char *virt, size_t virt_len)
 {
 	int rc;
 	rc = ecryptfs_write_lower(ecryptfs_inode, virt,
 				  0, virt_len);
 	if (rc < 0)
 		printk(KERN_ERR "%s: Error attempting to write header "
 		       "information to lower file; rc = [%d]\n", __func__, rc);
 	else
 		rc = 0;
 	return rc;
 }
 static int
 ecryptfs_write_metadata_to_xattr(struct dentry *ecryptfs_dentry,
 				 char *page_virt, size_t size)
 {
 	int rc;
 	rc = ecryptfs_setxattr(ecryptfs_dentry, ECRYPTFS_XATTR_NAME, page_virt,
 			       size, 0);
 	return rc;
 }
 static unsigned long ecryptfs_get_zeroed_pages(gfp_t gfp_mask,
 					       unsigned int order)
 {
 	struct page *page;
 	page = alloc_pages(gfp_mask | __GFP_ZERO, order);
 	if (page)
 		return (unsigned long) page_address(page);
 	return 0;
 }
 /**
  * ecryptfs_write_metadata
  * @ecryptfs_dentry: The eCryptfs dentry, which should be negative
  * @ecryptfs_inode: The newly created eCryptfs inode
  *
  * Write the file headers out.  This will likely involve a userspace
  * callout, in which the session key is encrypted with one or more
  * public keys and/or the passphrase necessary to do the encryption is
  * retrieved via a prompt.  Exactly what happens at this point should
  * be policy-dependent.
  *
  * Returns zero on success; non-zero on error
  */
 int ecryptfs_write_metadata(struct dentry *ecryptfs_dentry,
 			    struct inode *ecryptfs_inode)
 {
 	struct ecryptfs_crypt_stat *crypt_stat =
 		&ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
 	unsigned int order;
 	char *virt;
 	size_t virt_len;
 	size_t size = 0;
 	int rc = 0;
 	if (likely(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
 		if (!(crypt_stat->flags & ECRYPTFS_KEY_VALID)) {
 			printk(KERN_ERR "Key is invalid; bailing out\n");
 			rc = -EINVAL;
 			goto out;
 		}
 	} else {
 		printk(KERN_WARNING "%s: Encrypted flag not set\n",
 		       __func__);
 		rc = -EINVAL;
 		goto out;
 	}
 	virt_len = crypt_stat->metadata_size;
 	order = get_order(virt_len);
 	/* Released in this function */
 	virt = (char *)ecryptfs_get_zeroed_pages(GFP_KERNEL, order);
 	if (!virt) {
 		printk(KERN_ERR "%s: Out of memory\n", __func__);
 		rc = -ENOMEM;
 		goto out;
 	}
 	/* Zeroed page ensures the in-header unencrypted i_size is set to 0 */
 	rc = ecryptfs_write_headers_virt(virt, virt_len, &size, crypt_stat,
 					 ecryptfs_dentry);
 	if (unlikely(rc)) {
 		printk(KERN_ERR "%s: Error whilst writing headers; rc = [%d]\n",
 		       __func__, rc);
 		goto out_free;
 	}
 	if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR)
 		rc = ecryptfs_write_metadata_to_xattr(ecryptfs_dentry, virt,
 						      size);
 	else
 		rc = ecryptfs_write_metadata_to_contents(ecryptfs_inode, virt,
 							 virt_len);
 	if (rc) {
 		printk(KERN_ERR "%s: Error writing metadata out to lower file; "
 		       "rc = [%d]\n", __func__, rc);
 		goto out_free;
 	}
 out_free:
 	free_pages((unsigned long)virt, order);
 out:
 	return rc;
 }
 #define ECRYPTFS_DONT_VALIDATE_HEADER_SIZE 0
 #define ECRYPTFS_VALIDATE_HEADER_SIZE 1
 static int parse_header_metadata(struct ecryptfs_crypt_stat *crypt_stat,
 				 char *virt, int *bytes_read,
 				 int validate_header_size)
 {
 	int rc = 0;
 	u32 header_extent_size;
 	u16 num_header_extents_at_front;
 	header_extent_size = get_unaligned_be32(virt);
 	virt += sizeof(__be32);
 	num_header_extents_at_front = get_unaligned_be16(virt);
 	crypt_stat->metadata_size = (((size_t)num_header_extents_at_front
 				     * (size_t)header_extent_size));
 	(*bytes_read) = (sizeof(__be32) + sizeof(__be16));
 	if ((validate_header_size == ECRYPTFS_VALIDATE_HEADER_SIZE)
 	    && (crypt_stat->metadata_size
 		< ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE)) {
 		rc = -EINVAL;
 		printk(KERN_WARNING "Invalid header size: [%zd]\n",
 		       crypt_stat->metadata_size);
 	}
 	return rc;
 }
 /**
  * set_default_header_data
  * @crypt_stat: The cryptographic context
  *
  * For version 0 file format; this function is only for backwards
  * compatibility for files created with the prior versions of
  * eCryptfs.
  */
 static void set_default_header_data(struct ecryptfs_crypt_stat *crypt_stat)
 {
 	crypt_stat->metadata_size = ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE;
 }
 void ecryptfs_i_size_init(const char *page_virt, struct inode *inode)
 {
 	struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
 	struct ecryptfs_crypt_stat *crypt_stat;
 	u64 file_size;
 	crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
 	mount_crypt_stat =
 		&ecryptfs_superblock_to_private(inode->i_sb)->mount_crypt_stat;
 	if (mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED) {
 		file_size = i_size_read(ecryptfs_inode_to_lower(inode));
 		if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR)
 			file_size += crypt_stat->metadata_size;
 	} else
 		file_size = get_unaligned_be64(page_virt);
 	i_size_write(inode, (loff_t)file_size);
 	crypt_stat->flags |= ECRYPTFS_I_SIZE_INITIALIZED;
 }
 /**
  * ecryptfs_read_headers_virt
  * @page_virt: The virtual address into which to read the headers
  * @crypt_stat: The cryptographic context
  * @ecryptfs_dentry: The eCryptfs dentry
  * @validate_header_size: Whether to validate the header size while reading
  *
  * Read/parse the header data. The header format is detailed in the
  * comment block for the ecryptfs_write_headers_virt() function.
  *
  * Returns zero on success
  */
 static int ecryptfs_read_headers_virt(char *page_virt,
 				      struct ecryptfs_crypt_stat *crypt_stat,
 				      struct dentry *ecryptfs_dentry,
 				      int validate_header_size)
 {
 	int rc = 0;
 	int offset;
 	int bytes_read;
 	ecryptfs_set_default_sizes(crypt_stat);
 	crypt_stat->mount_crypt_stat = &ecryptfs_superblock_to_private(
 		ecryptfs_dentry->d_sb)->mount_crypt_stat;
 	offset = ECRYPTFS_FILE_SIZE_BYTES;
 	rc = ecryptfs_validate_marker(page_virt + offset);
 	if (rc)
 		goto out;
 	if (!(crypt_stat->flags & ECRYPTFS_I_SIZE_INITIALIZED))
 		ecryptfs_i_size_init(page_virt, ecryptfs_dentry->d_inode);
 	offset += MAGIC_ECRYPTFS_MARKER_SIZE_BYTES;
 	rc = ecryptfs_process_flags(crypt_stat, (page_virt + offset),
 				    &bytes_read);
 	if (rc) {
 		ecryptfs_printk(KERN_WARNING, "Error processing flags\n");
 		goto out;
 	}
 	if (crypt_stat->file_version > ECRYPTFS_SUPPORTED_FILE_VERSION) {
 		ecryptfs_printk(KERN_WARNING, "File version is [%d]; only "
 				"file version [%d] is supported by this "
 				"version of eCryptfs\n",
 				crypt_stat->file_version,
 				ECRYPTFS_SUPPORTED_FILE_VERSION);
 		rc = -EINVAL;
 		goto out;
 	}
 	offset += bytes_read;
 	if (crypt_stat->file_version >= 1) {
 		rc = parse_header_metadata(crypt_stat, (page_virt + offset),
 					   &bytes_read, validate_header_size);
 		if (rc) {
 			ecryptfs_printk(KERN_WARNING, "Error reading header "
 					"metadata; rc = [%d]\n", rc);
 		}
 		offset += bytes_read;
 	} else
 		set_default_header_data(crypt_stat);
 	rc = ecryptfs_parse_packet_set(crypt_stat, (page_virt + offset),
 				       ecryptfs_dentry);
 out:
 	return rc;
 }
 /**
  * ecryptfs_read_xattr_region
  * @page_virt: The vitual address into which to read the xattr data
  * @ecryptfs_inode: The eCryptfs inode
  *
  * Attempts to read the crypto metadata from the extended attribute
  * region of the lower file.
  *
  * Returns zero on success; non-zero on error
  */
 int ecryptfs_read_xattr_region(char *page_virt, struct inode *ecryptfs_inode)
 {
 	struct dentry *lower_dentry =
 		ecryptfs_inode_to_private(ecryptfs_inode)->lower_file->f_path.dentry;
 	ssize_t size;
 	int rc = 0;
 	size = ecryptfs_getxattr_lower(lower_dentry, ECRYPTFS_XATTR_NAME,
 				       page_virt, ECRYPTFS_DEFAULT_EXTENT_SIZE);
 	if (size < 0) {
 		if (unlikely(ecryptfs_verbosity > 0))
 			printk(KERN_INFO "Error attempting to read the [%s] "
 			       "xattr from the lower file; return value = "
 			       "[%zd]\n", ECRYPTFS_XATTR_NAME, size);
 		rc = -EINVAL;
 		goto out;
 	}
 out:
 	return rc;
 }
 int ecryptfs_read_and_validate_xattr_region(struct dentry *dentry,
 					    struct inode *inode)
 {
 	u8 file_size[ECRYPTFS_SIZE_AND_MARKER_BYTES];
 	u8 *marker = file_size + ECRYPTFS_FILE_SIZE_BYTES;
 	int rc;
 	rc = ecryptfs_getxattr_lower(ecryptfs_dentry_to_lower(dentry),
 				     ECRYPTFS_XATTR_NAME, file_size,
 				     ECRYPTFS_SIZE_AND_MARKER_BYTES);
 	if (rc < ECRYPTFS_SIZE_AND_MARKER_BYTES)
 		return rc >= 0 ? -EINVAL : rc;
 	rc = ecryptfs_validate_marker(marker);
 	if (!rc)
 		ecryptfs_i_size_init(file_size, inode);
 	return rc;
 }
 /**
  * ecryptfs_read_metadata
  *
  * Common entry point for reading file metadata. From here, we could
  * retrieve the header information from the header region of the file,
  * the xattr region of the file, or some other repostory that is
  * stored separately from the file itself. The current implementation
  * supports retrieving the metadata information from the file contents
  * and from the xattr region.
  *
  * Returns zero if valid headers found and parsed; non-zero otherwise
  */
 int ecryptfs_read_metadata(struct dentry *ecryptfs_dentry)
 {
 	int rc;
 	char *page_virt;
 	struct inode *ecryptfs_inode = ecryptfs_dentry->d_inode;
 	struct ecryptfs_crypt_stat *crypt_stat =
 	    &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
 	struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
 		&ecryptfs_superblock_to_private(
 			ecryptfs_dentry->d_sb)->mount_crypt_stat;
 	ecryptfs_copy_mount_wide_flags_to_inode_flags(crypt_stat,
 						      mount_crypt_stat);
 	/* Read the first page from the underlying file */
 	page_virt = kmem_cache_alloc(ecryptfs_header_cache, GFP_USER);
 	if (!page_virt) {
 		rc = -ENOMEM;
 		printk(KERN_ERR "%s: Unable to allocate page_virt\n",
 		       __func__);
 		goto out;
 	}
 	rc = ecryptfs_read_lower(page_virt, 0, crypt_stat->extent_size,
 				 ecryptfs_inode);
 	if (rc >= 0)
 		rc = ecryptfs_read_headers_virt(page_virt, crypt_stat,
 						ecryptfs_dentry,
 						ECRYPTFS_VALIDATE_HEADER_SIZE);
 	if (rc) {
 		/* metadata is not in the file header, so try xattrs */
 		memset(page_virt, 0, PAGE_CACHE_SIZE);
 		rc = ecryptfs_read_xattr_region(page_virt, ecryptfs_inode);
 		if (rc) {
 			printk(KERN_DEBUG "Valid eCryptfs headers not found in "
 			       "file header region or xattr region, inode %lu\n",
 				ecryptfs_inode->i_ino);
 			rc = -EINVAL;
 			goto out;
 		}
 		rc = ecryptfs_read_headers_virt(page_virt, crypt_stat,
 						ecryptfs_dentry,
 						ECRYPTFS_DONT_VALIDATE_HEADER_SIZE);
 		if (rc) {
 			printk(KERN_DEBUG "Valid eCryptfs headers not found in "
 			       "file xattr region either, inode %lu\n",
 				ecryptfs_inode->i_ino);
 			rc = -EINVAL;
 		}
 		if (crypt_stat->mount_crypt_stat->flags
 		    & ECRYPTFS_XATTR_METADATA_ENABLED) {
 			crypt_stat->flags |= ECRYPTFS_METADATA_IN_XATTR;
 		} else {
 			printk(KERN_WARNING "Attempt to access file with "
 			       "crypto metadata only in the extended attribute "
 			       "region, but eCryptfs was mounted without "
 			       "xattr support enabled. eCryptfs will not treat "
 			       "this like an encrypted file, inode %lu\n",
 				ecryptfs_inode->i_ino);
 			rc = -EINVAL;
 		}
 	}
 out:
 	if (page_virt) {
 		memset(page_virt, 0, PAGE_CACHE_SIZE);
 		kmem_cache_free(ecryptfs_header_cache, page_virt);
 	}
 	return rc;
 }
 /**
  * ecryptfs_encrypt_filename - encrypt filename
  *
  * CBC-encrypts the filename. We do not want to encrypt the same
  * filename with the same key and IV, which may happen with hard
  * links, so we prepend random bits to each filename.
  *
  * Returns zero on success; non-zero otherwise
  */
 static int
 ecryptfs_encrypt_filename(struct ecryptfs_filename *filename,
 			  struct ecryptfs_crypt_stat *crypt_stat,
 			  struct ecryptfs_mount_crypt_stat *mount_crypt_stat)
 {
 	int rc = 0;
 	filename->encrypted_filename = NULL;
 	filename->encrypted_filename_size = 0;
 	if ((crypt_stat && (crypt_stat->flags & ECRYPTFS_ENCFN_USE_MOUNT_FNEK))
 	    || (mount_crypt_stat && (mount_crypt_stat->flags
 				     & ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK))) {
 		size_t packet_size;
 		size_t remaining_bytes;
 		rc = ecryptfs_write_tag_70_packet(
 			NULL, NULL,
 			&filename->encrypted_filename_size,
 			mount_crypt_stat, NULL,
 			filename->filename_size);
 		if (rc) {
 			printk(KERN_ERR "%s: Error attempting to get packet "
 			       "size for tag 72; rc = [%d]\n", __func__,
 			       rc);
 			filename->encrypted_filename_size = 0;
 			goto out;
 		}
 		filename->encrypted_filename =
 			kmalloc(filename->encrypted_filename_size, GFP_KERNEL);
 		if (!filename->encrypted_filename) {
 			printk(KERN_ERR "%s: Out of memory whilst attempting "
 			       "to kmalloc [%zd] bytes\n", __func__,
 			       filename->encrypted_filename_size);
 			rc = -ENOMEM;
 			goto out;
 		}
 		remaining_bytes = filename->encrypted_filename_size;
 		rc = ecryptfs_write_tag_70_packet(filename->encrypted_filename,
 						  &remaining_bytes,
 						  &packet_size,
 						  mount_crypt_stat,
 						  filename->filename,
 						  filename->filename_size);
 		if (rc) {
 			printk(KERN_ERR "%s: Error attempting to generate "
 			       "tag 70 packet; rc = [%d]\n", __func__,
 			       rc);
 			kfree(filename->encrypted_filename);
 			filename->encrypted_filename = NULL;
 			filename->encrypted_filename_size = 0;
 			goto out;
 		}
 		filename->encrypted_filename_size = packet_size;
 	} else {
 		printk(KERN_ERR "%s: No support for requested filename "
 		       "encryption method in this release\n", __func__);
 		rc = -EOPNOTSUPP;
 		goto out;
 	}
 out:
 	return rc;
 }
 static int ecryptfs_copy_filename(char **copied_name, size_t *copied_name_size,
 				  const char *name, size_t name_size)
 {
 	int rc = 0;
 	(*copied_name) = kmalloc((name_size + 1), GFP_KERNEL);
 	if (!(*copied_name)) {
 		rc = -ENOMEM;
 		goto out;
 	}
 	memcpy((void *)(*copied_name), (void *)name, name_size);
 	(*copied_name)[(name_size)] = '\0';	/* Only for convenience
 						 * in printing out the
 						 * string in debug
 						 * messages */
 	(*copied_name_size) = name_size;
 out:
 	return rc;
 }
 /**
  * ecryptfs_process_key_cipher - Perform key cipher initialization.
  * @key_tfm: Crypto context for key material, set by this function
  * @cipher_name: Name of the cipher
  * @key_size: Size of the key in bytes
  *
  * Returns zero on success. Any crypto_tfm structs allocated here
  * should be released by other functions, such as on a superblock put
  * event, regardless of whether this function succeeds for fails.
  */
 static int
 ecryptfs_process_key_cipher(struct crypto_blkcipher **key_tfm,
 			    char *cipher_name, size_t *key_size)
 {
 	char dummy_key[ECRYPTFS_MAX_KEY_BYTES];
 	char *full_alg_name = NULL;
 	int rc;
 	*key_tfm = NULL;
 	if (*key_size > ECRYPTFS_MAX_KEY_BYTES) {
 		rc = -EINVAL;
 		printk(KERN_ERR "Requested key size is [%zd] bytes; maximum "
 		      "allowable is [%d]\n", *key_size, ECRYPTFS_MAX_KEY_BYTES);
 		goto out;
 	}
 	rc = ecryptfs_crypto_api_algify_cipher_name(&full_alg_name, cipher_name,
 						    "ecb");
 	if (rc)
 		goto out;
 	*key_tfm = crypto_alloc_blkcipher(full_alg_name, 0, CRYPTO_ALG_ASYNC);
 	if (IS_ERR(*key_tfm)) {
 		rc = PTR_ERR(*key_tfm);
 		printk(KERN_ERR "Unable to allocate crypto cipher with name "
 		       "[%s]; rc = [%d]\n", full_alg_name, rc);
 		goto out;
 	}
 	crypto_blkcipher_set_flags(*key_tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 	if (*key_size == 0) {
 		struct blkcipher_alg *alg = crypto_blkcipher_alg(*key_tfm);
 		*key_size = alg->max_keysize;
 	}
 	get_random_bytes(dummy_key, *key_size);
 	rc = crypto_blkcipher_setkey(*key_tfm, dummy_key, *key_size);
 	if (rc) {
 		printk(KERN_ERR "Error attempting to set key of size [%zd] for "
 		       "cipher [%s]; rc = [%d]\n", *key_size, full_alg_name,
 		       rc);
 		rc = -EINVAL;
 		goto out;
 	}
 out:
 	kfree(full_alg_name);
 	return rc;
 }
 struct kmem_cache *ecryptfs_key_tfm_cache;
 static struct list_head key_tfm_list;
 struct mutex key_tfm_list_mutex;
 int __init ecryptfs_init_crypto(void)
 {
 	mutex_init(&key_tfm_list_mutex);
 	INIT_LIST_HEAD(&key_tfm_list);
 	return 0;
 }
 /**
  * ecryptfs_destroy_crypto - free all cached key_tfms on key_tfm_list
  *
  * Called only at module unload time
  */
 int ecryptfs_destroy_crypto(void)
 {
 	struct ecryptfs_key_tfm *key_tfm, *key_tfm_tmp;
 	mutex_lock(&key_tfm_list_mutex);
 	list_for_each_entry_safe(key_tfm, key_tfm_tmp, &key_tfm_list,
 				 key_tfm_list) {
 		list_del(&key_tfm->key_tfm_list);
 		if (key_tfm->key_tfm)
 			crypto_free_blkcipher(key_tfm->key_tfm);
 		kmem_cache_free(ecryptfs_key_tfm_cache, key_tfm);
 	}
 	mutex_unlock(&key_tfm_list_mutex);
 	return 0;
 }
 int
 ecryptfs_add_new_key_tfm(struct ecryptfs_key_tfm **key_tfm, char *cipher_name,
 			 size_t key_size)
 {
 	struct ecryptfs_key_tfm *tmp_tfm;
 	int rc = 0;
 	BUG_ON(!mutex_is_locked(&key_tfm_list_mutex));
 	tmp_tfm = kmem_cache_alloc(ecryptfs_key_tfm_cache, GFP_KERNEL);
 	if (key_tfm != NULL)
 		(*key_tfm) = tmp_tfm;
 	if (!tmp_tfm) {
 		rc = -ENOMEM;
 		printk(KERN_ERR "Error attempting to allocate from "
 		       "ecryptfs_key_tfm_cache\n");
 		goto out;
 	}
 	mutex_init(&tmp_tfm->key_tfm_mutex);
 	strncpy(tmp_tfm->cipher_name, cipher_name,
 		ECRYPTFS_MAX_CIPHER_NAME_SIZE);
 	tmp_tfm->cipher_name[ECRYPTFS_MAX_CIPHER_NAME_SIZE] = '\0';
 	tmp_tfm->key_size = key_size;
 	rc = ecryptfs_process_key_cipher(&tmp_tfm->key_tfm,
 					 tmp_tfm->cipher_name,
 					 &tmp_tfm->key_size);
 	if (rc) {
 		printk(KERN_ERR "Error attempting to initialize key TFM "
 		       "cipher with name = [%s]; rc = [%d]\n",
 		       tmp_tfm->cipher_name, rc);
 		kmem_cache_free(ecryptfs_key_tfm_cache, tmp_tfm);
 		if (key_tfm != NULL)
 			(*key_tfm) = NULL;
 		goto out;
 	}
 	list_add(&tmp_tfm->key_tfm_list, &key_tfm_list);
 out:
 	return rc;
 }
 /**
  * ecryptfs_tfm_exists - Search for existing tfm for cipher_name.
  * @cipher_name: the name of the cipher to search for
  * @key_tfm: set to corresponding tfm if found
  *
  * Searches for cached key_tfm matching @cipher_name
  * Must be called with &key_tfm_list_mutex held
  * Returns 1 if found, with @key_tfm set
  * Returns 0 if not found, with @key_tfm set to NULL
  */
 int ecryptfs_tfm_exists(char *cipher_name, struct ecryptfs_key_tfm **key_tfm)
 {
 	struct ecryptfs_key_tfm *tmp_key_tfm;
 	BUG_ON(!mutex_is_locked(&key_tfm_list_mutex));
 	list_for_each_entry(tmp_key_tfm, &key_tfm_list, key_tfm_list) {
 		if (strcmp(tmp_key_tfm->cipher_name, cipher_name) == 0) {
 			if (key_tfm)
 				(*key_tfm) = tmp_key_tfm;
 			return 1;
 		}
 	}
 	if (key_tfm)
 		(*key_tfm) = NULL;
 	return 0;
 }
 /**
  * ecryptfs_get_tfm_and_mutex_for_cipher_name
  *
  * @tfm: set to cached tfm found, or new tfm created
  * @tfm_mutex: set to mutex for cached tfm found, or new tfm created
  * @cipher_name: the name of the cipher to search for and/or add
  *
  * Sets pointers to @tfm & @tfm_mutex matching @cipher_name.
  * Searches for cached item first, and creates new if not found.
  * Returns 0 on success, non-zero if adding new cipher failed
  */
 int ecryptfs_get_tfm_and_mutex_for_cipher_name(struct crypto_blkcipher **tfm,
 					       struct mutex **tfm_mutex,
 					       char *cipher_name)
 {
 	struct ecryptfs_key_tfm *key_tfm;
 	int rc = 0;
 	(*tfm) = NULL;
 	(*tfm_mutex) = NULL;
 	mutex_lock(&key_tfm_list_mutex);
 	if (!ecryptfs_tfm_exists(cipher_name, &key_tfm)) {
 		rc = ecryptfs_add_new_key_tfm(&key_tfm, cipher_name, 0);
 		if (rc) {
 			printk(KERN_ERR "Error adding new key_tfm to list; "
 					"rc = [%d]\n", rc);
 			goto out;
 		}
 	}
 	(*tfm) = key_tfm->key_tfm;
 	(*tfm_mutex) = &key_tfm->key_tfm_mutex;
 out:
 	mutex_unlock(&key_tfm_list_mutex);
 	return rc;
 }
 /* 64 characters forming a 6-bit target field */
 static unsigned char *portable_filename_chars = ("-.0123456789ABCD"
 						 "EFGHIJKLMNOPQRST"
 						 "UVWXYZabcdefghij"
 						 "klmnopqrstuvwxyz");
 /* We could either offset on every reverse map or just pad some 0x00's
  * at the front here */
 static const unsigned char filename_rev_map[256] = {
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 7 */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 15 */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 23 */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 31 */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 39 */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, /* 47 */
 	0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, /* 55 */
 	0x0A, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 63 */
 	0x00, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, /* 71 */
 	0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, /* 79 */
 	0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, /* 87 */
 	0x23, 0x24, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, /* 95 */
 	0x00, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, /* 103 */
 	0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, /* 111 */
 	0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, /* 119 */
 	0x3D, 0x3E, 0x3F /* 123 - 255 initialized to 0x00 */
 };
 /**
  * ecryptfs_encode_for_filename
  * @dst: Destination location for encoded filename
  * @dst_size: Size of the encoded filename in bytes
  * @src: Source location for the filename to encode
  * @src_size: Size of the source in bytes
  */
 static void ecryptfs_encode_for_filename(unsigned char *dst, size_t *dst_size,
 				  unsigned char *src, size_t src_size)
 {
 	size_t num_blocks;
 	size_t block_num = 0;
 	size_t dst_offset = 0;
 	unsigned char last_block[3];
 	if (src_size == 0) {
 		(*dst_size) = 0;
 		goto out;
 	}
 	num_blocks = (src_size / 3);
 	if ((src_size % 3) == 0) {
 		memcpy(last_block, (&src[src_size - 3]), 3);
 	} else {
 		num_blocks++;
 		last_block[2] = 0x00;
 		switch (src_size % 3) {
 		case 1:
 			last_block[0] = src[src_size - 1];
 			last_block[1] = 0x00;
 			break;
 		case 2:
 			last_block[0] = src[src_size - 2];
 			last_block[1] = src[src_size - 1];
 		}
 	}
 	(*dst_size) = (num_blocks * 4);
 	if (!dst)
 		goto out;
 	while (block_num < num_blocks) {
 		unsigned char *src_block;
 		unsigned char dst_block[4];
 		if (block_num == (num_blocks - 1))
 			src_block = last_block;
 		else
 			src_block = &src[block_num * 3];
 		dst_block[0] = ((src_block[0] >> 2) & 0x3F);
 		dst_block[1] = (((src_block[0] << 4) & 0x30)
 				| ((src_block[1] >> 4) & 0x0F));
 		dst_block[2] = (((src_block[1] << 2) & 0x3C)
 				| ((src_block[2] >> 6) & 0x03));
 		dst_block[3] = (src_block[2] & 0x3F);
 		dst[dst_offset++] = portable_filename_chars[dst_block[0]];
 		dst[dst_offset++] = portable_filename_chars[dst_block[1]];
 		dst[dst_offset++] = portable_filename_chars[dst_block[2]];
 		dst[dst_offset++] = portable_filename_chars[dst_block[3]];
 		block_num++;
 	}
 out:
 	return;
 }
 static size_t ecryptfs_max_decoded_size(size_t encoded_size)
 {
 	/* Not exact; conservatively long. Every block of 4
 	 * encoded characters decodes into a block of 3
 	 * decoded characters. This segment of code provides
 	 * the caller with the maximum amount of allocated
 	 * space that @dst will need to point to in a
 	 * subsequent call. */
 	return ((encoded_size + 1) * 3) / 4;
 }
 /**
  * ecryptfs_decode_from_filename
  * @dst: If NULL, this function only sets @dst_size and returns. If
  *       non-NULL, this function decodes the encoded octets in @src
  *       into the memory that @dst points to.
  * @dst_size: Set to the size of the decoded string.
  * @src: The encoded set of octets to decode.
  * @src_size: The size of the encoded set of octets to decode.
  */
 static void
 ecryptfs_decode_from_filename(unsigned char *dst, size_t *dst_size,
 			      const unsigned char *src, size_t src_size)
 {
 	u8 current_bit_offset = 0;
 	size_t src_byte_offset = 0;
 	size_t dst_byte_offset = 0;
 	if (dst == NULL) {
 		(*dst_size) = ecryptfs_max_decoded_size(src_size);
 		goto out;
 	}
 	while (src_byte_offset < src_size) {
 		unsigned char src_byte =
 				filename_rev_map[(int)src[src_byte_offset]];
 		switch (current_bit_offset) {
 		case 0:
 			dst[dst_byte_offset] = (src_byte << 2);
 			current_bit_offset = 6;
 			break;
 		case 6:
 			dst[dst_byte_offset++] |= (src_byte >> 4);
 			dst[dst_byte_offset] = ((src_byte & 0xF)
 						 << 4);
 			current_bit_offset = 4;
 			break;
 		case 4:
 			dst[dst_byte_offset++] |= (src_byte >> 2);
 			dst[dst_byte_offset] = (src_byte << 6);
 			current_bit_offset = 2;
 			break;
 		case 2:
 			dst[dst_byte_offset++] |= (src_byte);
-			dst[dst_byte_offset] = 0;
 			current_bit_offset = 0;
 			break;
 		}
 		src_byte_offset++;
 	}
 	(*dst_size) = dst_byte_offset;
 out:
 	return;
 }
 /**
  * ecryptfs_encrypt_and_encode_filename - converts a plaintext file name to cipher text
  * @crypt_stat: The crypt_stat struct associated with the file anem to encode
  * @name: The plaintext name
  * @length: The length of the plaintext
  * @encoded_name: The encypted name
  *
  * Encrypts and encodes a filename into something that constitutes a
  * valid filename for a filesystem, with printable characters.
  *
  * We assume that we have a properly initialized crypto context,
  * pointed to by crypt_stat->tfm.
  *
  * Returns zero on success; non-zero on otherwise
  */
 int ecryptfs_encrypt_and_encode_filename(
 	char **encoded_name,
 	size_t *encoded_name_size,
 	struct ecryptfs_crypt_stat *crypt_stat,
 	struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
 	const char *name, size_t name_size)
 {
 	size_t encoded_name_no_prefix_size;
 	int rc = 0;
 	(*encoded_name) = NULL;
 	(*encoded_name_size) = 0;
 	if ((crypt_stat && (crypt_stat->flags & ECRYPTFS_ENCRYPT_FILENAMES))
 	    || (mount_crypt_stat && (mount_crypt_stat->flags
 				     & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES))) {
 		struct ecryptfs_filename *filename;
 		filename = kzalloc(sizeof(*filename), GFP_KERNEL);
 		if (!filename) {
 			printk(KERN_ERR "%s: Out of memory whilst attempting "
 			       "to kzalloc [%zd] bytes\n", __func__,
 			       sizeof(*filename));
 			rc = -ENOMEM;
 			goto out;
 		}
 		filename->filename = (char *)name;
 		filename->filename_size = name_size;
 		rc = ecryptfs_encrypt_filename(filename, crypt_stat,
 					       mount_crypt_stat);
 		if (rc) {
 			printk(KERN_ERR "%s: Error attempting to encrypt "
 			       "filename; rc = [%d]\n", __func__, rc);
 			kfree(filename);
 			goto out;
 		}
 		ecryptfs_encode_for_filename(
 			NULL, &encoded_name_no_prefix_size,
 			filename->encrypted_filename,
 			filename->encrypted_filename_size);
 		if ((crypt_stat && (crypt_stat->flags
 				    & ECRYPTFS_ENCFN_USE_MOUNT_FNEK))
 		    || (mount_crypt_stat
 			&& (mount_crypt_stat->flags
 			    & ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK)))
 			(*encoded_name_size) =
 				(ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE
 				 + encoded_name_no_prefix_size);
 		else
 			(*encoded_name_size) =
 				(ECRYPTFS_FEK_ENCRYPTED_FILENAME_PREFIX_SIZE
 				 + encoded_name_no_prefix_size);
 		(*encoded_name) = kmalloc((*encoded_name_size) + 1, GFP_KERNEL);
 		if (!(*encoded_name)) {
 			printk(KERN_ERR "%s: Out of memory whilst attempting "
 			       "to kzalloc [%zd] bytes\n", __func__,
 			       (*encoded_name_size));
 			rc = -ENOMEM;
 			kfree(filename->encrypted_filename);
 			kfree(filename);
 			goto out;
 		}
 		if ((crypt_stat && (crypt_stat->flags
 				    & ECRYPTFS_ENCFN_USE_MOUNT_FNEK))
 		    || (mount_crypt_stat
 			&& (mount_crypt_stat->flags
 			    & ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK))) {
 			memcpy((*encoded_name),
 			       ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX,
 			       ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE);
 			ecryptfs_encode_for_filename(
 			    ((*encoded_name)
 			     + ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE),
 			    &encoded_name_no_prefix_size,
 			    filename->encrypted_filename,
 			    filename->encrypted_filename_size);
 			(*encoded_name_size) =
 				(ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE
 				 + encoded_name_no_prefix_size);
 			(*encoded_name)[(*encoded_name_size)] = '\0';
 		} else {
 			rc = -EOPNOTSUPP;
 		}
 		if (rc) {
 			printk(KERN_ERR "%s: Error attempting to encode "
 			       "encrypted filename; rc = [%d]\n", __func__,
 			       rc);
 			kfree((*encoded_name));
 			(*encoded_name) = NULL;
 			(*encoded_name_size) = 0;
 		}
 		kfree(filename->encrypted_filename);
 		kfree(filename);
 	} else {
 		rc = ecryptfs_copy_filename(encoded_name,
 					    encoded_name_size,
 					    name, name_size);
 	}
 out:
 	return rc;
 }
 /**
  * ecryptfs_decode_and_decrypt_filename - converts the encoded cipher text name to decoded plaintext
  * @plaintext_name: The plaintext name
  * @plaintext_name_size: The plaintext name size
  * @ecryptfs_dir_dentry: eCryptfs directory dentry
  * @name: The filename in cipher text
  * @name_size: The cipher text name size
  *
  * Decrypts and decodes the filename.
  *
  * Returns zero on error; non-zero otherwise
  */
 int ecryptfs_decode_and_decrypt_filename(char **plaintext_name,
 					 size_t *plaintext_name_size,
 					 struct super_block *sb,
 					 const char *name, size_t name_size)
 {
 	struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
 		&ecryptfs_superblock_to_private(sb)->mount_crypt_stat;
 	char *decoded_name;
 	size_t decoded_name_size;
 	size_t packet_size;
 	int rc = 0;
 	if ((mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES)
 	    && !(mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED)
 	    && (name_size > ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE)
 	    && (strncmp(name, ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX,
 			ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE) == 0)) {
 		const char *orig_name = name;
 		size_t orig_name_size = name_size;
 		name += ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE;
 		name_size -= ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE;
 		ecryptfs_decode_from_filename(NULL, &decoded_name_size,
 					      name, name_size);
 		decoded_name = kmalloc(decoded_name_size, GFP_KERNEL);
 		if (!decoded_name) {
 			printk(KERN_ERR "%s: Out of memory whilst attempting "
 			       "to kmalloc [%zd] bytes\n", __func__,
 			       decoded_name_size);
 			rc = -ENOMEM;
 			goto out;
 		}
 		ecryptfs_decode_from_filename(decoded_name, &decoded_name_size,
 					      name, name_size);
 		rc = ecryptfs_parse_tag_70_packet(plaintext_name,
 						  plaintext_name_size,
 						  &packet_size,
 						  mount_crypt_stat,
 						  decoded_name,
 						  decoded_name_size);
 		if (rc) {
 			printk(KERN_INFO "%s: Could not parse tag 70 packet "
 			       "from filename; copying through filename "
 			       "as-is\n", __func__);
 			rc = ecryptfs_copy_filename(plaintext_name,
 						    plaintext_name_size,
 						    orig_name, orig_name_size);
 			goto out_free;
 		}
 	} else {
 		rc = ecryptfs_copy_filename(plaintext_name,
 					    plaintext_name_size,
 					    name, name_size);
 		goto out;
 	}
 out_free:
 	kfree(decoded_name);
 out:
 	return rc;
 }
 #define ENC_NAME_MAX_BLOCKLEN_8_OR_16	143
 int ecryptfs_set_f_namelen(long *namelen, long lower_namelen,
 			   struct ecryptfs_mount_crypt_stat *mount_crypt_stat)
 {
 	struct blkcipher_desc desc;
 	struct mutex *tfm_mutex;
 	size_t cipher_blocksize;
 	int rc;
 	if (!(mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES)) {
 		(*namelen) = lower_namelen;
 		return 0;
 	}
 	rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(&desc.tfm, &tfm_mutex,
 			mount_crypt_stat->global_default_fn_cipher_name);
 	if (unlikely(rc)) {
 		(*namelen) = 0;
 		return rc;
 	}
 	mutex_lock(tfm_mutex);
 	cipher_blocksize = crypto_blkcipher_blocksize(desc.tfm);
 	mutex_unlock(tfm_mutex);
 	/* Return an exact amount for the common cases */
 	if (lower_namelen == NAME_MAX
 	    && (cipher_blocksize == 8 || cipher_blocksize == 16)) {
 		(*namelen) = ENC_NAME_MAX_BLOCKLEN_8_OR_16;
 		return 0;
 	}
 	/* Return a safe estimate for the uncommon cases */
 	(*namelen) = lower_namelen;
 	(*namelen) -= ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE;
 	/* Since this is the max decoded size, subtract 1 "decoded block" len */
 	(*namelen) = ecryptfs_max_decoded_size(*namelen) - 3;
 	(*namelen) -= ECRYPTFS_TAG_70_MAX_METADATA_SIZE;
 	(*namelen) -= ECRYPTFS_FILENAME_MIN_RANDOM_PREPEND_BYTES;
 	/* Worst case is that the filename is padded nearly a full block size */
 	(*namelen) -= cipher_blocksize - 1;
 	if ((*namelen) < 0)
 		(*namelen) = 0;
 	return 0;
 }

fs/ecryptfs/file.c

Diff comments View file @ 298647e

 /**
  * eCryptfs: Linux filesystem encryption layer
  *
  * Copyright (C) 1997-2004 Erez Zadok
  * Copyright (C) 2001-2004 Stony Brook University
  * Copyright (C) 2004-2007 International Business Machines Corp.
  *   Author(s): Michael A. Halcrow <mhalcrow@us.ibm.com>
  *   		Michael C. Thompson <mcthomps@us.ibm.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  * 02111-1307, USA.
  */
 #include <linux/file.h>
 #include <linux/poll.h>
 #include <linux/slab.h>
 #include <linux/mount.h>
 #include <linux/pagemap.h>
 #include <linux/security.h>
 #include <linux/compat.h>
 #include <linux/fs_stack.h>
 #include <linux/aio.h>
 #include "ecryptfs_kernel.h"
 /**
  * ecryptfs_read_update_atime
  *
  * generic_file_read updates the atime of upper layer inode.  But, it
  * doesn't give us a chance to update the atime of the lower layer
  * inode.  This function is a wrapper to generic_file_read.  It
  * updates the atime of the lower level inode if generic_file_read
  * returns without any errors. This is to be used only for file reads.
  * The function to be used for directory reads is ecryptfs_read.
  */
 static ssize_t ecryptfs_read_update_atime(struct kiocb *iocb,
 				struct iov_iter *to)
 {
 	ssize_t rc;
 	struct path *path;
 	struct file *file = iocb->ki_filp;
 	rc = generic_file_read_iter(iocb, to);
 	/*
 	 * Even though this is a async interface, we need to wait
 	 * for IO to finish to update atime
 	 */
 	if (-EIOCBQUEUED == rc)
 		rc = wait_on_sync_kiocb(iocb);
 	if (rc >= 0) {
 		path = ecryptfs_dentry_to_lower_path(file->f_path.dentry);
 		touch_atime(path);
 	}
 	return rc;
 }
 struct ecryptfs_getdents_callback {
 	struct dir_context ctx;
 	struct dir_context *caller;
 	struct super_block *sb;
 	int filldir_called;
 	int entries_written;
 };
 /* Inspired by generic filldir in fs/readdir.c */
 static int
 ecryptfs_filldir(struct dir_context *ctx, const char *lower_name,
 		 int lower_namelen, loff_t offset, u64 ino, unsigned int d_type)
 {
 	struct ecryptfs_getdents_callback *buf =
 		container_of(ctx, struct ecryptfs_getdents_callback, ctx);
 	size_t name_size;
 	char *name;
 	int rc;
 	buf->filldir_called++;
 	rc = ecryptfs_decode_and_decrypt_filename(&name, &name_size,
 						  buf->sb, lower_name,
 						  lower_namelen);
 	if (rc) {
 		printk(KERN_ERR "%s: Error attempting to decode and decrypt "
 		       "filename [%s]; rc = [%d]\n", __func__, lower_name,
 		       rc);
 		goto out;
 	}
 	buf->caller->pos = buf->ctx.pos;
 	rc = !dir_emit(buf->caller, name, name_size, ino, d_type);
 	kfree(name);
 	if (!rc)
 		buf->entries_written++;
 out:
 	return rc;
 }
 /**
  * ecryptfs_readdir
  * @file: The eCryptfs directory file
  * @ctx: The actor to feed the entries to
  */
 static int ecryptfs_readdir(struct file *file, struct dir_context *ctx)
 {
 	int rc;
 	struct file *lower_file;
 	struct inode *inode = file_inode(file);
 	struct ecryptfs_getdents_callback buf = {
 		.ctx.actor = ecryptfs_filldir,
 		.caller = ctx,
 		.sb = inode->i_sb,
 	};
 	lower_file = ecryptfs_file_to_lower(file);
 	lower_file->f_pos = ctx->pos;
 	rc = iterate_dir(lower_file, &buf.ctx);
 	ctx->pos = buf.ctx.pos;
 	if (rc < 0)
 		goto out;
 	if (buf.filldir_called && !buf.entries_written)
 		goto out;
 	if (rc >= 0)
 		fsstack_copy_attr_atime(inode,
 					file_inode(lower_file));
 out:
 	return rc;
 }
 struct kmem_cache *ecryptfs_file_info_cache;
 static int read_or_initialize_metadata(struct dentry *dentry)
 {
 	struct inode *inode = dentry->d_inode;
 	struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
 	struct ecryptfs_crypt_stat *crypt_stat;
 	int rc;
 	crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
 	mount_crypt_stat = &ecryptfs_superblock_to_private(
 						inode->i_sb)->mount_crypt_stat;
 	mutex_lock(&crypt_stat->cs_mutex);
 	if (crypt_stat->flags & ECRYPTFS_POLICY_APPLIED &&
 	    crypt_stat->flags & ECRYPTFS_KEY_VALID) {
 		rc = 0;
 		goto out;
 	}
 	rc = ecryptfs_read_metadata(dentry);
 	if (!rc)
 		goto out;
 	if (mount_crypt_stat->flags & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED) {
 		crypt_stat->flags &= ~(ECRYPTFS_I_SIZE_INITIALIZED
 				       | ECRYPTFS_ENCRYPTED);
 		rc = 0;
 		goto out;
 	}
 	if (!(mount_crypt_stat->flags & ECRYPTFS_XATTR_METADATA_ENABLED) &&
 	    !i_size_read(ecryptfs_inode_to_lower(inode))) {
 		rc = ecryptfs_initialize_file(dentry, inode);
 		if (!rc)
 			goto out;
 	}
 	rc = -EIO;
 out:
 	mutex_unlock(&crypt_stat->cs_mutex);
 	return rc;
 }
 /**
  * ecryptfs_open
  * @inode: inode speciying file to open
  * @file: Structure to return filled in
  *
  * Opens the file specified by inode.
  *
  * Returns zero on success; non-zero otherwise
  */
 static int ecryptfs_open(struct inode *inode, struct file *file)
 {
 	int rc = 0;
 	struct ecryptfs_crypt_stat *crypt_stat = NULL;
-	struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
 	struct dentry *ecryptfs_dentry = file->f_path.dentry;
 	/* Private value of ecryptfs_dentry allocated in
 	 * ecryptfs_lookup() */
 	struct ecryptfs_file_info *file_info;
-	mount_crypt_stat = &ecryptfs_superblock_to_private(
-		ecryptfs_dentry->d_sb)->mount_crypt_stat;
-	if ((mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED)
-	    && ((file->f_flags & O_WRONLY) || (file->f_flags & O_RDWR)
-		|| (file->f_flags & O_CREAT) || (file->f_flags & O_TRUNC)
-		|| (file->f_flags & O_APPEND))) {
-		printk(KERN_WARNING "Mount has encrypted view enabled; "
-		       "files may only be read\n");
-		rc = -EPERM;
-		goto out;
-	}
 	/* Released in ecryptfs_release or end of function if failure */
 	file_info = kmem_cache_zalloc(ecryptfs_file_info_cache, GFP_KERNEL);
 	ecryptfs_set_file_private(file, file_info);
 	if (!file_info) {
 		ecryptfs_printk(KERN_ERR,
 				"Error attempting to allocate memory\n");
 		rc = -ENOMEM;
 		goto out;
 	}
 	crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
 	mutex_lock(&crypt_stat->cs_mutex);
 	if (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED)) {
 		ecryptfs_printk(KERN_DEBUG, "Setting flags for stat...\n");
 		/* Policy code enabled in future release */
 		crypt_stat->flags |= (ECRYPTFS_POLICY_APPLIED
 				      | ECRYPTFS_ENCRYPTED);
 	}
 	mutex_unlock(&crypt_stat->cs_mutex);
 	rc = ecryptfs_get_lower_file(ecryptfs_dentry, inode);
 	if (rc) {
 		printk(KERN_ERR "%s: Error attempting to initialize "
 			"the lower file for the dentry with name "
 			"[%pd]; rc = [%d]\n", __func__,
 			ecryptfs_dentry, rc);
 		goto out_free;
 	}
 	if ((ecryptfs_inode_to_private(inode)->lower_file->f_flags & O_ACCMODE)
 	    == O_RDONLY && (file->f_flags & O_ACCMODE) != O_RDONLY) {
 		rc = -EPERM;
 		printk(KERN_WARNING "%s: Lower file is RO; eCryptfs "
 		       "file must hence be opened RO\n", __func__);
 		goto out_put;
 	}
 	ecryptfs_set_file_lower(
 		file, ecryptfs_inode_to_private(inode)->lower_file);
 	if (S_ISDIR(ecryptfs_dentry->d_inode->i_mode)) {
 		ecryptfs_printk(KERN_DEBUG, "This is a directory\n");
 		mutex_lock(&crypt_stat->cs_mutex);
 		crypt_stat->flags &= ~(ECRYPTFS_ENCRYPTED);
 		mutex_unlock(&crypt_stat->cs_mutex);
 		rc = 0;
 		goto out;
 	}
 	rc = read_or_initialize_metadata(ecryptfs_dentry);
 	if (rc)
 		goto out_put;
 	ecryptfs_printk(KERN_DEBUG, "inode w/ addr = [0x%p], i_ino = "
 			"[0x%.16lx] size: [0x%.16llx]\n", inode, inode->i_ino,
 			(unsigned long long)i_size_read(inode));
 	goto out;
 out_put:
 	ecryptfs_put_lower_file(inode);
 out_free:
 	kmem_cache_free(ecryptfs_file_info_cache,
 			ecryptfs_file_to_private(file));
 out:
 	return rc;
 }
 static int ecryptfs_flush(struct file *file, fl_owner_t td)
 {
 	struct file *lower_file = ecryptfs_file_to_lower(file);
 	if (lower_file->f_op->flush) {
 		filemap_write_and_wait(file->f_mapping);
 		return lower_file->f_op->flush(lower_file, td);
 	}
 	return 0;
 }
 static int ecryptfs_release(struct inode *inode, struct file *file)
 {
 	ecryptfs_put_lower_file(inode);
 	kmem_cache_free(ecryptfs_file_info_cache,
 			ecryptfs_file_to_private(file));
 	return 0;
 }
 static int
 ecryptfs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
 	int rc;
 	rc = filemap_write_and_wait(file->f_mapping);
 	if (rc)
 		return rc;
 	return vfs_fsync(ecryptfs_file_to_lower(file), datasync);
 }
 static int ecryptfs_fasync(int fd, struct file *file, int flag)
 {
 	int rc = 0;
 	struct file *lower_file = NULL;
 	lower_file = ecryptfs_file_to_lower(file);
 	if (lower_file->f_op->fasync)
 		rc = lower_file->f_op->fasync(fd, lower_file, flag);
 	return rc;
 }
 static long
 ecryptfs_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
 	struct file *lower_file = ecryptfs_file_to_lower(file);
 	long rc = -ENOTTY;
 	if (lower_file->f_op->unlocked_ioctl)
 		rc = lower_file->f_op->unlocked_ioctl(lower_file, cmd, arg);
 	return rc;
 }
 #ifdef CONFIG_COMPAT
 static long
 ecryptfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
 	struct file *lower_file = ecryptfs_file_to_lower(file);
 	long rc = -ENOIOCTLCMD;
 	if (lower_file->f_op->compat_ioctl)
 		rc = lower_file->f_op->compat_ioctl(lower_file, cmd, arg);
 	return rc;
 }
 #endif
 const struct file_operations ecryptfs_dir_fops = {
 	.iterate = ecryptfs_readdir,
 	.read = generic_read_dir,
 	.unlocked_ioctl = ecryptfs_unlocked_ioctl,
 #ifdef CONFIG_COMPAT
 	.compat_ioctl = ecryptfs_compat_ioctl,
 #endif
 	.open = ecryptfs_open,
 	.flush = ecryptfs_flush,
 	.release = ecryptfs_release,
 	.fsync = ecryptfs_fsync,
 	.fasync = ecryptfs_fasync,
 	.splice_read = generic_file_splice_read,
 	.llseek = default_llseek,
 };
 const struct file_operations ecryptfs_main_fops = {
 	.llseek = generic_file_llseek,
 	.read = new_sync_read,
 	.read_iter = ecryptfs_read_update_atime,
 	.write = new_sync_write,
 	.write_iter = generic_file_write_iter,
 	.iterate = ecryptfs_readdir,
 	.unlocked_ioctl = ecryptfs_unlocked_ioctl,
 #ifdef CONFIG_COMPAT
 	.compat_ioctl = ecryptfs_compat_ioctl,
 #endif
 	.mmap = generic_file_mmap,
 	.open = ecryptfs_open,
 	.flush = ecryptfs_flush,
 	.release = ecryptfs_release,
 	.fsync = ecryptfs_fsync,
 	.fasync = ecryptfs_fasync,
 	.splice_read = generic_file_splice_read,
 };

fs/ecryptfs/keystore.c

Diff comments View file @ 298647e

1	/**	1	/**
2	* eCryptfs: Linux filesystem encryption layer	2	* eCryptfs: Linux filesystem encryption layer
3	* In-kernel key management code. Includes functions to parse and	3	* In-kernel key management code. Includes functions to parse and
4	* write authentication token-related packets with the underlying	4	* write authentication token-related packets with the underlying
5	* file.	5	* file.
6	*	6	*
7	* Copyright (C) 2004-2006 International Business Machines Corp.	7	* Copyright (C) 2004-2006 International Business Machines Corp.
8	* Author(s): Michael A. Halcrow <mhalcrow@us.ibm.com>	8	* Author(s): Michael A. Halcrow <mhalcrow@us.ibm.com>
9	* Michael C. Thompson <mcthomps@us.ibm.com>	9	* Michael C. Thompson <mcthomps@us.ibm.com>
10	* Trevor S. Highland <trevor.highland@gmail.com>	10	* Trevor S. Highland <trevor.highland@gmail.com>
11	*	11	*
12	* This program is free software; you can redistribute it and/or	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	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	14	* published by the Free Software Foundation; either version 2 of the
15	* License, or (at your option) any later version.	15	* License, or (at your option) any later version.
16	*	16	*
17	* This program is distributed in the hope that it will be useful, but	17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of	18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.	20	* General Public License for more details.
21	*	21	*
22	* You should have received a copy of the GNU General Public License	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	23	* along with this program; if not, write to the Free Software
24	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA	24	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
25	* 02111-1307, USA.	25	* 02111-1307, USA.
26	*/	26	*/
27		27
28	#include <linux/string.h>	28	#include <linux/string.h>
29	#include <linux/pagemap.h>	29	#include <linux/pagemap.h>
30	#include <linux/key.h>	30	#include <linux/key.h>
31	#include <linux/random.h>	31	#include <linux/random.h>
32	#include <linux/crypto.h>	32	#include <linux/crypto.h>
33	#include <linux/scatterlist.h>	33	#include <linux/scatterlist.h>
34	#include <linux/slab.h>	34	#include <linux/slab.h>
35	#include "ecryptfs_kernel.h"	35	#include "ecryptfs_kernel.h"
36		36
37	/**	37	/**
38	* request_key returned an error instead of a valid key address;	38	* request_key returned an error instead of a valid key address;
39	* determine the type of error, make appropriate log entries, and	39	* determine the type of error, make appropriate log entries, and
40	* return an error code.	40	* return an error code.
41	*/	41	*/
42	static int process_request_key_err(long err_code)	42	static int process_request_key_err(long err_code)
43	{	43	{
44	int rc = 0;	44	int rc = 0;
45		45
46	switch (err_code) {	46	switch (err_code) {
47	case -ENOKEY:	47	case -ENOKEY:
48	ecryptfs_printk(KERN_WARNING, "No key\n");	48	ecryptfs_printk(KERN_WARNING, "No key\n");
49	rc = -ENOENT;	49	rc = -ENOENT;
50	break;	50	break;
51	case -EKEYEXPIRED:	51	case -EKEYEXPIRED:
52	ecryptfs_printk(KERN_WARNING, "Key expired\n");	52	ecryptfs_printk(KERN_WARNING, "Key expired\n");
53	rc = -ETIME;	53	rc = -ETIME;
54	break;	54	break;
55	case -EKEYREVOKED:	55	case -EKEYREVOKED:
56	ecryptfs_printk(KERN_WARNING, "Key revoked\n");	56	ecryptfs_printk(KERN_WARNING, "Key revoked\n");
57	rc = -EINVAL;	57	rc = -EINVAL;
58	break;	58	break;
59	default:	59	default:
60	ecryptfs_printk(KERN_WARNING, "Unknown error code: "	60	ecryptfs_printk(KERN_WARNING, "Unknown error code: "
61	"[0x%.16lx]\n", err_code);	61	"[0x%.16lx]\n", err_code);
62	rc = -EINVAL;	62	rc = -EINVAL;
63	}	63	}
64	return rc;	64	return rc;
65	}	65	}
66		66
67	static int process_find_global_auth_tok_for_sig_err(int err_code)	67	static int process_find_global_auth_tok_for_sig_err(int err_code)
68	{	68	{
69	int rc = err_code;	69	int rc = err_code;
70		70
71	switch (err_code) {	71	switch (err_code) {
72	case -ENOENT:	72	case -ENOENT:
73	ecryptfs_printk(KERN_WARNING, "Missing auth tok\n");	73	ecryptfs_printk(KERN_WARNING, "Missing auth tok\n");
74	break;	74	break;
75	case -EINVAL:	75	case -EINVAL:
76	ecryptfs_printk(KERN_WARNING, "Invalid auth tok\n");	76	ecryptfs_printk(KERN_WARNING, "Invalid auth tok\n");
77	break;	77	break;
78	default:	78	default:
79	rc = process_request_key_err(err_code);	79	rc = process_request_key_err(err_code);
80	break;	80	break;
81	}	81	}
82	return rc;	82	return rc;
83	}	83	}
84		84
85	/**	85	/**
86	* ecryptfs_parse_packet_length	86	* ecryptfs_parse_packet_length
87	* @data: Pointer to memory containing length at offset	87	* @data: Pointer to memory containing length at offset
88	* @size: This function writes the decoded size to this memory	88	* @size: This function writes the decoded size to this memory
89	* address; zero on error	89	* address; zero on error
90	* @length_size: The number of bytes occupied by the encoded length	90	* @length_size: The number of bytes occupied by the encoded length
91	*	91	*
92	* Returns zero on success; non-zero on error	92	* Returns zero on success; non-zero on error
93	*/	93	*/
94	int ecryptfs_parse_packet_length(unsigned char data, size_t size,	94	int ecryptfs_parse_packet_length(unsigned char data, size_t size,
95	size_t *length_size)	95	size_t *length_size)
96	{	96	{
97	int rc = 0;	97	int rc = 0;
98		98
99	(*length_size) = 0;	99	(*length_size) = 0;
100	(*size) = 0;	100	(*size) = 0;
101	if (data[0] < 192) {	101	if (data[0] < 192) {
102	/* One-byte length */	102	/* One-byte length */
103	(*size) = (unsigned char)data[0];	103	(*size) = data[0];
104	(*length_size) = 1;	104	(*length_size) = 1;
105	} else if (data[0] < 224) {	105	} else if (data[0] < 224) {
106	/* Two-byte length */	106	/* Two-byte length */
107	(size) = (((unsigned char)(data[0]) - 192) 256);	107	(size) = (data[0] - 192) 256;
108	(*size) += ((unsigned char)(data[1]) + 192);	108	(*size) += data[1] + 192;
109	(*length_size) = 2;	109	(*length_size) = 2;
110	} else if (data[0] == 255) {	110	} else if (data[0] == 255) {
111	/* If support is added, adjust ECRYPTFS_MAX_PKT_LEN_SIZE */	111	/* If support is added, adjust ECRYPTFS_MAX_PKT_LEN_SIZE */
112	ecryptfs_printk(KERN_ERR, "Five-byte packet length not "	112	ecryptfs_printk(KERN_ERR, "Five-byte packet length not "
113	"supported\n");	113	"supported\n");
114	rc = -EINVAL;	114	rc = -EINVAL;
115	goto out;	115	goto out;
116	} else {	116	} else {
117	ecryptfs_printk(KERN_ERR, "Error parsing packet length\n");	117	ecryptfs_printk(KERN_ERR, "Error parsing packet length\n");
118	rc = -EINVAL;	118	rc = -EINVAL;
119	goto out;	119	goto out;
120	}	120	}
121	out:	121	out:
122	return rc;	122	return rc;
123	}	123	}
124		124
125	/**	125	/**
126	* ecryptfs_write_packet_length	126	* ecryptfs_write_packet_length
127	* @dest: The byte array target into which to write the length. Must	127	* @dest: The byte array target into which to write the length. Must
128	* have at least ECRYPTFS_MAX_PKT_LEN_SIZE bytes allocated.	128	* have at least ECRYPTFS_MAX_PKT_LEN_SIZE bytes allocated.
129	* @size: The length to write.	129	* @size: The length to write.
130	* @packet_size_length: The number of bytes used to encode the packet	130	* @packet_size_length: The number of bytes used to encode the packet
131	* length is written to this address.	131	* length is written to this address.
132	*	132	*
133	* Returns zero on success; non-zero on error.	133	* Returns zero on success; non-zero on error.
134	*/	134	*/
135	int ecryptfs_write_packet_length(char *dest, size_t size,	135	int ecryptfs_write_packet_length(char *dest, size_t size,
136	size_t *packet_size_length)	136	size_t *packet_size_length)
137	{	137	{
138	int rc = 0;	138	int rc = 0;
139		139
140	if (size < 192) {	140	if (size < 192) {
141	dest[0] = size;	141	dest[0] = size;
142	(*packet_size_length) = 1;	142	(*packet_size_length) = 1;
143	} else if (size < 65536) {	143	} else if (size < 65536) {
144	dest[0] = (((size - 192) / 256) + 192);	144	dest[0] = (((size - 192) / 256) + 192);
145	dest[1] = ((size - 192) % 256);	145	dest[1] = ((size - 192) % 256);
146	(*packet_size_length) = 2;	146	(*packet_size_length) = 2;
147	} else {	147	} else {
148	/* If support is added, adjust ECRYPTFS_MAX_PKT_LEN_SIZE */	148	/* If support is added, adjust ECRYPTFS_MAX_PKT_LEN_SIZE */
149	rc = -EINVAL;	149	rc = -EINVAL;
150	ecryptfs_printk(KERN_WARNING,	150	ecryptfs_printk(KERN_WARNING,
151	"Unsupported packet size: [%zd]\n", size);	151	"Unsupported packet size: [%zd]\n", size);
152	}	152	}
153	return rc;	153	return rc;
154	}	154	}
155		155
156	static int	156	static int
157	write_tag_64_packet(char signature, struct ecryptfs_session_key session_key,	157	write_tag_64_packet(char signature, struct ecryptfs_session_key session_key,
158	char *packet, size_t packet_len)	158	char *packet, size_t packet_len)
159	{	159	{
160	size_t i = 0;	160	size_t i = 0;
161	size_t data_len;	161	size_t data_len;
162	size_t packet_size_len;	162	size_t packet_size_len;
163	char *message;	163	char *message;
164	int rc;	164	int rc;
165		165
166	/*	166	/*
167	* *** TAG 64 Packet Format ***	167	* *** TAG 64 Packet Format ***
168	* \| Content Type \| 1 byte \|	168	* \| Content Type \| 1 byte \|
169	* \| Key Identifier Size \| 1 or 2 bytes \|	169	* \| Key Identifier Size \| 1 or 2 bytes \|
170	* \| Key Identifier \| arbitrary \|	170	* \| Key Identifier \| arbitrary \|
171	* \| Encrypted File Encryption Key Size \| 1 or 2 bytes \|	171	* \| Encrypted File Encryption Key Size \| 1 or 2 bytes \|
172	* \| Encrypted File Encryption Key \| arbitrary \|	172	* \| Encrypted File Encryption Key \| arbitrary \|
173	*/	173	*/
174	data_len = (5 + ECRYPTFS_SIG_SIZE_HEX	174	data_len = (5 + ECRYPTFS_SIG_SIZE_HEX
175	+ session_key->encrypted_key_size);	175	+ session_key->encrypted_key_size);
176	*packet = kmalloc(data_len, GFP_KERNEL);	176	*packet = kmalloc(data_len, GFP_KERNEL);
177	message = *packet;	177	message = *packet;
178	if (!message) {	178	if (!message) {
179	ecryptfs_printk(KERN_ERR, "Unable to allocate memory\n");	179	ecryptfs_printk(KERN_ERR, "Unable to allocate memory\n");
180	rc = -ENOMEM;	180	rc = -ENOMEM;
181	goto out;	181	goto out;
182	}	182	}
183	message[i++] = ECRYPTFS_TAG_64_PACKET_TYPE;	183	message[i++] = ECRYPTFS_TAG_64_PACKET_TYPE;
184	rc = ecryptfs_write_packet_length(&message[i], ECRYPTFS_SIG_SIZE_HEX,	184	rc = ecryptfs_write_packet_length(&message[i], ECRYPTFS_SIG_SIZE_HEX,
185	&packet_size_len);	185	&packet_size_len);
186	if (rc) {	186	if (rc) {
187	ecryptfs_printk(KERN_ERR, "Error generating tag 64 packet "	187	ecryptfs_printk(KERN_ERR, "Error generating tag 64 packet "
188	"header; cannot generate packet length\n");	188	"header; cannot generate packet length\n");
189	goto out;	189	goto out;
190	}	190	}
191	i += packet_size_len;	191	i += packet_size_len;
192	memcpy(&message[i], signature, ECRYPTFS_SIG_SIZE_HEX);	192	memcpy(&message[i], signature, ECRYPTFS_SIG_SIZE_HEX);
193	i += ECRYPTFS_SIG_SIZE_HEX;	193	i += ECRYPTFS_SIG_SIZE_HEX;
194	rc = ecryptfs_write_packet_length(&message[i],	194	rc = ecryptfs_write_packet_length(&message[i],
195	session_key->encrypted_key_size,	195	session_key->encrypted_key_size,
196	&packet_size_len);	196	&packet_size_len);
197	if (rc) {	197	if (rc) {
198	ecryptfs_printk(KERN_ERR, "Error generating tag 64 packet "	198	ecryptfs_printk(KERN_ERR, "Error generating tag 64 packet "
199	"header; cannot generate packet length\n");	199	"header; cannot generate packet length\n");
200	goto out;	200	goto out;
201	}	201	}
202	i += packet_size_len;	202	i += packet_size_len;
203	memcpy(&message[i], session_key->encrypted_key,	203	memcpy(&message[i], session_key->encrypted_key,
204	session_key->encrypted_key_size);	204	session_key->encrypted_key_size);
205	i += session_key->encrypted_key_size;	205	i += session_key->encrypted_key_size;
206	*packet_len = i;	206	*packet_len = i;
207	out:	207	out:
208	return rc;	208	return rc;
209	}	209	}
210		210
211	static int	211	static int
212	parse_tag_65_packet(struct ecryptfs_session_key session_key, u8 cipher_code,	212	parse_tag_65_packet(struct ecryptfs_session_key session_key, u8 cipher_code,
213	struct ecryptfs_message *msg)	213	struct ecryptfs_message *msg)
214	{	214	{
215	size_t i = 0;	215	size_t i = 0;
216	char *data;	216	char *data;
217	size_t data_len;	217	size_t data_len;
218	size_t m_size;	218	size_t m_size;
219	size_t message_len;	219	size_t message_len;
220	u16 checksum = 0;	220	u16 checksum = 0;
221	u16 expected_checksum = 0;	221	u16 expected_checksum = 0;
222	int rc;	222	int rc;
223		223
224	/*	224	/*
225	* *** TAG 65 Packet Format ***	225	* *** TAG 65 Packet Format ***
226	* \| Content Type \| 1 byte \|	226	* \| Content Type \| 1 byte \|
227	* \| Status Indicator \| 1 byte \|	227	* \| Status Indicator \| 1 byte \|
228	* \| File Encryption Key Size \| 1 or 2 bytes \|	228	* \| File Encryption Key Size \| 1 or 2 bytes \|
229	* \| File Encryption Key \| arbitrary \|	229	* \| File Encryption Key \| arbitrary \|
230	*/	230	*/
231	message_len = msg->data_len;	231	message_len = msg->data_len;
232	data = msg->data;	232	data = msg->data;
233	if (message_len < 4) {	233	if (message_len < 4) {
234	rc = -EIO;	234	rc = -EIO;
235	goto out;	235	goto out;
236	}	236	}
237	if (data[i++] != ECRYPTFS_TAG_65_PACKET_TYPE) {	237	if (data[i++] != ECRYPTFS_TAG_65_PACKET_TYPE) {
238	ecryptfs_printk(KERN_ERR, "Type should be ECRYPTFS_TAG_65\n");	238	ecryptfs_printk(KERN_ERR, "Type should be ECRYPTFS_TAG_65\n");
239	rc = -EIO;	239	rc = -EIO;
240	goto out;	240	goto out;
241	}	241	}
242	if (data[i++]) {	242	if (data[i++]) {
243	ecryptfs_printk(KERN_ERR, "Status indicator has non-zero value "	243	ecryptfs_printk(KERN_ERR, "Status indicator has non-zero value "
244	"[%d]\n", data[i-1]);	244	"[%d]\n", data[i-1]);
245	rc = -EIO;	245	rc = -EIO;
246	goto out;	246	goto out;
247	}	247	}
248	rc = ecryptfs_parse_packet_length(&data[i], &m_size, &data_len);	248	rc = ecryptfs_parse_packet_length(&data[i], &m_size, &data_len);
249	if (rc) {	249	if (rc) {
250	ecryptfs_printk(KERN_WARNING, "Error parsing packet length; "	250	ecryptfs_printk(KERN_WARNING, "Error parsing packet length; "
251	"rc = [%d]\n", rc);	251	"rc = [%d]\n", rc);
252	goto out;	252	goto out;
253	}	253	}
254	i += data_len;	254	i += data_len;
255	if (message_len < (i + m_size)) {	255	if (message_len < (i + m_size)) {
256	ecryptfs_printk(KERN_ERR, "The message received from ecryptfsd "	256	ecryptfs_printk(KERN_ERR, "The message received from ecryptfsd "
257	"is shorter than expected\n");	257	"is shorter than expected\n");
258	rc = -EIO;	258	rc = -EIO;
259	goto out;	259	goto out;
260	}	260	}
261	if (m_size < 3) {	261	if (m_size < 3) {
262	ecryptfs_printk(KERN_ERR,	262	ecryptfs_printk(KERN_ERR,
263	"The decrypted key is not long enough to "	263	"The decrypted key is not long enough to "
264	"include a cipher code and checksum\n");	264	"include a cipher code and checksum\n");
265	rc = -EIO;	265	rc = -EIO;
266	goto out;	266	goto out;
267	}	267	}
268	*cipher_code = data[i++];	268	*cipher_code = data[i++];
269	/* The decrypted key includes 1 byte cipher code and 2 byte checksum */	269	/* The decrypted key includes 1 byte cipher code and 2 byte checksum */
270	session_key->decrypted_key_size = m_size - 3;	270	session_key->decrypted_key_size = m_size - 3;
271	if (session_key->decrypted_key_size > ECRYPTFS_MAX_KEY_BYTES) {	271	if (session_key->decrypted_key_size > ECRYPTFS_MAX_KEY_BYTES) {
272	ecryptfs_printk(KERN_ERR, "key_size [%d] larger than "	272	ecryptfs_printk(KERN_ERR, "key_size [%d] larger than "
273	"the maximum key size [%d]\n",	273	"the maximum key size [%d]\n",
274	session_key->decrypted_key_size,	274	session_key->decrypted_key_size,
275	ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES);	275	ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES);
276	rc = -EIO;	276	rc = -EIO;
277	goto out;	277	goto out;
278	}	278	}
279	memcpy(session_key->decrypted_key, &data[i],	279	memcpy(session_key->decrypted_key, &data[i],
280	session_key->decrypted_key_size);	280	session_key->decrypted_key_size);
281	i += session_key->decrypted_key_size;	281	i += session_key->decrypted_key_size;
282	expected_checksum += (unsigned char)(data[i++]) << 8;	282	expected_checksum += (unsigned char)(data[i++]) << 8;
283	expected_checksum += (unsigned char)(data[i++]);	283	expected_checksum += (unsigned char)(data[i++]);
284	for (i = 0; i < session_key->decrypted_key_size; i++)	284	for (i = 0; i < session_key->decrypted_key_size; i++)
285	checksum += session_key->decrypted_key[i];	285	checksum += session_key->decrypted_key[i];
286	if (expected_checksum != checksum) {	286	if (expected_checksum != checksum) {
287	ecryptfs_printk(KERN_ERR, "Invalid checksum for file "	287	ecryptfs_printk(KERN_ERR, "Invalid checksum for file "
288	"encryption key; expected [%x]; calculated "	288	"encryption key; expected [%x]; calculated "
289	"[%x]\n", expected_checksum, checksum);	289	"[%x]\n", expected_checksum, checksum);
290	rc = -EIO;	290	rc = -EIO;
291	}	291	}
292	out:	292	out:
293	return rc;	293	return rc;
294	}	294	}
295		295
296		296
297	static int	297	static int
298	write_tag_66_packet(char *signature, u8 cipher_code,	298	write_tag_66_packet(char *signature, u8 cipher_code,
299	struct ecryptfs_crypt_stat crypt_stat, char *packet,	299	struct ecryptfs_crypt_stat crypt_stat, char *packet,
300	size_t *packet_len)	300	size_t *packet_len)
301	{	301	{
302	size_t i = 0;	302	size_t i = 0;
303	size_t j;	303	size_t j;
304	size_t data_len;	304	size_t data_len;
305	size_t checksum = 0;	305	size_t checksum = 0;
306	size_t packet_size_len;	306	size_t packet_size_len;
307	char *message;	307	char *message;
308	int rc;	308	int rc;
309		309
310	/*	310	/*
311	* *** TAG 66 Packet Format ***	311	* *** TAG 66 Packet Format ***
312	* \| Content Type \| 1 byte \|	312	* \| Content Type \| 1 byte \|
313	* \| Key Identifier Size \| 1 or 2 bytes \|	313	* \| Key Identifier Size \| 1 or 2 bytes \|
314	* \| Key Identifier \| arbitrary \|	314	* \| Key Identifier \| arbitrary \|
315	* \| File Encryption Key Size \| 1 or 2 bytes \|	315	* \| File Encryption Key Size \| 1 or 2 bytes \|
316	* \| File Encryption Key \| arbitrary \|	316	* \| File Encryption Key \| arbitrary \|
317	*/	317	*/
318	data_len = (5 + ECRYPTFS_SIG_SIZE_HEX + crypt_stat->key_size);	318	data_len = (5 + ECRYPTFS_SIG_SIZE_HEX + crypt_stat->key_size);
319	*packet = kmalloc(data_len, GFP_KERNEL);	319	*packet = kmalloc(data_len, GFP_KERNEL);
320	message = *packet;	320	message = *packet;
321	if (!message) {	321	if (!message) {
322	ecryptfs_printk(KERN_ERR, "Unable to allocate memory\n");	322	ecryptfs_printk(KERN_ERR, "Unable to allocate memory\n");
323	rc = -ENOMEM;	323	rc = -ENOMEM;
324	goto out;	324	goto out;
325	}	325	}
326	message[i++] = ECRYPTFS_TAG_66_PACKET_TYPE;	326	message[i++] = ECRYPTFS_TAG_66_PACKET_TYPE;
327	rc = ecryptfs_write_packet_length(&message[i], ECRYPTFS_SIG_SIZE_HEX,	327	rc = ecryptfs_write_packet_length(&message[i], ECRYPTFS_SIG_SIZE_HEX,
328	&packet_size_len);	328	&packet_size_len);
329	if (rc) {	329	if (rc) {
330	ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet "	330	ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet "
331	"header; cannot generate packet length\n");	331	"header; cannot generate packet length\n");
332	goto out;	332	goto out;
333	}	333	}
334	i += packet_size_len;	334	i += packet_size_len;
335	memcpy(&message[i], signature, ECRYPTFS_SIG_SIZE_HEX);	335	memcpy(&message[i], signature, ECRYPTFS_SIG_SIZE_HEX);
336	i += ECRYPTFS_SIG_SIZE_HEX;	336	i += ECRYPTFS_SIG_SIZE_HEX;
337	/* The encrypted key includes 1 byte cipher code and 2 byte checksum */	337	/* The encrypted key includes 1 byte cipher code and 2 byte checksum */
338	rc = ecryptfs_write_packet_length(&message[i], crypt_stat->key_size + 3,	338	rc = ecryptfs_write_packet_length(&message[i], crypt_stat->key_size + 3,
339	&packet_size_len);	339	&packet_size_len);
340	if (rc) {	340	if (rc) {
341	ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet "	341	ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet "
342	"header; cannot generate packet length\n");	342	"header; cannot generate packet length\n");
343	goto out;	343	goto out;
344	}	344	}
345	i += packet_size_len;	345	i += packet_size_len;
346	message[i++] = cipher_code;	346	message[i++] = cipher_code;
347	memcpy(&message[i], crypt_stat->key, crypt_stat->key_size);	347	memcpy(&message[i], crypt_stat->key, crypt_stat->key_size);
348	i += crypt_stat->key_size;	348	i += crypt_stat->key_size;
349	for (j = 0; j < crypt_stat->key_size; j++)	349	for (j = 0; j < crypt_stat->key_size; j++)
350	checksum += crypt_stat->key[j];	350	checksum += crypt_stat->key[j];
351	message[i++] = (checksum / 256) % 256;	351	message[i++] = (checksum / 256) % 256;
352	message[i++] = (checksum % 256);	352	message[i++] = (checksum % 256);
353	*packet_len = i;	353	*packet_len = i;
354	out:	354	out:
355	return rc;	355	return rc;
356	}	356	}
357		357
358	static int	358	static int
359	parse_tag_67_packet(struct ecryptfs_key_record *key_rec,	359	parse_tag_67_packet(struct ecryptfs_key_record *key_rec,
360	struct ecryptfs_message *msg)	360	struct ecryptfs_message *msg)
361	{	361	{
362	size_t i = 0;	362	size_t i = 0;
363	char *data;	363	char *data;
364	size_t data_len;	364	size_t data_len;
365	size_t message_len;	365	size_t message_len;
366	int rc;	366	int rc;
367		367
368	/*	368	/*
369	* *** TAG 65 Packet Format ***	369	* *** TAG 65 Packet Format ***
370	* \| Content Type \| 1 byte \|	370	* \| Content Type \| 1 byte \|
371	* \| Status Indicator \| 1 byte \|	371	* \| Status Indicator \| 1 byte \|
372	* \| Encrypted File Encryption Key Size \| 1 or 2 bytes \|	372	* \| Encrypted File Encryption Key Size \| 1 or 2 bytes \|
373	* \| Encrypted File Encryption Key \| arbitrary \|	373	* \| Encrypted File Encryption Key \| arbitrary \|
374	*/	374	*/
375	message_len = msg->data_len;	375	message_len = msg->data_len;
376	data = msg->data;	376	data = msg->data;
377	/* verify that everything through the encrypted FEK size is present */	377	/* verify that everything through the encrypted FEK size is present */
378	if (message_len < 4) {	378	if (message_len < 4) {
379	rc = -EIO;	379	rc = -EIO;
380	printk(KERN_ERR "%s: message_len is [%zd]; minimum acceptable "	380	printk(KERN_ERR "%s: message_len is [%zd]; minimum acceptable "
381	"message length is [%d]\n", __func__, message_len, 4);	381	"message length is [%d]\n", __func__, message_len, 4);
382	goto out;	382	goto out;
383	}	383	}
384	if (data[i++] != ECRYPTFS_TAG_67_PACKET_TYPE) {	384	if (data[i++] != ECRYPTFS_TAG_67_PACKET_TYPE) {
385	rc = -EIO;	385	rc = -EIO;
386	printk(KERN_ERR "%s: Type should be ECRYPTFS_TAG_67\n",	386	printk(KERN_ERR "%s: Type should be ECRYPTFS_TAG_67\n",
387	__func__);	387	__func__);
388	goto out;	388	goto out;
389	}	389	}
390	if (data[i++]) {	390	if (data[i++]) {
391	rc = -EIO;	391	rc = -EIO;
392	printk(KERN_ERR "%s: Status indicator has non zero "	392	printk(KERN_ERR "%s: Status indicator has non zero "
393	"value [%d]\n", __func__, data[i-1]);	393	"value [%d]\n", __func__, data[i-1]);
394		394
395	goto out;	395	goto out;
396	}	396	}
397	rc = ecryptfs_parse_packet_length(&data[i], &key_rec->enc_key_size,	397	rc = ecryptfs_parse_packet_length(&data[i], &key_rec->enc_key_size,
398	&data_len);	398	&data_len);
399	if (rc) {	399	if (rc) {
400	ecryptfs_printk(KERN_WARNING, "Error parsing packet length; "	400	ecryptfs_printk(KERN_WARNING, "Error parsing packet length; "
401	"rc = [%d]\n", rc);	401	"rc = [%d]\n", rc);
402	goto out;	402	goto out;
403	}	403	}
404	i += data_len;	404	i += data_len;
405	if (message_len < (i + key_rec->enc_key_size)) {	405	if (message_len < (i + key_rec->enc_key_size)) {
406	rc = -EIO;	406	rc = -EIO;
407	printk(KERN_ERR "%s: message_len [%zd]; max len is [%zd]\n",	407	printk(KERN_ERR "%s: message_len [%zd]; max len is [%zd]\n",
408	__func__, message_len, (i + key_rec->enc_key_size));	408	__func__, message_len, (i + key_rec->enc_key_size));
409	goto out;	409	goto out;
410	}	410	}
411	if (key_rec->enc_key_size > ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES) {	411	if (key_rec->enc_key_size > ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES) {
412	rc = -EIO;	412	rc = -EIO;
413	printk(KERN_ERR "%s: Encrypted key_size [%zd] larger than "	413	printk(KERN_ERR "%s: Encrypted key_size [%zd] larger than "
414	"the maximum key size [%d]\n", __func__,	414	"the maximum key size [%d]\n", __func__,
415	key_rec->enc_key_size,	415	key_rec->enc_key_size,
416	ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES);	416	ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES);
417	goto out;	417	goto out;
418	}	418	}
419	memcpy(key_rec->enc_key, &data[i], key_rec->enc_key_size);	419	memcpy(key_rec->enc_key, &data[i], key_rec->enc_key_size);
420	out:	420	out:
421	return rc;	421	return rc;
422	}	422	}
423		423
424	/**	424	/**
425	* ecryptfs_verify_version	425	* ecryptfs_verify_version
426	* @version: The version number to confirm	426	* @version: The version number to confirm
427	*	427	*
428	* Returns zero on good version; non-zero otherwise	428	* Returns zero on good version; non-zero otherwise
429	*/	429	*/
430	static int ecryptfs_verify_version(u16 version)	430	static int ecryptfs_verify_version(u16 version)
431	{	431	{
432	int rc = 0;	432	int rc = 0;
433	unsigned char major;	433	unsigned char major;
434	unsigned char minor;	434	unsigned char minor;
435		435
436	major = ((version >> 8) & 0xFF);	436	major = ((version >> 8) & 0xFF);
437	minor = (version & 0xFF);	437	minor = (version & 0xFF);
438	if (major != ECRYPTFS_VERSION_MAJOR) {	438	if (major != ECRYPTFS_VERSION_MAJOR) {
439	ecryptfs_printk(KERN_ERR, "Major version number mismatch. "	439	ecryptfs_printk(KERN_ERR, "Major version number mismatch. "
440	"Expected [%d]; got [%d]\n",	440	"Expected [%d]; got [%d]\n",
441	ECRYPTFS_VERSION_MAJOR, major);	441	ECRYPTFS_VERSION_MAJOR, major);
442	rc = -EINVAL;	442	rc = -EINVAL;
443	goto out;	443	goto out;
444	}	444	}
445	if (minor != ECRYPTFS_VERSION_MINOR) {	445	if (minor != ECRYPTFS_VERSION_MINOR) {
446	ecryptfs_printk(KERN_ERR, "Minor version number mismatch. "	446	ecryptfs_printk(KERN_ERR, "Minor version number mismatch. "
447	"Expected [%d]; got [%d]\n",	447	"Expected [%d]; got [%d]\n",
448	ECRYPTFS_VERSION_MINOR, minor);	448	ECRYPTFS_VERSION_MINOR, minor);
449	rc = -EINVAL;	449	rc = -EINVAL;
450	goto out;	450	goto out;
451	}	451	}
452	out:	452	out:
453	return rc;	453	return rc;
454	}	454	}
455		455
456	/**	456	/**
457	* ecryptfs_verify_auth_tok_from_key	457	* ecryptfs_verify_auth_tok_from_key
458	* @auth_tok_key: key containing the authentication token	458	* @auth_tok_key: key containing the authentication token
459	* @auth_tok: authentication token	459	* @auth_tok: authentication token
460	*	460	*
461	* Returns zero on valid auth tok; -EINVAL otherwise	461	* Returns zero on valid auth tok; -EINVAL otherwise
462	*/	462	*/
463	static int	463	static int
464	ecryptfs_verify_auth_tok_from_key(struct key *auth_tok_key,	464	ecryptfs_verify_auth_tok_from_key(struct key *auth_tok_key,
465	struct ecryptfs_auth_tok **auth_tok)	465	struct ecryptfs_auth_tok **auth_tok)
466	{	466	{
467	int rc = 0;	467	int rc = 0;
468		468
469	(*auth_tok) = ecryptfs_get_key_payload_data(auth_tok_key);	469	(*auth_tok) = ecryptfs_get_key_payload_data(auth_tok_key);
470	if (ecryptfs_verify_version((*auth_tok)->version)) {	470	if (ecryptfs_verify_version((*auth_tok)->version)) {
471	printk(KERN_ERR "Data structure version mismatch. Userspace "	471	printk(KERN_ERR "Data structure version mismatch. Userspace "
472	"tools must match eCryptfs kernel module with major "	472	"tools must match eCryptfs kernel module with major "
473	"version [%d] and minor version [%d]\n",	473	"version [%d] and minor version [%d]\n",
474	ECRYPTFS_VERSION_MAJOR, ECRYPTFS_VERSION_MINOR);	474	ECRYPTFS_VERSION_MAJOR, ECRYPTFS_VERSION_MINOR);
475	rc = -EINVAL;	475	rc = -EINVAL;
476	goto out;	476	goto out;
477	}	477	}
478	if ((*auth_tok)->token_type != ECRYPTFS_PASSWORD	478	if ((*auth_tok)->token_type != ECRYPTFS_PASSWORD
479	&& (*auth_tok)->token_type != ECRYPTFS_PRIVATE_KEY) {	479	&& (*auth_tok)->token_type != ECRYPTFS_PRIVATE_KEY) {
480	printk(KERN_ERR "Invalid auth_tok structure "	480	printk(KERN_ERR "Invalid auth_tok structure "
481	"returned from key query\n");	481	"returned from key query\n");
482	rc = -EINVAL;	482	rc = -EINVAL;
483	goto out;	483	goto out;
484	}	484	}
485	out:	485	out:
486	return rc;	486	return rc;
487	}	487	}
488		488
489	static int	489	static int
490	ecryptfs_find_global_auth_tok_for_sig(	490	ecryptfs_find_global_auth_tok_for_sig(
491	struct key **auth_tok_key,	491	struct key **auth_tok_key,
492	struct ecryptfs_auth_tok **auth_tok,	492	struct ecryptfs_auth_tok **auth_tok,
493	struct ecryptfs_mount_crypt_stat mount_crypt_stat, char sig)	493	struct ecryptfs_mount_crypt_stat mount_crypt_stat, char sig)
494	{	494	{
495	struct ecryptfs_global_auth_tok *walker;	495	struct ecryptfs_global_auth_tok *walker;
496	int rc = 0;	496	int rc = 0;
497		497
498	(*auth_tok_key) = NULL;	498	(*auth_tok_key) = NULL;
499	(*auth_tok) = NULL;	499	(*auth_tok) = NULL;
500	mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex);	500	mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex);
501	list_for_each_entry(walker,	501	list_for_each_entry(walker,
502	&mount_crypt_stat->global_auth_tok_list,	502	&mount_crypt_stat->global_auth_tok_list,
503	mount_crypt_stat_list) {	503	mount_crypt_stat_list) {
504	if (memcmp(walker->sig, sig, ECRYPTFS_SIG_SIZE_HEX))	504	if (memcmp(walker->sig, sig, ECRYPTFS_SIG_SIZE_HEX))
505	continue;	505	continue;
506		506
507	if (walker->flags & ECRYPTFS_AUTH_TOK_INVALID) {	507	if (walker->flags & ECRYPTFS_AUTH_TOK_INVALID) {
508	rc = -EINVAL;	508	rc = -EINVAL;
509	goto out;	509	goto out;
510	}	510	}
511		511
512	rc = key_validate(walker->global_auth_tok_key);	512	rc = key_validate(walker->global_auth_tok_key);
513	if (rc) {	513	if (rc) {
514	if (rc == -EKEYEXPIRED)	514	if (rc == -EKEYEXPIRED)
515	goto out;	515	goto out;
516	goto out_invalid_auth_tok;	516	goto out_invalid_auth_tok;
517	}	517	}
518		518
519	down_write(&(walker->global_auth_tok_key->sem));	519	down_write(&(walker->global_auth_tok_key->sem));
520	rc = ecryptfs_verify_auth_tok_from_key(	520	rc = ecryptfs_verify_auth_tok_from_key(
521	walker->global_auth_tok_key, auth_tok);	521	walker->global_auth_tok_key, auth_tok);
522	if (rc)	522	if (rc)
523	goto out_invalid_auth_tok_unlock;	523	goto out_invalid_auth_tok_unlock;
524		524
525	(*auth_tok_key) = walker->global_auth_tok_key;	525	(*auth_tok_key) = walker->global_auth_tok_key;
526	key_get(*auth_tok_key);	526	key_get(*auth_tok_key);
527	goto out;	527	goto out;
528	}	528	}
529	rc = -ENOENT;	529	rc = -ENOENT;
530	goto out;	530	goto out;
531	out_invalid_auth_tok_unlock:	531	out_invalid_auth_tok_unlock:
532	up_write(&(walker->global_auth_tok_key->sem));	532	up_write(&(walker->global_auth_tok_key->sem));
533	out_invalid_auth_tok:	533	out_invalid_auth_tok:
534	printk(KERN_WARNING "Invalidating auth tok with sig = [%s]\n", sig);	534	printk(KERN_WARNING "Invalidating auth tok with sig = [%s]\n", sig);
535	walker->flags \|= ECRYPTFS_AUTH_TOK_INVALID;	535	walker->flags \|= ECRYPTFS_AUTH_TOK_INVALID;
536	key_put(walker->global_auth_tok_key);	536	key_put(walker->global_auth_tok_key);
537	walker->global_auth_tok_key = NULL;	537	walker->global_auth_tok_key = NULL;
538	out:	538	out:
539	mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex);	539	mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex);
540	return rc;	540	return rc;
541	}	541	}
542		542
543	/**	543	/**
544	* ecryptfs_find_auth_tok_for_sig	544	* ecryptfs_find_auth_tok_for_sig
545	* @auth_tok: Set to the matching auth_tok; NULL if not found	545	* @auth_tok: Set to the matching auth_tok; NULL if not found
546	* @crypt_stat: inode crypt_stat crypto context	546	* @crypt_stat: inode crypt_stat crypto context
547	* @sig: Sig of auth_tok to find	547	* @sig: Sig of auth_tok to find
548	*	548	*
549	* For now, this function simply looks at the registered auth_tok's	549	* For now, this function simply looks at the registered auth_tok's
550	* linked off the mount_crypt_stat, so all the auth_toks that can be	550	* linked off the mount_crypt_stat, so all the auth_toks that can be
551	* used must be registered at mount time. This function could	551	* used must be registered at mount time. This function could
552	* potentially try a lot harder to find auth_tok's (e.g., by calling	552	* potentially try a lot harder to find auth_tok's (e.g., by calling
553	* out to ecryptfsd to dynamically retrieve an auth_tok object) so	553	* out to ecryptfsd to dynamically retrieve an auth_tok object) so
554	* that static registration of auth_tok's will no longer be necessary.	554	* that static registration of auth_tok's will no longer be necessary.
555	*	555	*
556	* Returns zero on no error; non-zero on error	556	* Returns zero on no error; non-zero on error
557	*/	557	*/
558	static int	558	static int
559	ecryptfs_find_auth_tok_for_sig(	559	ecryptfs_find_auth_tok_for_sig(
560	struct key **auth_tok_key,	560	struct key **auth_tok_key,
561	struct ecryptfs_auth_tok **auth_tok,	561	struct ecryptfs_auth_tok **auth_tok,
562	struct ecryptfs_mount_crypt_stat *mount_crypt_stat,	562	struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
563	char *sig)	563	char *sig)
564	{	564	{
565	int rc = 0;	565	int rc = 0;
566		566
567	rc = ecryptfs_find_global_auth_tok_for_sig(auth_tok_key, auth_tok,	567	rc = ecryptfs_find_global_auth_tok_for_sig(auth_tok_key, auth_tok,
568	mount_crypt_stat, sig);	568	mount_crypt_stat, sig);
569	if (rc == -ENOENT) {	569	if (rc == -ENOENT) {
570	/* if the flag ECRYPTFS_GLOBAL_MOUNT_AUTH_TOK_ONLY is set in the	570	/* if the flag ECRYPTFS_GLOBAL_MOUNT_AUTH_TOK_ONLY is set in the
571	* mount_crypt_stat structure, we prevent to use auth toks that	571	* mount_crypt_stat structure, we prevent to use auth toks that
572	* are not inserted through the ecryptfs_add_global_auth_tok	572	* are not inserted through the ecryptfs_add_global_auth_tok
573	* function.	573	* function.
574	*/	574	*/
575	if (mount_crypt_stat->flags	575	if (mount_crypt_stat->flags
576	& ECRYPTFS_GLOBAL_MOUNT_AUTH_TOK_ONLY)	576	& ECRYPTFS_GLOBAL_MOUNT_AUTH_TOK_ONLY)
577	return -EINVAL;	577	return -EINVAL;
578		578
579	rc = ecryptfs_keyring_auth_tok_for_sig(auth_tok_key, auth_tok,	579	rc = ecryptfs_keyring_auth_tok_for_sig(auth_tok_key, auth_tok,
580	sig);	580	sig);
581	}	581	}
582	return rc;	582	return rc;
583	}	583	}
584		584
585	/**	585	/**
586	* write_tag_70_packet can gobble a lot of stack space. We stuff most	586	* write_tag_70_packet can gobble a lot of stack space. We stuff most
587	* of the function's parameters in a kmalloc'd struct to help reduce	587	* of the function's parameters in a kmalloc'd struct to help reduce
588	* eCryptfs' overall stack usage.	588	* eCryptfs' overall stack usage.
589	*/	589	*/
590	struct ecryptfs_write_tag_70_packet_silly_stack {	590	struct ecryptfs_write_tag_70_packet_silly_stack {
591	u8 cipher_code;	591	u8 cipher_code;
592	size_t max_packet_size;	592	size_t max_packet_size;
593	size_t packet_size_len;	593	size_t packet_size_len;
594	size_t block_aligned_filename_size;	594	size_t block_aligned_filename_size;
595	size_t block_size;	595	size_t block_size;
596	size_t i;	596	size_t i;
597	size_t j;	597	size_t j;
598	size_t num_rand_bytes;	598	size_t num_rand_bytes;
599	struct mutex *tfm_mutex;	599	struct mutex *tfm_mutex;
600	char *block_aligned_filename;	600	char *block_aligned_filename;
601	struct ecryptfs_auth_tok *auth_tok;	601	struct ecryptfs_auth_tok *auth_tok;
602	struct scatterlist src_sg[2];	602	struct scatterlist src_sg[2];
603	struct scatterlist dst_sg[2];	603	struct scatterlist dst_sg[2];
604	struct blkcipher_desc desc;	604	struct blkcipher_desc desc;
605	char iv[ECRYPTFS_MAX_IV_BYTES];	605	char iv[ECRYPTFS_MAX_IV_BYTES];
606	char hash[ECRYPTFS_TAG_70_DIGEST_SIZE];	606	char hash[ECRYPTFS_TAG_70_DIGEST_SIZE];
607	char tmp_hash[ECRYPTFS_TAG_70_DIGEST_SIZE];	607	char tmp_hash[ECRYPTFS_TAG_70_DIGEST_SIZE];
608	struct hash_desc hash_desc;	608	struct hash_desc hash_desc;
609	struct scatterlist hash_sg;	609	struct scatterlist hash_sg;
610	};	610	};
611		611
612	/**	612	/**
613	* write_tag_70_packet - Write encrypted filename (EFN) packet against FNEK	613	* write_tag_70_packet - Write encrypted filename (EFN) packet against FNEK
614	* @filename: NULL-terminated filename string	614	* @filename: NULL-terminated filename string
615	*	615	*
616	* This is the simplest mechanism for achieving filename encryption in	616	* This is the simplest mechanism for achieving filename encryption in
617	* eCryptfs. It encrypts the given filename with the mount-wide	617	* eCryptfs. It encrypts the given filename with the mount-wide
618	* filename encryption key (FNEK) and stores it in a packet to @dest,	618	* filename encryption key (FNEK) and stores it in a packet to @dest,
619	* which the callee will encode and write directly into the dentry	619	* which the callee will encode and write directly into the dentry
620	* name.	620	* name.
621	*/	621	*/
622	int	622	int
623	ecryptfs_write_tag_70_packet(char dest, size_t remaining_bytes,	623	ecryptfs_write_tag_70_packet(char dest, size_t remaining_bytes,
624	size_t *packet_size,	624	size_t *packet_size,
625	struct ecryptfs_mount_crypt_stat *mount_crypt_stat,	625	struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
626	char *filename, size_t filename_size)	626	char *filename, size_t filename_size)
627	{	627	{
628	struct ecryptfs_write_tag_70_packet_silly_stack *s;	628	struct ecryptfs_write_tag_70_packet_silly_stack *s;
629	struct key *auth_tok_key = NULL;	629	struct key *auth_tok_key = NULL;
630	int rc = 0;	630	int rc = 0;
631		631
632	s = kmalloc(sizeof(*s), GFP_KERNEL);	632	s = kmalloc(sizeof(*s), GFP_KERNEL);
633	if (!s) {	633	if (!s) {
634	printk(KERN_ERR "%s: Out of memory whilst trying to kmalloc "	634	printk(KERN_ERR "%s: Out of memory whilst trying to kmalloc "
635	"[%zd] bytes of kernel memory\n", __func__, sizeof(*s));	635	"[%zd] bytes of kernel memory\n", __func__, sizeof(*s));
636	rc = -ENOMEM;	636	rc = -ENOMEM;
637	goto out;	637	goto out;
638	}	638	}
639	s->desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;	639	s->desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;
640	(*packet_size) = 0;	640	(*packet_size) = 0;
641	rc = ecryptfs_find_auth_tok_for_sig(	641	rc = ecryptfs_find_auth_tok_for_sig(
642	&auth_tok_key,	642	&auth_tok_key,
643	&s->auth_tok, mount_crypt_stat,	643	&s->auth_tok, mount_crypt_stat,
644	mount_crypt_stat->global_default_fnek_sig);	644	mount_crypt_stat->global_default_fnek_sig);
645	if (rc) {	645	if (rc) {
646	printk(KERN_ERR "%s: Error attempting to find auth tok for "	646	printk(KERN_ERR "%s: Error attempting to find auth tok for "
647	"fnek sig [%s]; rc = [%d]\n", __func__,	647	"fnek sig [%s]; rc = [%d]\n", __func__,
648	mount_crypt_stat->global_default_fnek_sig, rc);	648	mount_crypt_stat->global_default_fnek_sig, rc);
649	goto out;	649	goto out;
650	}	650	}
651	rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(	651	rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(
652	&s->desc.tfm,	652	&s->desc.tfm,
653	&s->tfm_mutex, mount_crypt_stat->global_default_fn_cipher_name);	653	&s->tfm_mutex, mount_crypt_stat->global_default_fn_cipher_name);
654	if (unlikely(rc)) {	654	if (unlikely(rc)) {
655	printk(KERN_ERR "Internal error whilst attempting to get "	655	printk(KERN_ERR "Internal error whilst attempting to get "
656	"tfm and mutex for cipher name [%s]; rc = [%d]\n",	656	"tfm and mutex for cipher name [%s]; rc = [%d]\n",
657	mount_crypt_stat->global_default_fn_cipher_name, rc);	657	mount_crypt_stat->global_default_fn_cipher_name, rc);
658	goto out;	658	goto out;
659	}	659	}
660	mutex_lock(s->tfm_mutex);	660	mutex_lock(s->tfm_mutex);
661	s->block_size = crypto_blkcipher_blocksize(s->desc.tfm);	661	s->block_size = crypto_blkcipher_blocksize(s->desc.tfm);
662	/* Plus one for the \0 separator between the random prefix	662	/* Plus one for the \0 separator between the random prefix
663	* and the plaintext filename */	663	* and the plaintext filename */
664	s->num_rand_bytes = (ECRYPTFS_FILENAME_MIN_RANDOM_PREPEND_BYTES + 1);	664	s->num_rand_bytes = (ECRYPTFS_FILENAME_MIN_RANDOM_PREPEND_BYTES + 1);
665	s->block_aligned_filename_size = (s->num_rand_bytes + filename_size);	665	s->block_aligned_filename_size = (s->num_rand_bytes + filename_size);
666	if ((s->block_aligned_filename_size % s->block_size) != 0) {	666	if ((s->block_aligned_filename_size % s->block_size) != 0) {
667	s->num_rand_bytes += (s->block_size	667	s->num_rand_bytes += (s->block_size
668	- (s->block_aligned_filename_size	668	- (s->block_aligned_filename_size
669	% s->block_size));	669	% s->block_size));
670	s->block_aligned_filename_size = (s->num_rand_bytes	670	s->block_aligned_filename_size = (s->num_rand_bytes
671	+ filename_size);	671	+ filename_size);
672	}	672	}
673	/* Octet 0: Tag 70 identifier	673	/* Octet 0: Tag 70 identifier
674	* Octets 1-N1: Tag 70 packet size (includes cipher identifier	674	* Octets 1-N1: Tag 70 packet size (includes cipher identifier
675	* and block-aligned encrypted filename size)	675	* and block-aligned encrypted filename size)
676	* Octets N1-N2: FNEK sig (ECRYPTFS_SIG_SIZE)	676	* Octets N1-N2: FNEK sig (ECRYPTFS_SIG_SIZE)
677	* Octet N2-N3: Cipher identifier (1 octet)	677	* Octet N2-N3: Cipher identifier (1 octet)
678	* Octets N3-N4: Block-aligned encrypted filename	678	* Octets N3-N4: Block-aligned encrypted filename
679	* - Consists of a minimum number of random characters, a \0	679	* - Consists of a minimum number of random characters, a \0
680	* separator, and then the filename */	680	* separator, and then the filename */
681	s->max_packet_size = (ECRYPTFS_TAG_70_MAX_METADATA_SIZE	681	s->max_packet_size = (ECRYPTFS_TAG_70_MAX_METADATA_SIZE
682	+ s->block_aligned_filename_size);	682	+ s->block_aligned_filename_size);
683	if (dest == NULL) {	683	if (dest == NULL) {
684	(*packet_size) = s->max_packet_size;	684	(*packet_size) = s->max_packet_size;
685	goto out_unlock;	685	goto out_unlock;
686	}	686	}
687	if (s->max_packet_size > (*remaining_bytes)) {	687	if (s->max_packet_size > (*remaining_bytes)) {
688	printk(KERN_WARNING "%s: Require [%zd] bytes to write; only "	688	printk(KERN_WARNING "%s: Require [%zd] bytes to write; only "
689	"[%zd] available\n", __func__, s->max_packet_size,	689	"[%zd] available\n", __func__, s->max_packet_size,
690	(*remaining_bytes));	690	(*remaining_bytes));
691	rc = -EINVAL;	691	rc = -EINVAL;
692	goto out_unlock;	692	goto out_unlock;
693	}	693	}
694	s->block_aligned_filename = kzalloc(s->block_aligned_filename_size,	694	s->block_aligned_filename = kzalloc(s->block_aligned_filename_size,
695	GFP_KERNEL);	695	GFP_KERNEL);
696	if (!s->block_aligned_filename) {	696	if (!s->block_aligned_filename) {
697	printk(KERN_ERR "%s: Out of kernel memory whilst attempting to "	697	printk(KERN_ERR "%s: Out of kernel memory whilst attempting to "
698	"kzalloc [%zd] bytes\n", __func__,	698	"kzalloc [%zd] bytes\n", __func__,
699	s->block_aligned_filename_size);	699	s->block_aligned_filename_size);
700	rc = -ENOMEM;	700	rc = -ENOMEM;
701	goto out_unlock;	701	goto out_unlock;
702	}	702	}
703	s->i = 0;	703	s->i = 0;
704	dest[s->i++] = ECRYPTFS_TAG_70_PACKET_TYPE;	704	dest[s->i++] = ECRYPTFS_TAG_70_PACKET_TYPE;
705	rc = ecryptfs_write_packet_length(&dest[s->i],	705	rc = ecryptfs_write_packet_length(&dest[s->i],
706	(ECRYPTFS_SIG_SIZE	706	(ECRYPTFS_SIG_SIZE
707	+ 1 /* Cipher code */	707	+ 1 /* Cipher code */
708	+ s->block_aligned_filename_size),	708	+ s->block_aligned_filename_size),
709	&s->packet_size_len);	709	&s->packet_size_len);
710	if (rc) {	710	if (rc) {
711	printk(KERN_ERR "%s: Error generating tag 70 packet "	711	printk(KERN_ERR "%s: Error generating tag 70 packet "
712	"header; cannot generate packet length; rc = [%d]\n",	712	"header; cannot generate packet length; rc = [%d]\n",
713	__func__, rc);	713	__func__, rc);
714	goto out_free_unlock;	714	goto out_free_unlock;
715	}	715	}
716	s->i += s->packet_size_len;	716	s->i += s->packet_size_len;
717	ecryptfs_from_hex(&dest[s->i],	717	ecryptfs_from_hex(&dest[s->i],
718	mount_crypt_stat->global_default_fnek_sig,	718	mount_crypt_stat->global_default_fnek_sig,
719	ECRYPTFS_SIG_SIZE);	719	ECRYPTFS_SIG_SIZE);
720	s->i += ECRYPTFS_SIG_SIZE;	720	s->i += ECRYPTFS_SIG_SIZE;
721	s->cipher_code = ecryptfs_code_for_cipher_string(	721	s->cipher_code = ecryptfs_code_for_cipher_string(
722	mount_crypt_stat->global_default_fn_cipher_name,	722	mount_crypt_stat->global_default_fn_cipher_name,
723	mount_crypt_stat->global_default_fn_cipher_key_bytes);	723	mount_crypt_stat->global_default_fn_cipher_key_bytes);
724	if (s->cipher_code == 0) {	724	if (s->cipher_code == 0) {
725	printk(KERN_WARNING "%s: Unable to generate code for "	725	printk(KERN_WARNING "%s: Unable to generate code for "
726	"cipher [%s] with key bytes [%zd]\n", __func__,	726	"cipher [%s] with key bytes [%zd]\n", __func__,
727	mount_crypt_stat->global_default_fn_cipher_name,	727	mount_crypt_stat->global_default_fn_cipher_name,
728	mount_crypt_stat->global_default_fn_cipher_key_bytes);	728	mount_crypt_stat->global_default_fn_cipher_key_bytes);
729	rc = -EINVAL;	729	rc = -EINVAL;
730	goto out_free_unlock;	730	goto out_free_unlock;
731	}	731	}
732	dest[s->i++] = s->cipher_code;	732	dest[s->i++] = s->cipher_code;
733	/* TODO: Support other key modules than passphrase for	733	/* TODO: Support other key modules than passphrase for
734	* filename encryption */	734	* filename encryption */
735	if (s->auth_tok->token_type != ECRYPTFS_PASSWORD) {	735	if (s->auth_tok->token_type != ECRYPTFS_PASSWORD) {
736	rc = -EOPNOTSUPP;	736	rc = -EOPNOTSUPP;
737	printk(KERN_INFO "%s: Filename encryption only supports "	737	printk(KERN_INFO "%s: Filename encryption only supports "
738	"password tokens\n", __func__);	738	"password tokens\n", __func__);
739	goto out_free_unlock;	739	goto out_free_unlock;
740	}	740	}
741	sg_init_one(	741	sg_init_one(
742	&s->hash_sg,	742	&s->hash_sg,
743	(u8 *)s->auth_tok->token.password.session_key_encryption_key,	743	(u8 *)s->auth_tok->token.password.session_key_encryption_key,
744	s->auth_tok->token.password.session_key_encryption_key_bytes);	744	s->auth_tok->token.password.session_key_encryption_key_bytes);
745	s->hash_desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;	745	s->hash_desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;
746	s->hash_desc.tfm = crypto_alloc_hash(ECRYPTFS_TAG_70_DIGEST, 0,	746	s->hash_desc.tfm = crypto_alloc_hash(ECRYPTFS_TAG_70_DIGEST, 0,
747	CRYPTO_ALG_ASYNC);	747	CRYPTO_ALG_ASYNC);
748	if (IS_ERR(s->hash_desc.tfm)) {	748	if (IS_ERR(s->hash_desc.tfm)) {
749	rc = PTR_ERR(s->hash_desc.tfm);	749	rc = PTR_ERR(s->hash_desc.tfm);
750	printk(KERN_ERR "%s: Error attempting to "	750	printk(KERN_ERR "%s: Error attempting to "
751	"allocate hash crypto context; rc = [%d]\n",	751	"allocate hash crypto context; rc = [%d]\n",
752	__func__, rc);	752	__func__, rc);
753	goto out_free_unlock;	753	goto out_free_unlock;
754	}	754	}
755	rc = crypto_hash_init(&s->hash_desc);	755	rc = crypto_hash_init(&s->hash_desc);
756	if (rc) {	756	if (rc) {
757	printk(KERN_ERR	757	printk(KERN_ERR
758	"%s: Error initializing crypto hash; rc = [%d]\n",	758	"%s: Error initializing crypto hash; rc = [%d]\n",
759	__func__, rc);	759	__func__, rc);
760	goto out_release_free_unlock;	760	goto out_release_free_unlock;
761	}	761	}
762	rc = crypto_hash_update(	762	rc = crypto_hash_update(
763	&s->hash_desc, &s->hash_sg,	763	&s->hash_desc, &s->hash_sg,
764	s->auth_tok->token.password.session_key_encryption_key_bytes);	764	s->auth_tok->token.password.session_key_encryption_key_bytes);
765	if (rc) {	765	if (rc) {
766	printk(KERN_ERR	766	printk(KERN_ERR
767	"%s: Error updating crypto hash; rc = [%d]\n",	767	"%s: Error updating crypto hash; rc = [%d]\n",
768	__func__, rc);	768	__func__, rc);
769	goto out_release_free_unlock;	769	goto out_release_free_unlock;
770	}	770	}
771	rc = crypto_hash_final(&s->hash_desc, s->hash);	771	rc = crypto_hash_final(&s->hash_desc, s->hash);
772	if (rc) {	772	if (rc) {
773	printk(KERN_ERR	773	printk(KERN_ERR
774	"%s: Error finalizing crypto hash; rc = [%d]\n",	774	"%s: Error finalizing crypto hash; rc = [%d]\n",
775	__func__, rc);	775	__func__, rc);
776	goto out_release_free_unlock;	776	goto out_release_free_unlock;
777	}	777	}
778	for (s->j = 0; s->j < (s->num_rand_bytes - 1); s->j++) {	778	for (s->j = 0; s->j < (s->num_rand_bytes - 1); s->j++) {
779	s->block_aligned_filename[s->j] =	779	s->block_aligned_filename[s->j] =
780	s->hash[(s->j % ECRYPTFS_TAG_70_DIGEST_SIZE)];	780	s->hash[(s->j % ECRYPTFS_TAG_70_DIGEST_SIZE)];
781	if ((s->j % ECRYPTFS_TAG_70_DIGEST_SIZE)	781	if ((s->j % ECRYPTFS_TAG_70_DIGEST_SIZE)
782	== (ECRYPTFS_TAG_70_DIGEST_SIZE - 1)) {	782	== (ECRYPTFS_TAG_70_DIGEST_SIZE - 1)) {
783	sg_init_one(&s->hash_sg, (u8 *)s->hash,	783	sg_init_one(&s->hash_sg, (u8 *)s->hash,
784	ECRYPTFS_TAG_70_DIGEST_SIZE);	784	ECRYPTFS_TAG_70_DIGEST_SIZE);
785	rc = crypto_hash_init(&s->hash_desc);	785	rc = crypto_hash_init(&s->hash_desc);
786	if (rc) {	786	if (rc) {
787	printk(KERN_ERR	787	printk(KERN_ERR
788	"%s: Error initializing crypto hash; "	788	"%s: Error initializing crypto hash; "
789	"rc = [%d]\n", __func__, rc);	789	"rc = [%d]\n", __func__, rc);
790	goto out_release_free_unlock;	790	goto out_release_free_unlock;
791	}	791	}
792	rc = crypto_hash_update(&s->hash_desc, &s->hash_sg,	792	rc = crypto_hash_update(&s->hash_desc, &s->hash_sg,
793	ECRYPTFS_TAG_70_DIGEST_SIZE);	793	ECRYPTFS_TAG_70_DIGEST_SIZE);
794	if (rc) {	794	if (rc) {
795	printk(KERN_ERR	795	printk(KERN_ERR
796	"%s: Error updating crypto hash; "	796	"%s: Error updating crypto hash; "
797	"rc = [%d]\n", __func__, rc);	797	"rc = [%d]\n", __func__, rc);
798	goto out_release_free_unlock;	798	goto out_release_free_unlock;
799	}	799	}
800	rc = crypto_hash_final(&s->hash_desc, s->tmp_hash);	800	rc = crypto_hash_final(&s->hash_desc, s->tmp_hash);
801	if (rc) {	801	if (rc) {
802	printk(KERN_ERR	802	printk(KERN_ERR
803	"%s: Error finalizing crypto hash; "	803	"%s: Error finalizing crypto hash; "
804	"rc = [%d]\n", __func__, rc);	804	"rc = [%d]\n", __func__, rc);
805	goto out_release_free_unlock;	805	goto out_release_free_unlock;
806	}	806	}
807	memcpy(s->hash, s->tmp_hash,	807	memcpy(s->hash, s->tmp_hash,
808	ECRYPTFS_TAG_70_DIGEST_SIZE);	808	ECRYPTFS_TAG_70_DIGEST_SIZE);
809	}	809	}
810	if (s->block_aligned_filename[s->j] == '\0')	810	if (s->block_aligned_filename[s->j] == '\0')
811	s->block_aligned_filename[s->j] = ECRYPTFS_NON_NULL;	811	s->block_aligned_filename[s->j] = ECRYPTFS_NON_NULL;
812	}	812	}
813	memcpy(&s->block_aligned_filename[s->num_rand_bytes], filename,	813	memcpy(&s->block_aligned_filename[s->num_rand_bytes], filename,
814	filename_size);	814	filename_size);
815	rc = virt_to_scatterlist(s->block_aligned_filename,	815	rc = virt_to_scatterlist(s->block_aligned_filename,
816	s->block_aligned_filename_size, s->src_sg, 2);	816	s->block_aligned_filename_size, s->src_sg, 2);
817	if (rc < 1) {	817	if (rc < 1) {
818	printk(KERN_ERR "%s: Internal error whilst attempting to "	818	printk(KERN_ERR "%s: Internal error whilst attempting to "
819	"convert filename memory to scatterlist; rc = [%d]. "	819	"convert filename memory to scatterlist; rc = [%d]. "
820	"block_aligned_filename_size = [%zd]\n", __func__, rc,	820	"block_aligned_filename_size = [%zd]\n", __func__, rc,
821	s->block_aligned_filename_size);	821	s->block_aligned_filename_size);
822	goto out_release_free_unlock;	822	goto out_release_free_unlock;
823	}	823	}
824	rc = virt_to_scatterlist(&dest[s->i], s->block_aligned_filename_size,	824	rc = virt_to_scatterlist(&dest[s->i], s->block_aligned_filename_size,
825	s->dst_sg, 2);	825	s->dst_sg, 2);
826	if (rc < 1) {	826	if (rc < 1) {
827	printk(KERN_ERR "%s: Internal error whilst attempting to "	827	printk(KERN_ERR "%s: Internal error whilst attempting to "
828	"convert encrypted filename memory to scatterlist; "	828	"convert encrypted filename memory to scatterlist; "
829	"rc = [%d]. block_aligned_filename_size = [%zd]\n",	829	"rc = [%d]. block_aligned_filename_size = [%zd]\n",
830	__func__, rc, s->block_aligned_filename_size);	830	__func__, rc, s->block_aligned_filename_size);
831	goto out_release_free_unlock;	831	goto out_release_free_unlock;
832	}	832	}
833	/* The characters in the first block effectively do the job	833	/* The characters in the first block effectively do the job
834	* of the IV here, so we just use 0's for the IV. Note the	834	* of the IV here, so we just use 0's for the IV. Note the
835	* constraint that ECRYPTFS_FILENAME_MIN_RANDOM_PREPEND_BYTES	835	* constraint that ECRYPTFS_FILENAME_MIN_RANDOM_PREPEND_BYTES
836	* >= ECRYPTFS_MAX_IV_BYTES. */	836	* >= ECRYPTFS_MAX_IV_BYTES. */
837	memset(s->iv, 0, ECRYPTFS_MAX_IV_BYTES);	837	memset(s->iv, 0, ECRYPTFS_MAX_IV_BYTES);
838	s->desc.info = s->iv;	838	s->desc.info = s->iv;
839	rc = crypto_blkcipher_setkey(	839	rc = crypto_blkcipher_setkey(
840	s->desc.tfm,	840	s->desc.tfm,
841	s->auth_tok->token.password.session_key_encryption_key,	841	s->auth_tok->token.password.session_key_encryption_key,
842	mount_crypt_stat->global_default_fn_cipher_key_bytes);	842	mount_crypt_stat->global_default_fn_cipher_key_bytes);
843	if (rc < 0) {	843	if (rc < 0) {
844	printk(KERN_ERR "%s: Error setting key for crypto context; "	844	printk(KERN_ERR "%s: Error setting key for crypto context; "
845	"rc = [%d]. s->auth_tok->token.password.session_key_"	845	"rc = [%d]. s->auth_tok->token.password.session_key_"
846	"encryption_key = [0x%p]; mount_crypt_stat->"	846	"encryption_key = [0x%p]; mount_crypt_stat->"
847	"global_default_fn_cipher_key_bytes = [%zd]\n", __func__,	847	"global_default_fn_cipher_key_bytes = [%zd]\n", __func__,
848	rc,	848	rc,
849	s->auth_tok->token.password.session_key_encryption_key,	849	s->auth_tok->token.password.session_key_encryption_key,
850	mount_crypt_stat->global_default_fn_cipher_key_bytes);	850	mount_crypt_stat->global_default_fn_cipher_key_bytes);
851	goto out_release_free_unlock;	851	goto out_release_free_unlock;
852	}	852	}
853	rc = crypto_blkcipher_encrypt_iv(&s->desc, s->dst_sg, s->src_sg,	853	rc = crypto_blkcipher_encrypt_iv(&s->desc, s->dst_sg, s->src_sg,
854	s->block_aligned_filename_size);	854	s->block_aligned_filename_size);
855	if (rc) {	855	if (rc) {
856	printk(KERN_ERR "%s: Error attempting to encrypt filename; "	856	printk(KERN_ERR "%s: Error attempting to encrypt filename; "
857	"rc = [%d]\n", __func__, rc);	857	"rc = [%d]\n", __func__, rc);
858	goto out_release_free_unlock;	858	goto out_release_free_unlock;
859	}	859	}
860	s->i += s->block_aligned_filename_size;	860	s->i += s->block_aligned_filename_size;
861	(*packet_size) = s->i;	861	(*packet_size) = s->i;
862	(remaining_bytes) -= (packet_size);	862	(remaining_bytes) -= (packet_size);
863	out_release_free_unlock:	863	out_release_free_unlock:
864	crypto_free_hash(s->hash_desc.tfm);	864	crypto_free_hash(s->hash_desc.tfm);
865	out_free_unlock:	865	out_free_unlock:
866	kzfree(s->block_aligned_filename);	866	kzfree(s->block_aligned_filename);
867	out_unlock:	867	out_unlock:
868	mutex_unlock(s->tfm_mutex);	868	mutex_unlock(s->tfm_mutex);
869	out:	869	out:
870	if (auth_tok_key) {	870	if (auth_tok_key) {
871	up_write(&(auth_tok_key->sem));	871	up_write(&(auth_tok_key->sem));
872	key_put(auth_tok_key);	872	key_put(auth_tok_key);
873	}	873	}
874	kfree(s);	874	kfree(s);
875	return rc;	875	return rc;
876	}	876	}
877		877
878	struct ecryptfs_parse_tag_70_packet_silly_stack {	878	struct ecryptfs_parse_tag_70_packet_silly_stack {
879	u8 cipher_code;	879	u8 cipher_code;
880	size_t max_packet_size;	880	size_t max_packet_size;
881	size_t packet_size_len;	881	size_t packet_size_len;
882	size_t parsed_tag_70_packet_size;	882	size_t parsed_tag_70_packet_size;
883	size_t block_aligned_filename_size;	883	size_t block_aligned_filename_size;
884	size_t block_size;	884	size_t block_size;
885	size_t i;	885	size_t i;
886	struct mutex *tfm_mutex;	886	struct mutex *tfm_mutex;
887	char *decrypted_filename;	887	char *decrypted_filename;
888	struct ecryptfs_auth_tok *auth_tok;	888	struct ecryptfs_auth_tok *auth_tok;
889	struct scatterlist src_sg[2];	889	struct scatterlist src_sg[2];
890	struct scatterlist dst_sg[2];	890	struct scatterlist dst_sg[2];
891	struct blkcipher_desc desc;	891	struct blkcipher_desc desc;
892	char fnek_sig_hex[ECRYPTFS_SIG_SIZE_HEX + 1];	892	char fnek_sig_hex[ECRYPTFS_SIG_SIZE_HEX + 1];
893	char iv[ECRYPTFS_MAX_IV_BYTES];	893	char iv[ECRYPTFS_MAX_IV_BYTES];
894	char cipher_string[ECRYPTFS_MAX_CIPHER_NAME_SIZE];	894	char cipher_string[ECRYPTFS_MAX_CIPHER_NAME_SIZE];
895	};	895	};
896		896
897	/**	897	/**
898	* parse_tag_70_packet - Parse and process FNEK-encrypted passphrase packet	898	* parse_tag_70_packet - Parse and process FNEK-encrypted passphrase packet
899	* @filename: This function kmalloc's the memory for the filename	899	* @filename: This function kmalloc's the memory for the filename
900	* @filename_size: This function sets this to the amount of memory	900	* @filename_size: This function sets this to the amount of memory
901	* kmalloc'd for the filename	901	* kmalloc'd for the filename
902	* @packet_size: This function sets this to the the number of octets	902	* @packet_size: This function sets this to the the number of octets
903	* in the packet parsed	903	* in the packet parsed
904	* @mount_crypt_stat: The mount-wide cryptographic context	904	* @mount_crypt_stat: The mount-wide cryptographic context
905	* @data: The memory location containing the start of the tag 70	905	* @data: The memory location containing the start of the tag 70
906	* packet	906	* packet
907	* @max_packet_size: The maximum legal size of the packet to be parsed	907	* @max_packet_size: The maximum legal size of the packet to be parsed
908	* from @data	908	* from @data
909	*	909	*
910	* Returns zero on success; non-zero otherwise	910	* Returns zero on success; non-zero otherwise
911	*/	911	*/
912	int	912	int
913	ecryptfs_parse_tag_70_packet(char *filename, size_t filename_size,	913	ecryptfs_parse_tag_70_packet(char *filename, size_t filename_size,
914	size_t *packet_size,	914	size_t *packet_size,
915	struct ecryptfs_mount_crypt_stat *mount_crypt_stat,	915	struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
916	char *data, size_t max_packet_size)	916	char *data, size_t max_packet_size)
917	{	917	{
918	struct ecryptfs_parse_tag_70_packet_silly_stack *s;	918	struct ecryptfs_parse_tag_70_packet_silly_stack *s;
919	struct key *auth_tok_key = NULL;	919	struct key *auth_tok_key = NULL;
920	int rc = 0;	920	int rc = 0;
921		921
922	(*packet_size) = 0;	922	(*packet_size) = 0;
923	(*filename_size) = 0;	923	(*filename_size) = 0;
924	(*filename) = NULL;	924	(*filename) = NULL;
925	s = kmalloc(sizeof(*s), GFP_KERNEL);	925	s = kmalloc(sizeof(*s), GFP_KERNEL);
926	if (!s) {	926	if (!s) {
927	printk(KERN_ERR "%s: Out of memory whilst trying to kmalloc "	927	printk(KERN_ERR "%s: Out of memory whilst trying to kmalloc "
928	"[%zd] bytes of kernel memory\n", __func__, sizeof(*s));	928	"[%zd] bytes of kernel memory\n", __func__, sizeof(*s));
929	rc = -ENOMEM;	929	rc = -ENOMEM;
930	goto out;	930	goto out;
931	}	931	}
932	s->desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;	932	s->desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;
933	if (max_packet_size < ECRYPTFS_TAG_70_MIN_METADATA_SIZE) {	933	if (max_packet_size < ECRYPTFS_TAG_70_MIN_METADATA_SIZE) {
934	printk(KERN_WARNING "%s: max_packet_size is [%zd]; it must be "	934	printk(KERN_WARNING "%s: max_packet_size is [%zd]; it must be "
935	"at least [%d]\n", __func__, max_packet_size,	935	"at least [%d]\n", __func__, max_packet_size,
936	ECRYPTFS_TAG_70_MIN_METADATA_SIZE);	936	ECRYPTFS_TAG_70_MIN_METADATA_SIZE);
937	rc = -EINVAL;	937	rc = -EINVAL;
938	goto out;	938	goto out;
939	}	939	}
940	/* Octet 0: Tag 70 identifier	940	/* Octet 0: Tag 70 identifier
941	* Octets 1-N1: Tag 70 packet size (includes cipher identifier	941	* Octets 1-N1: Tag 70 packet size (includes cipher identifier
942	* and block-aligned encrypted filename size)	942	* and block-aligned encrypted filename size)
943	* Octets N1-N2: FNEK sig (ECRYPTFS_SIG_SIZE)	943	* Octets N1-N2: FNEK sig (ECRYPTFS_SIG_SIZE)
944	* Octet N2-N3: Cipher identifier (1 octet)	944	* Octet N2-N3: Cipher identifier (1 octet)
945	* Octets N3-N4: Block-aligned encrypted filename	945	* Octets N3-N4: Block-aligned encrypted filename
946	* - Consists of a minimum number of random numbers, a \0	946	* - Consists of a minimum number of random numbers, a \0
947	* separator, and then the filename */	947	* separator, and then the filename */
948	if (data[(*packet_size)++] != ECRYPTFS_TAG_70_PACKET_TYPE) {	948	if (data[(*packet_size)++] != ECRYPTFS_TAG_70_PACKET_TYPE) {
949	printk(KERN_WARNING "%s: Invalid packet tag [0x%.2x]; must be "	949	printk(KERN_WARNING "%s: Invalid packet tag [0x%.2x]; must be "
950	"tag [0x%.2x]\n", __func__,	950	"tag [0x%.2x]\n", __func__,
951	data[((*packet_size) - 1)], ECRYPTFS_TAG_70_PACKET_TYPE);	951	data[((*packet_size) - 1)], ECRYPTFS_TAG_70_PACKET_TYPE);
952	rc = -EINVAL;	952	rc = -EINVAL;
953	goto out;	953	goto out;
954	}	954	}
955	rc = ecryptfs_parse_packet_length(&data[(*packet_size)],	955	rc = ecryptfs_parse_packet_length(&data[(*packet_size)],
956	&s->parsed_tag_70_packet_size,	956	&s->parsed_tag_70_packet_size,
957	&s->packet_size_len);	957	&s->packet_size_len);
958	if (rc) {	958	if (rc) {
959	printk(KERN_WARNING "%s: Error parsing packet length; "	959	printk(KERN_WARNING "%s: Error parsing packet length; "
960	"rc = [%d]\n", __func__, rc);	960	"rc = [%d]\n", __func__, rc);
961	goto out;	961	goto out;
962	}	962	}
963	s->block_aligned_filename_size = (s->parsed_tag_70_packet_size	963	s->block_aligned_filename_size = (s->parsed_tag_70_packet_size
964	- ECRYPTFS_SIG_SIZE - 1);	964	- ECRYPTFS_SIG_SIZE - 1);
965	if ((1 + s->packet_size_len + s->parsed_tag_70_packet_size)	965	if ((1 + s->packet_size_len + s->parsed_tag_70_packet_size)
966	> max_packet_size) {	966	> max_packet_size) {
967	printk(KERN_WARNING "%s: max_packet_size is [%zd]; real packet "	967	printk(KERN_WARNING "%s: max_packet_size is [%zd]; real packet "
968	"size is [%zd]\n", __func__, max_packet_size,	968	"size is [%zd]\n", __func__, max_packet_size,
969	(1 + s->packet_size_len + 1	969	(1 + s->packet_size_len + 1
970	+ s->block_aligned_filename_size));	970	+ s->block_aligned_filename_size));
971	rc = -EINVAL;	971	rc = -EINVAL;
972	goto out;	972	goto out;
973	}	973	}
974	(*packet_size) += s->packet_size_len;	974	(*packet_size) += s->packet_size_len;
975	ecryptfs_to_hex(s->fnek_sig_hex, &data[(*packet_size)],	975	ecryptfs_to_hex(s->fnek_sig_hex, &data[(*packet_size)],
976	ECRYPTFS_SIG_SIZE);	976	ECRYPTFS_SIG_SIZE);
977	s->fnek_sig_hex[ECRYPTFS_SIG_SIZE_HEX] = '\0';	977	s->fnek_sig_hex[ECRYPTFS_SIG_SIZE_HEX] = '\0';
978	(*packet_size) += ECRYPTFS_SIG_SIZE;	978	(*packet_size) += ECRYPTFS_SIG_SIZE;
979	s->cipher_code = data[(*packet_size)++];	979	s->cipher_code = data[(*packet_size)++];
980	rc = ecryptfs_cipher_code_to_string(s->cipher_string, s->cipher_code);	980	rc = ecryptfs_cipher_code_to_string(s->cipher_string, s->cipher_code);
981	if (rc) {	981	if (rc) {
982	printk(KERN_WARNING "%s: Cipher code [%d] is invalid\n",	982	printk(KERN_WARNING "%s: Cipher code [%d] is invalid\n",
983	__func__, s->cipher_code);	983	__func__, s->cipher_code);
984	goto out;	984	goto out;
985	}	985	}
986	rc = ecryptfs_find_auth_tok_for_sig(&auth_tok_key,	986	rc = ecryptfs_find_auth_tok_for_sig(&auth_tok_key,
987	&s->auth_tok, mount_crypt_stat,	987	&s->auth_tok, mount_crypt_stat,
988	s->fnek_sig_hex);	988	s->fnek_sig_hex);
989	if (rc) {	989	if (rc) {
990	printk(KERN_ERR "%s: Error attempting to find auth tok for "	990	printk(KERN_ERR "%s: Error attempting to find auth tok for "
991	"fnek sig [%s]; rc = [%d]\n", __func__, s->fnek_sig_hex,	991	"fnek sig [%s]; rc = [%d]\n", __func__, s->fnek_sig_hex,
992	rc);	992	rc);
993	goto out;	993	goto out;
994	}	994	}
995	rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(&s->desc.tfm,	995	rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(&s->desc.tfm,
996	&s->tfm_mutex,	996	&s->tfm_mutex,
997	s->cipher_string);	997	s->cipher_string);
998	if (unlikely(rc)) {	998	if (unlikely(rc)) {
999	printk(KERN_ERR "Internal error whilst attempting to get "	999	printk(KERN_ERR "Internal error whilst attempting to get "
1000	"tfm and mutex for cipher name [%s]; rc = [%d]\n",	1000	"tfm and mutex for cipher name [%s]; rc = [%d]\n",
1001	s->cipher_string, rc);	1001	s->cipher_string, rc);
1002	goto out;	1002	goto out;
1003	}	1003	}
1004	mutex_lock(s->tfm_mutex);	1004	mutex_lock(s->tfm_mutex);
1005	rc = virt_to_scatterlist(&data[(*packet_size)],	1005	rc = virt_to_scatterlist(&data[(*packet_size)],
1006	s->block_aligned_filename_size, s->src_sg, 2);	1006	s->block_aligned_filename_size, s->src_sg, 2);
1007	if (rc < 1) {	1007	if (rc < 1) {
1008	printk(KERN_ERR "%s: Internal error whilst attempting to "	1008	printk(KERN_ERR "%s: Internal error whilst attempting to "
1009	"convert encrypted filename memory to scatterlist; "	1009	"convert encrypted filename memory to scatterlist; "
1010	"rc = [%d]. block_aligned_filename_size = [%zd]\n",	1010	"rc = [%d]. block_aligned_filename_size = [%zd]\n",
1011	__func__, rc, s->block_aligned_filename_size);	1011	__func__, rc, s->block_aligned_filename_size);
1012	goto out_unlock;	1012	goto out_unlock;
1013	}	1013	}
1014	(*packet_size) += s->block_aligned_filename_size;	1014	(*packet_size) += s->block_aligned_filename_size;
1015	s->decrypted_filename = kmalloc(s->block_aligned_filename_size,	1015	s->decrypted_filename = kmalloc(s->block_aligned_filename_size,
1016	GFP_KERNEL);	1016	GFP_KERNEL);
1017	if (!s->decrypted_filename) {	1017	if (!s->decrypted_filename) {
1018	printk(KERN_ERR "%s: Out of memory whilst attempting to "	1018	printk(KERN_ERR "%s: Out of memory whilst attempting to "
1019	"kmalloc [%zd] bytes\n", __func__,	1019	"kmalloc [%zd] bytes\n", __func__,
1020	s->block_aligned_filename_size);	1020	s->block_aligned_filename_size);
1021	rc = -ENOMEM;	1021	rc = -ENOMEM;
1022	goto out_unlock;	1022	goto out_unlock;
1023	}	1023	}
1024	rc = virt_to_scatterlist(s->decrypted_filename,	1024	rc = virt_to_scatterlist(s->decrypted_filename,
1025	s->block_aligned_filename_size, s->dst_sg, 2);	1025	s->block_aligned_filename_size, s->dst_sg, 2);
1026	if (rc < 1) {	1026	if (rc < 1) {
1027	printk(KERN_ERR "%s: Internal error whilst attempting to "	1027	printk(KERN_ERR "%s: Internal error whilst attempting to "
1028	"convert decrypted filename memory to scatterlist; "	1028	"convert decrypted filename memory to scatterlist; "
1029	"rc = [%d]. block_aligned_filename_size = [%zd]\n",	1029	"rc = [%d]. block_aligned_filename_size = [%zd]\n",
1030	__func__, rc, s->block_aligned_filename_size);	1030	__func__, rc, s->block_aligned_filename_size);
1031	goto out_free_unlock;	1031	goto out_free_unlock;
1032	}	1032	}
1033	/* The characters in the first block effectively do the job of	1033	/* The characters in the first block effectively do the job of
1034	* the IV here, so we just use 0's for the IV. Note the	1034	* the IV here, so we just use 0's for the IV. Note the
1035	* constraint that ECRYPTFS_FILENAME_MIN_RANDOM_PREPEND_BYTES	1035	* constraint that ECRYPTFS_FILENAME_MIN_RANDOM_PREPEND_BYTES
1036	* >= ECRYPTFS_MAX_IV_BYTES. */	1036	* >= ECRYPTFS_MAX_IV_BYTES. */
1037	memset(s->iv, 0, ECRYPTFS_MAX_IV_BYTES);	1037	memset(s->iv, 0, ECRYPTFS_MAX_IV_BYTES);
1038	s->desc.info = s->iv;	1038	s->desc.info = s->iv;
1039	/* TODO: Support other key modules than passphrase for	1039	/* TODO: Support other key modules than passphrase for
1040	* filename encryption */	1040	* filename encryption */
1041	if (s->auth_tok->token_type != ECRYPTFS_PASSWORD) {	1041	if (s->auth_tok->token_type != ECRYPTFS_PASSWORD) {
1042	rc = -EOPNOTSUPP;	1042	rc = -EOPNOTSUPP;
1043	printk(KERN_INFO "%s: Filename encryption only supports "	1043	printk(KERN_INFO "%s: Filename encryption only supports "
1044	"password tokens\n", __func__);	1044	"password tokens\n", __func__);
1045	goto out_free_unlock;	1045	goto out_free_unlock;
1046	}	1046	}
1047	rc = crypto_blkcipher_setkey(	1047	rc = crypto_blkcipher_setkey(
1048	s->desc.tfm,	1048	s->desc.tfm,
1049	s->auth_tok->token.password.session_key_encryption_key,	1049	s->auth_tok->token.password.session_key_encryption_key,
1050	mount_crypt_stat->global_default_fn_cipher_key_bytes);	1050	mount_crypt_stat->global_default_fn_cipher_key_bytes);
1051	if (rc < 0) {	1051	if (rc < 0) {
1052	printk(KERN_ERR "%s: Error setting key for crypto context; "	1052	printk(KERN_ERR "%s: Error setting key for crypto context; "
1053	"rc = [%d]. s->auth_tok->token.password.session_key_"	1053	"rc = [%d]. s->auth_tok->token.password.session_key_"
1054	"encryption_key = [0x%p]; mount_crypt_stat->"	1054	"encryption_key = [0x%p]; mount_crypt_stat->"
1055	"global_default_fn_cipher_key_bytes = [%zd]\n", __func__,	1055	"global_default_fn_cipher_key_bytes = [%zd]\n", __func__,
1056	rc,	1056	rc,
1057	s->auth_tok->token.password.session_key_encryption_key,	1057	s->auth_tok->token.password.session_key_encryption_key,
1058	mount_crypt_stat->global_default_fn_cipher_key_bytes);	1058	mount_crypt_stat->global_default_fn_cipher_key_bytes);
1059	goto out_free_unlock;	1059	goto out_free_unlock;
1060	}	1060	}
1061	rc = crypto_blkcipher_decrypt_iv(&s->desc, s->dst_sg, s->src_sg,	1061	rc = crypto_blkcipher_decrypt_iv(&s->desc, s->dst_sg, s->src_sg,
1062	s->block_aligned_filename_size);	1062	s->block_aligned_filename_size);
1063	if (rc) {	1063	if (rc) {
1064	printk(KERN_ERR "%s: Error attempting to decrypt filename; "	1064	printk(KERN_ERR "%s: Error attempting to decrypt filename; "
1065	"rc = [%d]\n", __func__, rc);	1065	"rc = [%d]\n", __func__, rc);
1066	goto out_free_unlock;	1066	goto out_free_unlock;
1067	}	1067	}
1068	s->i = 0;	1068	s->i = 0;
1069	while (s->decrypted_filename[s->i] != '\0'	1069	while (s->decrypted_filename[s->i] != '\0'
1070	&& s->i < s->block_aligned_filename_size)	1070	&& s->i < s->block_aligned_filename_size)
1071	s->i++;	1071	s->i++;
1072	if (s->i == s->block_aligned_filename_size) {	1072	if (s->i == s->block_aligned_filename_size) {
1073	printk(KERN_WARNING "%s: Invalid tag 70 packet; could not "	1073	printk(KERN_WARNING "%s: Invalid tag 70 packet; could not "
1074	"find valid separator between random characters and "	1074	"find valid separator between random characters and "
1075	"the filename\n", __func__);	1075	"the filename\n", __func__);
1076	rc = -EINVAL;	1076	rc = -EINVAL;
1077	goto out_free_unlock;	1077	goto out_free_unlock;
1078	}	1078	}
1079	s->i++;	1079	s->i++;
1080	(*filename_size) = (s->block_aligned_filename_size - s->i);	1080	(*filename_size) = (s->block_aligned_filename_size - s->i);
1081	if (!((filename_size) > 0 && (filename_size < PATH_MAX))) {	1081	if (!((filename_size) > 0 && (filename_size < PATH_MAX))) {
1082	printk(KERN_WARNING "%s: Filename size is [%zd], which is "	1082	printk(KERN_WARNING "%s: Filename size is [%zd], which is "
1083	"invalid\n", __func__, (*filename_size));	1083	"invalid\n", __func__, (*filename_size));
1084	rc = -EINVAL;	1084	rc = -EINVAL;
1085	goto out_free_unlock;	1085	goto out_free_unlock;
1086	}	1086	}
1087	(filename) = kmalloc(((filename_size) + 1), GFP_KERNEL);	1087	(filename) = kmalloc(((filename_size) + 1), GFP_KERNEL);
1088	if (!(*filename)) {	1088	if (!(*filename)) {
1089	printk(KERN_ERR "%s: Out of memory whilst attempting to "	1089	printk(KERN_ERR "%s: Out of memory whilst attempting to "
1090	"kmalloc [%zd] bytes\n", __func__,	1090	"kmalloc [%zd] bytes\n", __func__,
1091	((*filename_size) + 1));	1091	((*filename_size) + 1));
1092	rc = -ENOMEM;	1092	rc = -ENOMEM;
1093	goto out_free_unlock;	1093	goto out_free_unlock;
1094	}	1094	}
1095	memcpy((filename), &s->decrypted_filename[s->i], (filename_size));	1095	memcpy((filename), &s->decrypted_filename[s->i], (filename_size));
1096	(filename)[(filename_size)] = '\0';	1096	(filename)[(filename_size)] = '\0';
1097	out_free_unlock:	1097	out_free_unlock:
1098	kfree(s->decrypted_filename);	1098	kfree(s->decrypted_filename);
1099	out_unlock:	1099	out_unlock:
1100	mutex_unlock(s->tfm_mutex);	1100	mutex_unlock(s->tfm_mutex);
1101	out:	1101	out:
1102	if (rc) {	1102	if (rc) {
1103	(*packet_size) = 0;	1103	(*packet_size) = 0;
1104	(*filename_size) = 0;	1104	(*filename_size) = 0;
1105	(*filename) = NULL;	1105	(*filename) = NULL;
1106	}	1106	}
1107	if (auth_tok_key) {	1107	if (auth_tok_key) {
1108	up_write(&(auth_tok_key->sem));	1108	up_write(&(auth_tok_key->sem));
1109	key_put(auth_tok_key);	1109	key_put(auth_tok_key);
1110	}	1110	}
1111	kfree(s);	1111	kfree(s);
1112	return rc;	1112	return rc;
1113	}	1113	}
1114		1114
1115	static int	1115	static int
1116	ecryptfs_get_auth_tok_sig(char *sig, struct ecryptfs_auth_tok auth_tok)	1116	ecryptfs_get_auth_tok_sig(char *sig, struct ecryptfs_auth_tok auth_tok)
1117	{	1117	{
1118	int rc = 0;	1118	int rc = 0;
1119		1119
1120	(*sig) = NULL;	1120	(*sig) = NULL;
1121	switch (auth_tok->token_type) {	1121	switch (auth_tok->token_type) {
1122	case ECRYPTFS_PASSWORD:	1122	case ECRYPTFS_PASSWORD:
1123	(*sig) = auth_tok->token.password.signature;	1123	(*sig) = auth_tok->token.password.signature;
1124	break;	1124	break;
1125	case ECRYPTFS_PRIVATE_KEY:	1125	case ECRYPTFS_PRIVATE_KEY:
1126	(*sig) = auth_tok->token.private_key.signature;	1126	(*sig) = auth_tok->token.private_key.signature;
1127	break;	1127	break;
1128	default:	1128	default:
1129	printk(KERN_ERR "Cannot get sig for auth_tok of type [%d]\n",	1129	printk(KERN_ERR "Cannot get sig for auth_tok of type [%d]\n",
1130	auth_tok->token_type);	1130	auth_tok->token_type);
1131	rc = -EINVAL;	1131	rc = -EINVAL;
1132	}	1132	}
1133	return rc;	1133	return rc;
1134	}	1134	}
1135		1135
1136	/**	1136	/**
1137	* decrypt_pki_encrypted_session_key - Decrypt the session key with the given auth_tok.	1137	* decrypt_pki_encrypted_session_key - Decrypt the session key with the given auth_tok.
1138	* @auth_tok: The key authentication token used to decrypt the session key	1138	* @auth_tok: The key authentication token used to decrypt the session key
1139	* @crypt_stat: The cryptographic context	1139	* @crypt_stat: The cryptographic context
1140	*	1140	*
1141	* Returns zero on success; non-zero error otherwise.	1141	* Returns zero on success; non-zero error otherwise.
1142	*/	1142	*/
1143	static int	1143	static int
1144	decrypt_pki_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,	1144	decrypt_pki_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,
1145	struct ecryptfs_crypt_stat *crypt_stat)	1145	struct ecryptfs_crypt_stat *crypt_stat)
1146	{	1146	{
1147	u8 cipher_code = 0;	1147	u8 cipher_code = 0;
1148	struct ecryptfs_msg_ctx *msg_ctx;	1148	struct ecryptfs_msg_ctx *msg_ctx;
1149	struct ecryptfs_message *msg = NULL;	1149	struct ecryptfs_message *msg = NULL;
1150	char *auth_tok_sig;	1150	char *auth_tok_sig;
1151	char *payload = NULL;	1151	char *payload = NULL;
1152	size_t payload_len = 0;	1152	size_t payload_len = 0;
1153	int rc;	1153	int rc;
1154		1154
1155	rc = ecryptfs_get_auth_tok_sig(&auth_tok_sig, auth_tok);	1155	rc = ecryptfs_get_auth_tok_sig(&auth_tok_sig, auth_tok);
1156	if (rc) {	1156	if (rc) {
1157	printk(KERN_ERR "Unrecognized auth tok type: [%d]\n",	1157	printk(KERN_ERR "Unrecognized auth tok type: [%d]\n",
1158	auth_tok->token_type);	1158	auth_tok->token_type);
1159	goto out;	1159	goto out;
1160	}	1160	}
1161	rc = write_tag_64_packet(auth_tok_sig, &(auth_tok->session_key),	1161	rc = write_tag_64_packet(auth_tok_sig, &(auth_tok->session_key),
1162	&payload, &payload_len);	1162	&payload, &payload_len);
1163	if (rc) {	1163	if (rc) {
1164	ecryptfs_printk(KERN_ERR, "Failed to write tag 64 packet\n");	1164	ecryptfs_printk(KERN_ERR, "Failed to write tag 64 packet\n");
1165	goto out;	1165	goto out;
1166	}	1166	}
1167	rc = ecryptfs_send_message(payload, payload_len, &msg_ctx);	1167	rc = ecryptfs_send_message(payload, payload_len, &msg_ctx);
1168	if (rc) {	1168	if (rc) {
1169	ecryptfs_printk(KERN_ERR, "Error sending message to "	1169	ecryptfs_printk(KERN_ERR, "Error sending message to "
1170	"ecryptfsd: %d\n", rc);	1170	"ecryptfsd: %d\n", rc);
1171	goto out;	1171	goto out;
1172	}	1172	}
1173	rc = ecryptfs_wait_for_response(msg_ctx, &msg);	1173	rc = ecryptfs_wait_for_response(msg_ctx, &msg);
1174	if (rc) {	1174	if (rc) {
1175	ecryptfs_printk(KERN_ERR, "Failed to receive tag 65 packet "	1175	ecryptfs_printk(KERN_ERR, "Failed to receive tag 65 packet "
1176	"from the user space daemon\n");	1176	"from the user space daemon\n");
1177	rc = -EIO;	1177	rc = -EIO;
1178	goto out;	1178	goto out;
1179	}	1179	}
1180	rc = parse_tag_65_packet(&(auth_tok->session_key),	1180	rc = parse_tag_65_packet(&(auth_tok->session_key),
1181	&cipher_code, msg);	1181	&cipher_code, msg);
1182	if (rc) {	1182	if (rc) {
1183	printk(KERN_ERR "Failed to parse tag 65 packet; rc = [%d]\n",	1183	printk(KERN_ERR "Failed to parse tag 65 packet; rc = [%d]\n",
1184	rc);	1184	rc);
1185	goto out;	1185	goto out;
1186	}	1186	}
1187	auth_tok->session_key.flags \|= ECRYPTFS_CONTAINS_DECRYPTED_KEY;	1187	auth_tok->session_key.flags \|= ECRYPTFS_CONTAINS_DECRYPTED_KEY;
1188	memcpy(crypt_stat->key, auth_tok->session_key.decrypted_key,	1188	memcpy(crypt_stat->key, auth_tok->session_key.decrypted_key,
1189	auth_tok->session_key.decrypted_key_size);	1189	auth_tok->session_key.decrypted_key_size);
1190	crypt_stat->key_size = auth_tok->session_key.decrypted_key_size;	1190	crypt_stat->key_size = auth_tok->session_key.decrypted_key_size;
1191	rc = ecryptfs_cipher_code_to_string(crypt_stat->cipher, cipher_code);	1191	rc = ecryptfs_cipher_code_to_string(crypt_stat->cipher, cipher_code);
1192	if (rc) {	1192	if (rc) {
1193	ecryptfs_printk(KERN_ERR, "Cipher code [%d] is invalid\n",	1193	ecryptfs_printk(KERN_ERR, "Cipher code [%d] is invalid\n",
1194	cipher_code)	1194	cipher_code)
1195	goto out;	1195	goto out;
1196	}	1196	}
1197	crypt_stat->flags \|= ECRYPTFS_KEY_VALID;	1197	crypt_stat->flags \|= ECRYPTFS_KEY_VALID;
1198	if (ecryptfs_verbosity > 0) {	1198	if (ecryptfs_verbosity > 0) {
1199	ecryptfs_printk(KERN_DEBUG, "Decrypted session key:\n");	1199	ecryptfs_printk(KERN_DEBUG, "Decrypted session key:\n");
1200	ecryptfs_dump_hex(crypt_stat->key,	1200	ecryptfs_dump_hex(crypt_stat->key,
1201	crypt_stat->key_size);	1201	crypt_stat->key_size);
1202	}	1202	}
1203	out:	1203	out:
1204	kfree(msg);	1204	kfree(msg);
1205	kfree(payload);	1205	kfree(payload);
1206	return rc;	1206	return rc;
1207	}	1207	}
1208		1208
1209	static void wipe_auth_tok_list(struct list_head *auth_tok_list_head)	1209	static void wipe_auth_tok_list(struct list_head *auth_tok_list_head)
1210	{	1210	{
1211	struct ecryptfs_auth_tok_list_item *auth_tok_list_item;	1211	struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
1212	struct ecryptfs_auth_tok_list_item *auth_tok_list_item_tmp;	1212	struct ecryptfs_auth_tok_list_item *auth_tok_list_item_tmp;
1213		1213
1214	list_for_each_entry_safe(auth_tok_list_item, auth_tok_list_item_tmp,	1214	list_for_each_entry_safe(auth_tok_list_item, auth_tok_list_item_tmp,
1215	auth_tok_list_head, list) {	1215	auth_tok_list_head, list) {
1216	list_del(&auth_tok_list_item->list);	1216	list_del(&auth_tok_list_item->list);
1217	kmem_cache_free(ecryptfs_auth_tok_list_item_cache,	1217	kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
1218	auth_tok_list_item);	1218	auth_tok_list_item);
1219	}	1219	}
1220	}	1220	}
1221		1221
1222	struct kmem_cache *ecryptfs_auth_tok_list_item_cache;	1222	struct kmem_cache *ecryptfs_auth_tok_list_item_cache;
1223		1223
1224	/**	1224	/**
1225	* parse_tag_1_packet	1225	* parse_tag_1_packet
1226	* @crypt_stat: The cryptographic context to modify based on packet contents	1226	* @crypt_stat: The cryptographic context to modify based on packet contents
1227	* @data: The raw bytes of the packet.	1227	* @data: The raw bytes of the packet.
1228	* @auth_tok_list: eCryptfs parses packets into authentication tokens;	1228	* @auth_tok_list: eCryptfs parses packets into authentication tokens;
1229	* a new authentication token will be placed at the	1229	* a new authentication token will be placed at the
1230	* end of this list for this packet.	1230	* end of this list for this packet.
1231	* @new_auth_tok: Pointer to a pointer to memory that this function	1231	* @new_auth_tok: Pointer to a pointer to memory that this function
1232	* allocates; sets the memory address of the pointer to	1232	* allocates; sets the memory address of the pointer to
1233	* NULL on error. This object is added to the	1233	* NULL on error. This object is added to the
1234	* auth_tok_list.	1234	* auth_tok_list.
1235	* @packet_size: This function writes the size of the parsed packet	1235	* @packet_size: This function writes the size of the parsed packet
1236	* into this memory location; zero on error.	1236	* into this memory location; zero on error.
1237	* @max_packet_size: The maximum allowable packet size	1237	* @max_packet_size: The maximum allowable packet size
1238	*	1238	*
1239	* Returns zero on success; non-zero on error.	1239	* Returns zero on success; non-zero on error.
1240	*/	1240	*/
1241	static int	1241	static int
1242	parse_tag_1_packet(struct ecryptfs_crypt_stat *crypt_stat,	1242	parse_tag_1_packet(struct ecryptfs_crypt_stat *crypt_stat,
1243	unsigned char data, struct list_head auth_tok_list,	1243	unsigned char data, struct list_head auth_tok_list,
1244	struct ecryptfs_auth_tok **new_auth_tok,	1244	struct ecryptfs_auth_tok **new_auth_tok,
1245	size_t *packet_size, size_t max_packet_size)	1245	size_t *packet_size, size_t max_packet_size)
1246	{	1246	{
1247	size_t body_size;	1247	size_t body_size;
1248	struct ecryptfs_auth_tok_list_item *auth_tok_list_item;	1248	struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
1249	size_t length_size;	1249	size_t length_size;
1250	int rc = 0;	1250	int rc = 0;
1251		1251
1252	(*packet_size) = 0;	1252	(*packet_size) = 0;
1253	(*new_auth_tok) = NULL;	1253	(*new_auth_tok) = NULL;
1254	/**	1254	/**
1255	* This format is inspired by OpenPGP; see RFC 2440	1255	* This format is inspired by OpenPGP; see RFC 2440
1256	* packet tag 1	1256	* packet tag 1
1257	*	1257	*
1258	* Tag 1 identifier (1 byte)	1258	* Tag 1 identifier (1 byte)
1259	* Max Tag 1 packet size (max 3 bytes)	1259	* Max Tag 1 packet size (max 3 bytes)
1260	* Version (1 byte)	1260	* Version (1 byte)
1261	* Key identifier (8 bytes; ECRYPTFS_SIG_SIZE)	1261	* Key identifier (8 bytes; ECRYPTFS_SIG_SIZE)
1262	* Cipher identifier (1 byte)	1262	* Cipher identifier (1 byte)
1263	* Encrypted key size (arbitrary)	1263	* Encrypted key size (arbitrary)
1264	*	1264	*
1265	* 12 bytes minimum packet size	1265	* 12 bytes minimum packet size
1266	*/	1266	*/
1267	if (unlikely(max_packet_size < 12)) {	1267	if (unlikely(max_packet_size < 12)) {
1268	printk(KERN_ERR "Invalid max packet size; must be >=12\n");	1268	printk(KERN_ERR "Invalid max packet size; must be >=12\n");
1269	rc = -EINVAL;	1269	rc = -EINVAL;
1270	goto out;	1270	goto out;
1271	}	1271	}
1272	if (data[(*packet_size)++] != ECRYPTFS_TAG_1_PACKET_TYPE) {	1272	if (data[(*packet_size)++] != ECRYPTFS_TAG_1_PACKET_TYPE) {
1273	printk(KERN_ERR "Enter w/ first byte != 0x%.2x\n",	1273	printk(KERN_ERR "Enter w/ first byte != 0x%.2x\n",
1274	ECRYPTFS_TAG_1_PACKET_TYPE);	1274	ECRYPTFS_TAG_1_PACKET_TYPE);
1275	rc = -EINVAL;	1275	rc = -EINVAL;
1276	goto out;	1276	goto out;
1277	}	1277	}
1278	/* Released: wipe_auth_tok_list called in ecryptfs_parse_packet_set or	1278	/* Released: wipe_auth_tok_list called in ecryptfs_parse_packet_set or
1279	* at end of function upon failure */	1279	* at end of function upon failure */
1280	auth_tok_list_item =	1280	auth_tok_list_item =
1281	kmem_cache_zalloc(ecryptfs_auth_tok_list_item_cache,	1281	kmem_cache_zalloc(ecryptfs_auth_tok_list_item_cache,
1282	GFP_KERNEL);	1282	GFP_KERNEL);
1283	if (!auth_tok_list_item) {	1283	if (!auth_tok_list_item) {
1284	printk(KERN_ERR "Unable to allocate memory\n");	1284	printk(KERN_ERR "Unable to allocate memory\n");
1285	rc = -ENOMEM;	1285	rc = -ENOMEM;
1286	goto out;	1286	goto out;
1287	}	1287	}
1288	(*new_auth_tok) = &auth_tok_list_item->auth_tok;	1288	(*new_auth_tok) = &auth_tok_list_item->auth_tok;
1289	rc = ecryptfs_parse_packet_length(&data[(*packet_size)], &body_size,	1289	rc = ecryptfs_parse_packet_length(&data[(*packet_size)], &body_size,
1290	&length_size);	1290	&length_size);
1291	if (rc) {	1291	if (rc) {
1292	printk(KERN_WARNING "Error parsing packet length; "	1292	printk(KERN_WARNING "Error parsing packet length; "
1293	"rc = [%d]\n", rc);	1293	"rc = [%d]\n", rc);
1294	goto out_free;	1294	goto out_free;
1295	}	1295	}
1296	if (unlikely(body_size < (ECRYPTFS_SIG_SIZE + 2))) {	1296	if (unlikely(body_size < (ECRYPTFS_SIG_SIZE + 2))) {
1297	printk(KERN_WARNING "Invalid body size ([%td])\n", body_size);	1297	printk(KERN_WARNING "Invalid body size ([%td])\n", body_size);
1298	rc = -EINVAL;	1298	rc = -EINVAL;
1299	goto out_free;	1299	goto out_free;
1300	}	1300	}
1301	(*packet_size) += length_size;	1301	(*packet_size) += length_size;
1302	if (unlikely((*packet_size) + body_size > max_packet_size)) {	1302	if (unlikely((*packet_size) + body_size > max_packet_size)) {
1303	printk(KERN_WARNING "Packet size exceeds max\n");	1303	printk(KERN_WARNING "Packet size exceeds max\n");
1304	rc = -EINVAL;	1304	rc = -EINVAL;
1305	goto out_free;	1305	goto out_free;
1306	}	1306	}
1307	if (unlikely(data[(*packet_size)++] != 0x03)) {	1307	if (unlikely(data[(*packet_size)++] != 0x03)) {
1308	printk(KERN_WARNING "Unknown version number [%d]\n",	1308	printk(KERN_WARNING "Unknown version number [%d]\n",
1309	data[(*packet_size) - 1]);	1309	data[(*packet_size) - 1]);
1310	rc = -EINVAL;	1310	rc = -EINVAL;
1311	goto out_free;	1311	goto out_free;
1312	}	1312	}
1313	ecryptfs_to_hex((*new_auth_tok)->token.private_key.signature,	1313	ecryptfs_to_hex((*new_auth_tok)->token.private_key.signature,
1314	&data[(*packet_size)], ECRYPTFS_SIG_SIZE);	1314	&data[(*packet_size)], ECRYPTFS_SIG_SIZE);
1315	*packet_size += ECRYPTFS_SIG_SIZE;	1315	*packet_size += ECRYPTFS_SIG_SIZE;
1316	/* This byte is skipped because the kernel does not need to	1316	/* This byte is skipped because the kernel does not need to
1317	* know which public key encryption algorithm was used */	1317	* know which public key encryption algorithm was used */
1318	(*packet_size)++;	1318	(*packet_size)++;
1319	(*new_auth_tok)->session_key.encrypted_key_size =	1319	(*new_auth_tok)->session_key.encrypted_key_size =
1320	body_size - (ECRYPTFS_SIG_SIZE + 2);	1320	body_size - (ECRYPTFS_SIG_SIZE + 2);
1321	if ((*new_auth_tok)->session_key.encrypted_key_size	1321	if ((*new_auth_tok)->session_key.encrypted_key_size
1322	> ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES) {	1322	> ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES) {
1323	printk(KERN_WARNING "Tag 1 packet contains key larger "	1323	printk(KERN_WARNING "Tag 1 packet contains key larger "
1324	"than ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES");	1324	"than ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES");
1325	rc = -EINVAL;	1325	rc = -EINVAL;
1326	goto out;	1326	goto out;
1327	}	1327	}
1328	memcpy((*new_auth_tok)->session_key.encrypted_key,	1328	memcpy((*new_auth_tok)->session_key.encrypted_key,
1329	&data[(*packet_size)], (body_size - (ECRYPTFS_SIG_SIZE + 2)));	1329	&data[(*packet_size)], (body_size - (ECRYPTFS_SIG_SIZE + 2)));
1330	(packet_size) += (new_auth_tok)->session_key.encrypted_key_size;	1330	(packet_size) += (new_auth_tok)->session_key.encrypted_key_size;
1331	(*new_auth_tok)->session_key.flags &=	1331	(*new_auth_tok)->session_key.flags &=
1332	~ECRYPTFS_CONTAINS_DECRYPTED_KEY;	1332	~ECRYPTFS_CONTAINS_DECRYPTED_KEY;
1333	(*new_auth_tok)->session_key.flags \|=	1333	(*new_auth_tok)->session_key.flags \|=
1334	ECRYPTFS_CONTAINS_ENCRYPTED_KEY;	1334	ECRYPTFS_CONTAINS_ENCRYPTED_KEY;
1335	(*new_auth_tok)->token_type = ECRYPTFS_PRIVATE_KEY;	1335	(*new_auth_tok)->token_type = ECRYPTFS_PRIVATE_KEY;
1336	(*new_auth_tok)->flags = 0;	1336	(*new_auth_tok)->flags = 0;
1337	(*new_auth_tok)->session_key.flags &=	1337	(*new_auth_tok)->session_key.flags &=
1338	~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT);	1338	~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT);
1339	(*new_auth_tok)->session_key.flags &=	1339	(*new_auth_tok)->session_key.flags &=
1340	~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT);	1340	~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT);
1341	list_add(&auth_tok_list_item->list, auth_tok_list);	1341	list_add(&auth_tok_list_item->list, auth_tok_list);
1342	goto out;	1342	goto out;
1343	out_free:	1343	out_free:
1344	(*new_auth_tok) = NULL;	1344	(*new_auth_tok) = NULL;
1345	memset(auth_tok_list_item, 0,	1345	memset(auth_tok_list_item, 0,
1346	sizeof(struct ecryptfs_auth_tok_list_item));	1346	sizeof(struct ecryptfs_auth_tok_list_item));
1347	kmem_cache_free(ecryptfs_auth_tok_list_item_cache,	1347	kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
1348	auth_tok_list_item);	1348	auth_tok_list_item);
1349	out:	1349	out:
1350	if (rc)	1350	if (rc)
1351	(*packet_size) = 0;	1351	(*packet_size) = 0;
1352	return rc;	1352	return rc;
1353	}	1353	}
1354		1354
1355	/**	1355	/**
1356	* parse_tag_3_packet	1356	* parse_tag_3_packet
1357	* @crypt_stat: The cryptographic context to modify based on packet	1357	* @crypt_stat: The cryptographic context to modify based on packet
1358	* contents.	1358	* contents.
1359	* @data: The raw bytes of the packet.	1359	* @data: The raw bytes of the packet.
1360	* @auth_tok_list: eCryptfs parses packets into authentication tokens;	1360	* @auth_tok_list: eCryptfs parses packets into authentication tokens;
1361	* a new authentication token will be placed at the end	1361	* a new authentication token will be placed at the end
1362	* of this list for this packet.	1362	* of this list for this packet.
1363	* @new_auth_tok: Pointer to a pointer to memory that this function	1363	* @new_auth_tok: Pointer to a pointer to memory that this function
1364	* allocates; sets the memory address of the pointer to	1364	* allocates; sets the memory address of the pointer to
1365	* NULL on error. This object is added to the	1365	* NULL on error. This object is added to the
1366	* auth_tok_list.	1366	* auth_tok_list.
1367	* @packet_size: This function writes the size of the parsed packet	1367	* @packet_size: This function writes the size of the parsed packet
1368	* into this memory location; zero on error.	1368	* into this memory location; zero on error.
1369	* @max_packet_size: maximum number of bytes to parse	1369	* @max_packet_size: maximum number of bytes to parse
1370	*	1370	*
1371	* Returns zero on success; non-zero on error.	1371	* Returns zero on success; non-zero on error.
1372	*/	1372	*/
1373	static int	1373	static int
1374	parse_tag_3_packet(struct ecryptfs_crypt_stat *crypt_stat,	1374	parse_tag_3_packet(struct ecryptfs_crypt_stat *crypt_stat,
1375	unsigned char data, struct list_head auth_tok_list,	1375	unsigned char data, struct list_head auth_tok_list,
1376	struct ecryptfs_auth_tok **new_auth_tok,	1376	struct ecryptfs_auth_tok **new_auth_tok,
1377	size_t *packet_size, size_t max_packet_size)	1377	size_t *packet_size, size_t max_packet_size)
1378	{	1378	{
1379	size_t body_size;	1379	size_t body_size;
1380	struct ecryptfs_auth_tok_list_item *auth_tok_list_item;	1380	struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
1381	size_t length_size;	1381	size_t length_size;
1382	int rc = 0;	1382	int rc = 0;
1383		1383
1384	(*packet_size) = 0;	1384	(*packet_size) = 0;
1385	(*new_auth_tok) = NULL;	1385	(*new_auth_tok) = NULL;
1386	/**	1386	/**
1387	*This format is inspired by OpenPGP; see RFC 2440	1387	*This format is inspired by OpenPGP; see RFC 2440
1388	* packet tag 3	1388	* packet tag 3
1389	*	1389	*
1390	* Tag 3 identifier (1 byte)	1390	* Tag 3 identifier (1 byte)
1391	* Max Tag 3 packet size (max 3 bytes)	1391	* Max Tag 3 packet size (max 3 bytes)
1392	* Version (1 byte)	1392	* Version (1 byte)
1393	* Cipher code (1 byte)	1393	* Cipher code (1 byte)
1394	* S2K specifier (1 byte)	1394	* S2K specifier (1 byte)
1395	* Hash identifier (1 byte)	1395	* Hash identifier (1 byte)
1396	* Salt (ECRYPTFS_SALT_SIZE)	1396	* Salt (ECRYPTFS_SALT_SIZE)
1397	* Hash iterations (1 byte)	1397	* Hash iterations (1 byte)
1398	* Encrypted key (arbitrary)	1398	* Encrypted key (arbitrary)
1399	*	1399	*
1400	* (ECRYPTFS_SALT_SIZE + 7) minimum packet size	1400	* (ECRYPTFS_SALT_SIZE + 7) minimum packet size
1401	*/	1401	*/
1402	if (max_packet_size < (ECRYPTFS_SALT_SIZE + 7)) {	1402	if (max_packet_size < (ECRYPTFS_SALT_SIZE + 7)) {
1403	printk(KERN_ERR "Max packet size too large\n");	1403	printk(KERN_ERR "Max packet size too large\n");
1404	rc = -EINVAL;	1404	rc = -EINVAL;
1405	goto out;	1405	goto out;
1406	}	1406	}
1407	if (data[(*packet_size)++] != ECRYPTFS_TAG_3_PACKET_TYPE) {	1407	if (data[(*packet_size)++] != ECRYPTFS_TAG_3_PACKET_TYPE) {
1408	printk(KERN_ERR "First byte != 0x%.2x; invalid packet\n",	1408	printk(KERN_ERR "First byte != 0x%.2x; invalid packet\n",
1409	ECRYPTFS_TAG_3_PACKET_TYPE);	1409	ECRYPTFS_TAG_3_PACKET_TYPE);
1410	rc = -EINVAL;	1410	rc = -EINVAL;
1411	goto out;	1411	goto out;
1412	}	1412	}
1413	/* Released: wipe_auth_tok_list called in ecryptfs_parse_packet_set or	1413	/* Released: wipe_auth_tok_list called in ecryptfs_parse_packet_set or
1414	* at end of function upon failure */	1414	* at end of function upon failure */
1415	auth_tok_list_item =	1415	auth_tok_list_item =
1416	kmem_cache_zalloc(ecryptfs_auth_tok_list_item_cache, GFP_KERNEL);	1416	kmem_cache_zalloc(ecryptfs_auth_tok_list_item_cache, GFP_KERNEL);
1417	if (!auth_tok_list_item) {	1417	if (!auth_tok_list_item) {
1418	printk(KERN_ERR "Unable to allocate memory\n");	1418	printk(KERN_ERR "Unable to allocate memory\n");
1419	rc = -ENOMEM;	1419	rc = -ENOMEM;
1420	goto out;	1420	goto out;
1421	}	1421	}
1422	(*new_auth_tok) = &auth_tok_list_item->auth_tok;	1422	(*new_auth_tok) = &auth_tok_list_item->auth_tok;
1423	rc = ecryptfs_parse_packet_length(&data[(*packet_size)], &body_size,	1423	rc = ecryptfs_parse_packet_length(&data[(*packet_size)], &body_size,
1424	&length_size);	1424	&length_size);
1425	if (rc) {	1425	if (rc) {
1426	printk(KERN_WARNING "Error parsing packet length; rc = [%d]\n",	1426	printk(KERN_WARNING "Error parsing packet length; rc = [%d]\n",
1427	rc);	1427	rc);
1428	goto out_free;	1428	goto out_free;
1429	}	1429	}
1430	if (unlikely(body_size < (ECRYPTFS_SALT_SIZE + 5))) {	1430	if (unlikely(body_size < (ECRYPTFS_SALT_SIZE + 5))) {
1431	printk(KERN_WARNING "Invalid body size ([%td])\n", body_size);	1431	printk(KERN_WARNING "Invalid body size ([%td])\n", body_size);
1432	rc = -EINVAL;	1432	rc = -EINVAL;
1433	goto out_free;	1433	goto out_free;
1434	}	1434	}
1435	(*packet_size) += length_size;	1435	(*packet_size) += length_size;
1436	if (unlikely((*packet_size) + body_size > max_packet_size)) {	1436	if (unlikely((*packet_size) + body_size > max_packet_size)) {
1437	printk(KERN_ERR "Packet size exceeds max\n");	1437	printk(KERN_ERR "Packet size exceeds max\n");
1438	rc = -EINVAL;	1438	rc = -EINVAL;
1439	goto out_free;	1439	goto out_free;
1440	}	1440	}
1441	(*new_auth_tok)->session_key.encrypted_key_size =	1441	(*new_auth_tok)->session_key.encrypted_key_size =
1442	(body_size - (ECRYPTFS_SALT_SIZE + 5));	1442	(body_size - (ECRYPTFS_SALT_SIZE + 5));
1443	if ((*new_auth_tok)->session_key.encrypted_key_size	1443	if ((*new_auth_tok)->session_key.encrypted_key_size
1444	> ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES) {	1444	> ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES) {
1445	printk(KERN_WARNING "Tag 3 packet contains key larger "	1445	printk(KERN_WARNING "Tag 3 packet contains key larger "
1446	"than ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES\n");	1446	"than ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES\n");
1447	rc = -EINVAL;	1447	rc = -EINVAL;
1448	goto out_free;	1448	goto out_free;
1449	}	1449	}
1450	if (unlikely(data[(*packet_size)++] != 0x04)) {	1450	if (unlikely(data[(*packet_size)++] != 0x04)) {
1451	printk(KERN_WARNING "Unknown version number [%d]\n",	1451	printk(KERN_WARNING "Unknown version number [%d]\n",
1452	data[(*packet_size) - 1]);	1452	data[(*packet_size) - 1]);
1453	rc = -EINVAL;	1453	rc = -EINVAL;
1454	goto out_free;	1454	goto out_free;
1455	}	1455	}
1456	rc = ecryptfs_cipher_code_to_string(crypt_stat->cipher,	1456	rc = ecryptfs_cipher_code_to_string(crypt_stat->cipher,
1457	(u16)data[(*packet_size)]);	1457	(u16)data[(*packet_size)]);
1458	if (rc)	1458	if (rc)
1459	goto out_free;	1459	goto out_free;
1460	/* A little extra work to differentiate among the AES key	1460	/* A little extra work to differentiate among the AES key
1461	* sizes; see RFC2440 */	1461	* sizes; see RFC2440 */
1462	switch(data[(*packet_size)++]) {	1462	switch(data[(*packet_size)++]) {
1463	case RFC2440_CIPHER_AES_192:	1463	case RFC2440_CIPHER_AES_192:
1464	crypt_stat->key_size = 24;	1464	crypt_stat->key_size = 24;
1465	break;	1465	break;
1466	default:	1466	default:
1467	crypt_stat->key_size =	1467	crypt_stat->key_size =
1468	(*new_auth_tok)->session_key.encrypted_key_size;	1468	(*new_auth_tok)->session_key.encrypted_key_size;
1469	}	1469	}
1470	rc = ecryptfs_init_crypt_ctx(crypt_stat);	1470	rc = ecryptfs_init_crypt_ctx(crypt_stat);
1471	if (rc)	1471	if (rc)
1472	goto out_free;	1472	goto out_free;
1473	if (unlikely(data[(*packet_size)++] != 0x03)) {	1473	if (unlikely(data[(*packet_size)++] != 0x03)) {
1474	printk(KERN_WARNING "Only S2K ID 3 is currently supported\n");	1474	printk(KERN_WARNING "Only S2K ID 3 is currently supported\n");
1475	rc = -ENOSYS;	1475	rc = -ENOSYS;
1476	goto out_free;	1476	goto out_free;
1477	}	1477	}
1478	/* TODO: finish the hash mapping */	1478	/* TODO: finish the hash mapping */
1479	switch (data[(*packet_size)++]) {	1479	switch (data[(*packet_size)++]) {
1480	case 0x01: /* See RFC2440 for these numbers and their mappings */	1480	case 0x01: /* See RFC2440 for these numbers and their mappings */
1481	/* Choose MD5 */	1481	/* Choose MD5 */
1482	memcpy((*new_auth_tok)->token.password.salt,	1482	memcpy((*new_auth_tok)->token.password.salt,
1483	&data[(*packet_size)], ECRYPTFS_SALT_SIZE);	1483	&data[(*packet_size)], ECRYPTFS_SALT_SIZE);
1484	(*packet_size) += ECRYPTFS_SALT_SIZE;	1484	(*packet_size) += ECRYPTFS_SALT_SIZE;
1485	/* This conversion was taken straight from RFC2440 */	1485	/* This conversion was taken straight from RFC2440 */
1486	(*new_auth_tok)->token.password.hash_iterations =	1486	(*new_auth_tok)->token.password.hash_iterations =
1487	((u32) 16 + (data[(*packet_size)] & 15))	1487	((u32) 16 + (data[(*packet_size)] & 15))
1488	<< ((data[(*packet_size)] >> 4) + 6);	1488	<< ((data[(*packet_size)] >> 4) + 6);
1489	(*packet_size)++;	1489	(*packet_size)++;
1490	/* Friendly reminder:	1490	/* Friendly reminder:
1491	* (*new_auth_tok)->session_key.encrypted_key_size =	1491	* (*new_auth_tok)->session_key.encrypted_key_size =
1492	* (body_size - (ECRYPTFS_SALT_SIZE + 5)); */	1492	* (body_size - (ECRYPTFS_SALT_SIZE + 5)); */
1493	memcpy((*new_auth_tok)->session_key.encrypted_key,	1493	memcpy((*new_auth_tok)->session_key.encrypted_key,
1494	&data[(*packet_size)],	1494	&data[(*packet_size)],
1495	(*new_auth_tok)->session_key.encrypted_key_size);	1495	(*new_auth_tok)->session_key.encrypted_key_size);
1496	(*packet_size) +=	1496	(*packet_size) +=
1497	(*new_auth_tok)->session_key.encrypted_key_size;	1497	(*new_auth_tok)->session_key.encrypted_key_size;
1498	(*new_auth_tok)->session_key.flags &=	1498	(*new_auth_tok)->session_key.flags &=
1499	~ECRYPTFS_CONTAINS_DECRYPTED_KEY;	1499	~ECRYPTFS_CONTAINS_DECRYPTED_KEY;
1500	(*new_auth_tok)->session_key.flags \|=	1500	(*new_auth_tok)->session_key.flags \|=
1501	ECRYPTFS_CONTAINS_ENCRYPTED_KEY;	1501	ECRYPTFS_CONTAINS_ENCRYPTED_KEY;
1502	(new_auth_tok)->token.password.hash_algo = 0x01; / MD5 */	1502	(new_auth_tok)->token.password.hash_algo = 0x01; / MD5 */
1503	break;	1503	break;
1504	default:	1504	default:
1505	ecryptfs_printk(KERN_ERR, "Unsupported hash algorithm: "	1505	ecryptfs_printk(KERN_ERR, "Unsupported hash algorithm: "
1506	"[%d]\n", data[(*packet_size) - 1]);	1506	"[%d]\n", data[(*packet_size) - 1]);
1507	rc = -ENOSYS;	1507	rc = -ENOSYS;
1508	goto out_free;	1508	goto out_free;
1509	}	1509	}
1510	(*new_auth_tok)->token_type = ECRYPTFS_PASSWORD;	1510	(*new_auth_tok)->token_type = ECRYPTFS_PASSWORD;
1511	/* TODO: Parametarize; we might actually want userspace to	1511	/* TODO: Parametarize; we might actually want userspace to
1512	* decrypt the session key. */	1512	* decrypt the session key. */
1513	(*new_auth_tok)->session_key.flags &=	1513	(*new_auth_tok)->session_key.flags &=
1514	~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT);	1514	~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT);
1515	(*new_auth_tok)->session_key.flags &=	1515	(*new_auth_tok)->session_key.flags &=
1516	~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT);	1516	~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT);
1517	list_add(&auth_tok_list_item->list, auth_tok_list);	1517	list_add(&auth_tok_list_item->list, auth_tok_list);
1518	goto out;	1518	goto out;
1519	out_free:	1519	out_free:
1520	(*new_auth_tok) = NULL;	1520	(*new_auth_tok) = NULL;
1521	memset(auth_tok_list_item, 0,	1521	memset(auth_tok_list_item, 0,
1522	sizeof(struct ecryptfs_auth_tok_list_item));	1522	sizeof(struct ecryptfs_auth_tok_list_item));
1523	kmem_cache_free(ecryptfs_auth_tok_list_item_cache,	1523	kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
1524	auth_tok_list_item);	1524	auth_tok_list_item);
1525	out:	1525	out:
1526	if (rc)	1526	if (rc)
1527	(*packet_size) = 0;	1527	(*packet_size) = 0;
1528	return rc;	1528	return rc;
1529	}	1529	}
1530		1530
1531	/**	1531	/**
1532	* parse_tag_11_packet	1532	* parse_tag_11_packet
1533	* @data: The raw bytes of the packet	1533	* @data: The raw bytes of the packet
1534	* @contents: This function writes the data contents of the literal	1534	* @contents: This function writes the data contents of the literal
1535	* packet into this memory location	1535	* packet into this memory location
1536	* @max_contents_bytes: The maximum number of bytes that this function	1536	* @max_contents_bytes: The maximum number of bytes that this function
1537	* is allowed to write into contents	1537	* is allowed to write into contents
1538	* @tag_11_contents_size: This function writes the size of the parsed	1538	* @tag_11_contents_size: This function writes the size of the parsed
1539	* contents into this memory location; zero on	1539	* contents into this memory location; zero on
1540	* error	1540	* error
1541	* @packet_size: This function writes the size of the parsed packet	1541	* @packet_size: This function writes the size of the parsed packet
1542	* into this memory location; zero on error	1542	* into this memory location; zero on error
1543	* @max_packet_size: maximum number of bytes to parse	1543	* @max_packet_size: maximum number of bytes to parse
1544	*	1544	*
1545	* Returns zero on success; non-zero on error.	1545	* Returns zero on success; non-zero on error.
1546	*/	1546	*/
1547	static int	1547	static int
1548	parse_tag_11_packet(unsigned char data, unsigned char contents,	1548	parse_tag_11_packet(unsigned char data, unsigned char contents,
1549	size_t max_contents_bytes, size_t *tag_11_contents_size,	1549	size_t max_contents_bytes, size_t *tag_11_contents_size,
1550	size_t *packet_size, size_t max_packet_size)	1550	size_t *packet_size, size_t max_packet_size)
1551	{	1551	{
1552	size_t body_size;	1552	size_t body_size;
1553	size_t length_size;	1553	size_t length_size;
1554	int rc = 0;	1554	int rc = 0;
1555		1555
1556	(*packet_size) = 0;	1556	(*packet_size) = 0;
1557	(*tag_11_contents_size) = 0;	1557	(*tag_11_contents_size) = 0;
1558	/* This format is inspired by OpenPGP; see RFC 2440	1558	/* This format is inspired by OpenPGP; see RFC 2440
1559	* packet tag 11	1559	* packet tag 11
1560	*	1560	*
1561	* Tag 11 identifier (1 byte)	1561	* Tag 11 identifier (1 byte)
1562	* Max Tag 11 packet size (max 3 bytes)	1562	* Max Tag 11 packet size (max 3 bytes)
1563	* Binary format specifier (1 byte)	1563	* Binary format specifier (1 byte)
1564	* Filename length (1 byte)	1564	* Filename length (1 byte)
1565	* Filename ("_CONSOLE") (8 bytes)	1565	* Filename ("_CONSOLE") (8 bytes)
1566	* Modification date (4 bytes)	1566	* Modification date (4 bytes)
1567	* Literal data (arbitrary)	1567	* Literal data (arbitrary)
1568	*	1568	*
1569	* We need at least 16 bytes of data for the packet to even be	1569	* We need at least 16 bytes of data for the packet to even be
1570	* valid.	1570	* valid.
1571	*/	1571	*/
1572	if (max_packet_size < 16) {	1572	if (max_packet_size < 16) {
1573	printk(KERN_ERR "Maximum packet size too small\n");	1573	printk(KERN_ERR "Maximum packet size too small\n");
1574	rc = -EINVAL;	1574	rc = -EINVAL;
1575	goto out;	1575	goto out;
1576	}	1576	}
1577	if (data[(*packet_size)++] != ECRYPTFS_TAG_11_PACKET_TYPE) {	1577	if (data[(*packet_size)++] != ECRYPTFS_TAG_11_PACKET_TYPE) {
1578	printk(KERN_WARNING "Invalid tag 11 packet format\n");	1578	printk(KERN_WARNING "Invalid tag 11 packet format\n");
1579	rc = -EINVAL;	1579	rc = -EINVAL;
1580	goto out;	1580	goto out;
1581	}	1581	}
1582	rc = ecryptfs_parse_packet_length(&data[(*packet_size)], &body_size,	1582	rc = ecryptfs_parse_packet_length(&data[(*packet_size)], &body_size,
1583	&length_size);	1583	&length_size);
1584	if (rc) {	1584	if (rc) {
1585	printk(KERN_WARNING "Invalid tag 11 packet format\n");	1585	printk(KERN_WARNING "Invalid tag 11 packet format\n");
1586	goto out;	1586	goto out;
1587	}	1587	}
1588	if (body_size < 14) {	1588	if (body_size < 14) {
1589	printk(KERN_WARNING "Invalid body size ([%td])\n", body_size);	1589	printk(KERN_WARNING "Invalid body size ([%td])\n", body_size);
1590	rc = -EINVAL;	1590	rc = -EINVAL;
1591	goto out;	1591	goto out;
1592	}	1592	}
1593	(*packet_size) += length_size;	1593	(*packet_size) += length_size;
1594	(*tag_11_contents_size) = (body_size - 14);	1594	(*tag_11_contents_size) = (body_size - 14);
1595	if (unlikely((*packet_size) + body_size + 1 > max_packet_size)) {	1595	if (unlikely((*packet_size) + body_size + 1 > max_packet_size)) {
1596	printk(KERN_ERR "Packet size exceeds max\n");	1596	printk(KERN_ERR "Packet size exceeds max\n");
1597	rc = -EINVAL;	1597	rc = -EINVAL;
1598	goto out;	1598	goto out;
1599	}	1599	}
1600	if (unlikely((*tag_11_contents_size) > max_contents_bytes)) {	1600	if (unlikely((*tag_11_contents_size) > max_contents_bytes)) {
1601	printk(KERN_ERR "Literal data section in tag 11 packet exceeds "	1601	printk(KERN_ERR "Literal data section in tag 11 packet exceeds "
1602	"expected size\n");	1602	"expected size\n");
1603	rc = -EINVAL;	1603	rc = -EINVAL;
1604	goto out;	1604	goto out;
1605	}	1605	}
1606	if (data[(*packet_size)++] != 0x62) {	1606	if (data[(*packet_size)++] != 0x62) {
1607	printk(KERN_WARNING "Unrecognizable packet\n");	1607	printk(KERN_WARNING "Unrecognizable packet\n");
1608	rc = -EINVAL;	1608	rc = -EINVAL;
1609	goto out;	1609	goto out;
1610	}	1610	}
1611	if (data[(*packet_size)++] != 0x08) {	1611	if (data[(*packet_size)++] != 0x08) {
1612	printk(KERN_WARNING "Unrecognizable packet\n");	1612	printk(KERN_WARNING "Unrecognizable packet\n");
1613	rc = -EINVAL;	1613	rc = -EINVAL;
1614	goto out;	1614	goto out;
1615	}	1615	}
1616	(packet_size) += 12; / Ignore filename and modification date */	1616	(packet_size) += 12; / Ignore filename and modification date */
1617	memcpy(contents, &data[(packet_size)], (tag_11_contents_size));	1617	memcpy(contents, &data[(packet_size)], (tag_11_contents_size));
1618	(packet_size) += (tag_11_contents_size);	1618	(packet_size) += (tag_11_contents_size);
1619	out:	1619	out:
1620	if (rc) {	1620	if (rc) {
1621	(*packet_size) = 0;	1621	(*packet_size) = 0;
1622	(*tag_11_contents_size) = 0;	1622	(*tag_11_contents_size) = 0;
1623	}	1623	}
1624	return rc;	1624	return rc;
1625	}	1625	}
1626		1626
1627	int ecryptfs_keyring_auth_tok_for_sig(struct key **auth_tok_key,	1627	int ecryptfs_keyring_auth_tok_for_sig(struct key **auth_tok_key,
1628	struct ecryptfs_auth_tok **auth_tok,	1628	struct ecryptfs_auth_tok **auth_tok,
1629	char *sig)	1629	char *sig)
1630	{	1630	{
1631	int rc = 0;	1631	int rc = 0;
1632		1632
1633	(*auth_tok_key) = request_key(&key_type_user, sig, NULL);	1633	(*auth_tok_key) = request_key(&key_type_user, sig, NULL);
1634	if (!(auth_tok_key) \|\| IS_ERR(auth_tok_key)) {	1634	if (!(auth_tok_key) \|\| IS_ERR(auth_tok_key)) {
1635	(*auth_tok_key) = ecryptfs_get_encrypted_key(sig);	1635	(*auth_tok_key) = ecryptfs_get_encrypted_key(sig);
1636	if (!(auth_tok_key) \|\| IS_ERR(auth_tok_key)) {	1636	if (!(auth_tok_key) \|\| IS_ERR(auth_tok_key)) {
1637	printk(KERN_ERR "Could not find key with description: [%s]\n",	1637	printk(KERN_ERR "Could not find key with description: [%s]\n",
1638	sig);	1638	sig);
1639	rc = process_request_key_err(PTR_ERR(*auth_tok_key));	1639	rc = process_request_key_err(PTR_ERR(*auth_tok_key));
1640	(*auth_tok_key) = NULL;	1640	(*auth_tok_key) = NULL;
1641	goto out;	1641	goto out;
1642	}	1642	}
1643	}	1643	}
1644	down_write(&(*auth_tok_key)->sem);	1644	down_write(&(*auth_tok_key)->sem);
1645	rc = ecryptfs_verify_auth_tok_from_key(*auth_tok_key, auth_tok);	1645	rc = ecryptfs_verify_auth_tok_from_key(*auth_tok_key, auth_tok);
1646	if (rc) {	1646	if (rc) {
1647	up_write(&(*auth_tok_key)->sem);	1647	up_write(&(*auth_tok_key)->sem);
1648	key_put(*auth_tok_key);	1648	key_put(*auth_tok_key);
1649	(*auth_tok_key) = NULL;	1649	(*auth_tok_key) = NULL;
1650	goto out;	1650	goto out;
1651	}	1651	}
1652	out:	1652	out:
1653	return rc;	1653	return rc;
1654	}	1654	}
1655		1655
1656	/**	1656	/**
1657	* decrypt_passphrase_encrypted_session_key - Decrypt the session key with the given auth_tok.	1657	* decrypt_passphrase_encrypted_session_key - Decrypt the session key with the given auth_tok.
1658	* @auth_tok: The passphrase authentication token to use to encrypt the FEK	1658	* @auth_tok: The passphrase authentication token to use to encrypt the FEK
1659	* @crypt_stat: The cryptographic context	1659	* @crypt_stat: The cryptographic context
1660	*	1660	*
1661	* Returns zero on success; non-zero error otherwise	1661	* Returns zero on success; non-zero error otherwise
1662	*/	1662	*/
1663	static int	1663	static int
1664	decrypt_passphrase_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,	1664	decrypt_passphrase_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,
1665	struct ecryptfs_crypt_stat *crypt_stat)	1665	struct ecryptfs_crypt_stat *crypt_stat)
1666	{	1666	{
1667	struct scatterlist dst_sg[2];	1667	struct scatterlist dst_sg[2];
1668	struct scatterlist src_sg[2];	1668	struct scatterlist src_sg[2];
1669	struct mutex *tfm_mutex;	1669	struct mutex *tfm_mutex;
1670	struct blkcipher_desc desc = {	1670	struct blkcipher_desc desc = {
1671	.flags = CRYPTO_TFM_REQ_MAY_SLEEP	1671	.flags = CRYPTO_TFM_REQ_MAY_SLEEP
1672	};	1672	};
1673	int rc = 0;	1673	int rc = 0;
1674		1674
1675	if (unlikely(ecryptfs_verbosity > 0)) {	1675	if (unlikely(ecryptfs_verbosity > 0)) {
1676	ecryptfs_printk(	1676	ecryptfs_printk(
1677	KERN_DEBUG, "Session key encryption key (size [%d]):\n",	1677	KERN_DEBUG, "Session key encryption key (size [%d]):\n",
1678	auth_tok->token.password.session_key_encryption_key_bytes);	1678	auth_tok->token.password.session_key_encryption_key_bytes);
1679	ecryptfs_dump_hex(	1679	ecryptfs_dump_hex(
1680	auth_tok->token.password.session_key_encryption_key,	1680	auth_tok->token.password.session_key_encryption_key,
1681	auth_tok->token.password.session_key_encryption_key_bytes);	1681	auth_tok->token.password.session_key_encryption_key_bytes);
1682	}	1682	}
1683	rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(&desc.tfm, &tfm_mutex,	1683	rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(&desc.tfm, &tfm_mutex,
1684	crypt_stat->cipher);	1684	crypt_stat->cipher);
1685	if (unlikely(rc)) {	1685	if (unlikely(rc)) {
1686	printk(KERN_ERR "Internal error whilst attempting to get "	1686	printk(KERN_ERR "Internal error whilst attempting to get "
1687	"tfm and mutex for cipher name [%s]; rc = [%d]\n",	1687	"tfm and mutex for cipher name [%s]; rc = [%d]\n",
1688	crypt_stat->cipher, rc);	1688	crypt_stat->cipher, rc);
1689	goto out;	1689	goto out;
1690	}	1690	}
1691	rc = virt_to_scatterlist(auth_tok->session_key.encrypted_key,	1691	rc = virt_to_scatterlist(auth_tok->session_key.encrypted_key,
1692	auth_tok->session_key.encrypted_key_size,	1692	auth_tok->session_key.encrypted_key_size,
1693	src_sg, 2);	1693	src_sg, 2);
1694	if (rc < 1 \|\| rc > 2) {	1694	if (rc < 1 \|\| rc > 2) {
1695	printk(KERN_ERR "Internal error whilst attempting to convert "	1695	printk(KERN_ERR "Internal error whilst attempting to convert "
1696	"auth_tok->session_key.encrypted_key to scatterlist; "	1696	"auth_tok->session_key.encrypted_key to scatterlist; "
1697	"expected rc = 1; got rc = [%d]. "	1697	"expected rc = 1; got rc = [%d]. "
1698	"auth_tok->session_key.encrypted_key_size = [%d]\n", rc,	1698	"auth_tok->session_key.encrypted_key_size = [%d]\n", rc,
1699	auth_tok->session_key.encrypted_key_size);	1699	auth_tok->session_key.encrypted_key_size);
1700	goto out;	1700	goto out;
1701	}	1701	}
1702	auth_tok->session_key.decrypted_key_size =	1702	auth_tok->session_key.decrypted_key_size =
1703	auth_tok->session_key.encrypted_key_size;	1703	auth_tok->session_key.encrypted_key_size;
1704	rc = virt_to_scatterlist(auth_tok->session_key.decrypted_key,	1704	rc = virt_to_scatterlist(auth_tok->session_key.decrypted_key,
1705	auth_tok->session_key.decrypted_key_size,	1705	auth_tok->session_key.decrypted_key_size,
1706	dst_sg, 2);	1706	dst_sg, 2);
1707	if (rc < 1 \|\| rc > 2) {	1707	if (rc < 1 \|\| rc > 2) {
1708	printk(KERN_ERR "Internal error whilst attempting to convert "	1708	printk(KERN_ERR "Internal error whilst attempting to convert "
1709	"auth_tok->session_key.decrypted_key to scatterlist; "	1709	"auth_tok->session_key.decrypted_key to scatterlist; "
1710	"expected rc = 1; got rc = [%d]\n", rc);	1710	"expected rc = 1; got rc = [%d]\n", rc);
1711	goto out;	1711	goto out;
1712	}	1712	}
1713	mutex_lock(tfm_mutex);	1713	mutex_lock(tfm_mutex);
1714	rc = crypto_blkcipher_setkey(	1714	rc = crypto_blkcipher_setkey(
1715	desc.tfm, auth_tok->token.password.session_key_encryption_key,	1715	desc.tfm, auth_tok->token.password.session_key_encryption_key,
1716	crypt_stat->key_size);	1716	crypt_stat->key_size);
1717	if (unlikely(rc < 0)) {	1717	if (unlikely(rc < 0)) {
1718	mutex_unlock(tfm_mutex);	1718	mutex_unlock(tfm_mutex);
1719	printk(KERN_ERR "Error setting key for crypto context\n");	1719	printk(KERN_ERR "Error setting key for crypto context\n");
1720	rc = -EINVAL;	1720	rc = -EINVAL;
1721	goto out;	1721	goto out;
1722	}	1722	}
1723	rc = crypto_blkcipher_decrypt(&desc, dst_sg, src_sg,	1723	rc = crypto_blkcipher_decrypt(&desc, dst_sg, src_sg,
1724	auth_tok->session_key.encrypted_key_size);	1724	auth_tok->session_key.encrypted_key_size);
1725	mutex_unlock(tfm_mutex);	1725	mutex_unlock(tfm_mutex);
1726	if (unlikely(rc)) {	1726	if (unlikely(rc)) {
1727	printk(KERN_ERR "Error decrypting; rc = [%d]\n", rc);	1727	printk(KERN_ERR "Error decrypting; rc = [%d]\n", rc);
1728	goto out;	1728	goto out;
1729	}	1729	}
1730	auth_tok->session_key.flags \|= ECRYPTFS_CONTAINS_DECRYPTED_KEY;	1730	auth_tok->session_key.flags \|= ECRYPTFS_CONTAINS_DECRYPTED_KEY;
1731	memcpy(crypt_stat->key, auth_tok->session_key.decrypted_key,	1731	memcpy(crypt_stat->key, auth_tok->session_key.decrypted_key,
1732	auth_tok->session_key.decrypted_key_size);	1732	auth_tok->session_key.decrypted_key_size);
1733	crypt_stat->flags \|= ECRYPTFS_KEY_VALID;	1733	crypt_stat->flags \|= ECRYPTFS_KEY_VALID;
1734	if (unlikely(ecryptfs_verbosity > 0)) {	1734	if (unlikely(ecryptfs_verbosity > 0)) {
1735	ecryptfs_printk(KERN_DEBUG, "FEK of size [%zd]:\n",	1735	ecryptfs_printk(KERN_DEBUG, "FEK of size [%zd]:\n",
1736	crypt_stat->key_size);	1736	crypt_stat->key_size);
1737	ecryptfs_dump_hex(crypt_stat->key,	1737	ecryptfs_dump_hex(crypt_stat->key,
1738	crypt_stat->key_size);	1738	crypt_stat->key_size);
1739	}	1739	}
1740	out:	1740	out:
1741	return rc;	1741	return rc;
1742	}	1742	}
1743		1743
1744	/**	1744	/**
1745	* ecryptfs_parse_packet_set	1745	* ecryptfs_parse_packet_set
1746	* @crypt_stat: The cryptographic context	1746	* @crypt_stat: The cryptographic context
1747	* @src: Virtual address of region of memory containing the packets	1747	* @src: Virtual address of region of memory containing the packets
1748	* @ecryptfs_dentry: The eCryptfs dentry associated with the packet set	1748	* @ecryptfs_dentry: The eCryptfs dentry associated with the packet set
1749	*	1749	*
1750	* Get crypt_stat to have the file's session key if the requisite key	1750	* Get crypt_stat to have the file's session key if the requisite key
1751	* is available to decrypt the session key.	1751	* is available to decrypt the session key.
1752	*	1752	*
1753	* Returns Zero if a valid authentication token was retrieved and	1753	* Returns Zero if a valid authentication token was retrieved and
1754	* processed; negative value for file not encrypted or for error	1754	* processed; negative value for file not encrypted or for error
1755	* conditions.	1755	* conditions.
1756	*/	1756	*/
1757	int ecryptfs_parse_packet_set(struct ecryptfs_crypt_stat *crypt_stat,	1757	int ecryptfs_parse_packet_set(struct ecryptfs_crypt_stat *crypt_stat,
1758	unsigned char *src,	1758	unsigned char *src,
1759	struct dentry *ecryptfs_dentry)	1759	struct dentry *ecryptfs_dentry)
1760	{	1760	{
1761	size_t i = 0;	1761	size_t i = 0;
1762	size_t found_auth_tok;	1762	size_t found_auth_tok;
1763	size_t next_packet_is_auth_tok_packet;	1763	size_t next_packet_is_auth_tok_packet;
1764	struct list_head auth_tok_list;	1764	struct list_head auth_tok_list;
1765	struct ecryptfs_auth_tok *matching_auth_tok;	1765	struct ecryptfs_auth_tok *matching_auth_tok;
1766	struct ecryptfs_auth_tok *candidate_auth_tok;	1766	struct ecryptfs_auth_tok *candidate_auth_tok;
1767	char *candidate_auth_tok_sig;	1767	char *candidate_auth_tok_sig;
1768	size_t packet_size;	1768	size_t packet_size;
1769	struct ecryptfs_auth_tok *new_auth_tok;	1769	struct ecryptfs_auth_tok *new_auth_tok;
1770	unsigned char sig_tmp_space[ECRYPTFS_SIG_SIZE];	1770	unsigned char sig_tmp_space[ECRYPTFS_SIG_SIZE];
1771	struct ecryptfs_auth_tok_list_item *auth_tok_list_item;	1771	struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
1772	size_t tag_11_contents_size;	1772	size_t tag_11_contents_size;
1773	size_t tag_11_packet_size;	1773	size_t tag_11_packet_size;
1774	struct key *auth_tok_key = NULL;	1774	struct key *auth_tok_key = NULL;
1775	int rc = 0;	1775	int rc = 0;
1776		1776
1777	INIT_LIST_HEAD(&auth_tok_list);	1777	INIT_LIST_HEAD(&auth_tok_list);
1778	/* Parse the header to find as many packets as we can; these will be	1778	/* Parse the header to find as many packets as we can; these will be
1779	* added the our &auth_tok_list */	1779	* added the our &auth_tok_list */
1780	next_packet_is_auth_tok_packet = 1;	1780	next_packet_is_auth_tok_packet = 1;
1781	while (next_packet_is_auth_tok_packet) {	1781	while (next_packet_is_auth_tok_packet) {
1782	size_t max_packet_size = ((PAGE_CACHE_SIZE - 8) - i);	1782	size_t max_packet_size = ((PAGE_CACHE_SIZE - 8) - i);
1783		1783
1784	switch (src[i]) {	1784	switch (src[i]) {
1785	case ECRYPTFS_TAG_3_PACKET_TYPE:	1785	case ECRYPTFS_TAG_3_PACKET_TYPE:
1786	rc = parse_tag_3_packet(crypt_stat,	1786	rc = parse_tag_3_packet(crypt_stat,
1787	(unsigned char *)&src[i],	1787	(unsigned char *)&src[i],
1788	&auth_tok_list, &new_auth_tok,	1788	&auth_tok_list, &new_auth_tok,
1789	&packet_size, max_packet_size);	1789	&packet_size, max_packet_size);
1790	if (rc) {	1790	if (rc) {
1791	ecryptfs_printk(KERN_ERR, "Error parsing "	1791	ecryptfs_printk(KERN_ERR, "Error parsing "
1792	"tag 3 packet\n");	1792	"tag 3 packet\n");
1793	rc = -EIO;	1793	rc = -EIO;
1794	goto out_wipe_list;	1794	goto out_wipe_list;
1795	}	1795	}
1796	i += packet_size;	1796	i += packet_size;
1797	rc = parse_tag_11_packet((unsigned char *)&src[i],	1797	rc = parse_tag_11_packet((unsigned char *)&src[i],
1798	sig_tmp_space,	1798	sig_tmp_space,
1799	ECRYPTFS_SIG_SIZE,	1799	ECRYPTFS_SIG_SIZE,
1800	&tag_11_contents_size,	1800	&tag_11_contents_size,
1801	&tag_11_packet_size,	1801	&tag_11_packet_size,
1802	max_packet_size);	1802	max_packet_size);
1803	if (rc) {	1803	if (rc) {
1804	ecryptfs_printk(KERN_ERR, "No valid "	1804	ecryptfs_printk(KERN_ERR, "No valid "
1805	"(ecryptfs-specific) literal "	1805	"(ecryptfs-specific) literal "
1806	"packet containing "	1806	"packet containing "
1807	"authentication token "	1807	"authentication token "
1808	"signature found after "	1808	"signature found after "
1809	"tag 3 packet\n");	1809	"tag 3 packet\n");
1810	rc = -EIO;	1810	rc = -EIO;
1811	goto out_wipe_list;	1811	goto out_wipe_list;
1812	}	1812	}
1813	i += tag_11_packet_size;	1813	i += tag_11_packet_size;
1814	if (ECRYPTFS_SIG_SIZE != tag_11_contents_size) {	1814	if (ECRYPTFS_SIG_SIZE != tag_11_contents_size) {
1815	ecryptfs_printk(KERN_ERR, "Expected "	1815	ecryptfs_printk(KERN_ERR, "Expected "
1816	"signature of size [%d]; "	1816	"signature of size [%d]; "
1817	"read size [%zd]\n",	1817	"read size [%zd]\n",
1818	ECRYPTFS_SIG_SIZE,	1818	ECRYPTFS_SIG_SIZE,
1819	tag_11_contents_size);	1819	tag_11_contents_size);
1820	rc = -EIO;	1820	rc = -EIO;
1821	goto out_wipe_list;	1821	goto out_wipe_list;
1822	}	1822	}
1823	ecryptfs_to_hex(new_auth_tok->token.password.signature,	1823	ecryptfs_to_hex(new_auth_tok->token.password.signature,
1824	sig_tmp_space, tag_11_contents_size);	1824	sig_tmp_space, tag_11_contents_size);
1825	new_auth_tok->token.password.signature[	1825	new_auth_tok->token.password.signature[
1826	ECRYPTFS_PASSWORD_SIG_SIZE] = '\0';	1826	ECRYPTFS_PASSWORD_SIG_SIZE] = '\0';
1827	crypt_stat->flags \|= ECRYPTFS_ENCRYPTED;	1827	crypt_stat->flags \|= ECRYPTFS_ENCRYPTED;
1828	break;	1828	break;
1829	case ECRYPTFS_TAG_1_PACKET_TYPE:	1829	case ECRYPTFS_TAG_1_PACKET_TYPE:
1830	rc = parse_tag_1_packet(crypt_stat,	1830	rc = parse_tag_1_packet(crypt_stat,
1831	(unsigned char *)&src[i],	1831	(unsigned char *)&src[i],
1832	&auth_tok_list, &new_auth_tok,	1832	&auth_tok_list, &new_auth_tok,
1833	&packet_size, max_packet_size);	1833	&packet_size, max_packet_size);
1834	if (rc) {	1834	if (rc) {
1835	ecryptfs_printk(KERN_ERR, "Error parsing "	1835	ecryptfs_printk(KERN_ERR, "Error parsing "
1836	"tag 1 packet\n");	1836	"tag 1 packet\n");
1837	rc = -EIO;	1837	rc = -EIO;
1838	goto out_wipe_list;	1838	goto out_wipe_list;
1839	}	1839	}
1840	i += packet_size;	1840	i += packet_size;
1841	crypt_stat->flags \|= ECRYPTFS_ENCRYPTED;	1841	crypt_stat->flags \|= ECRYPTFS_ENCRYPTED;
1842	break;	1842	break;
1843	case ECRYPTFS_TAG_11_PACKET_TYPE:	1843	case ECRYPTFS_TAG_11_PACKET_TYPE:
1844	ecryptfs_printk(KERN_WARNING, "Invalid packet set "	1844	ecryptfs_printk(KERN_WARNING, "Invalid packet set "
1845	"(Tag 11 not allowed by itself)\n");	1845	"(Tag 11 not allowed by itself)\n");
1846	rc = -EIO;	1846	rc = -EIO;
1847	goto out_wipe_list;	1847	goto out_wipe_list;
1848	default:	1848	default:
1849	ecryptfs_printk(KERN_DEBUG, "No packet at offset [%zd] "	1849	ecryptfs_printk(KERN_DEBUG, "No packet at offset [%zd] "
1850	"of the file header; hex value of "	1850	"of the file header; hex value of "
1851	"character is [0x%.2x]\n", i, src[i]);	1851	"character is [0x%.2x]\n", i, src[i]);
1852	next_packet_is_auth_tok_packet = 0;	1852	next_packet_is_auth_tok_packet = 0;
1853	}	1853	}
1854	}	1854	}
1855	if (list_empty(&auth_tok_list)) {	1855	if (list_empty(&auth_tok_list)) {
1856	printk(KERN_ERR "The lower file appears to be a non-encrypted "	1856	printk(KERN_ERR "The lower file appears to be a non-encrypted "
1857	"eCryptfs file; this is not supported in this version "	1857	"eCryptfs file; this is not supported in this version "
1858	"of the eCryptfs kernel module\n");	1858	"of the eCryptfs kernel module\n");
1859	rc = -EINVAL;	1859	rc = -EINVAL;
1860	goto out;	1860	goto out;
1861	}	1861	}
1862	/* auth_tok_list contains the set of authentication tokens	1862	/* auth_tok_list contains the set of authentication tokens
1863	* parsed from the metadata. We need to find a matching	1863	* parsed from the metadata. We need to find a matching
1864	* authentication token that has the secret component(s)	1864	* authentication token that has the secret component(s)
1865	* necessary to decrypt the EFEK in the auth_tok parsed from	1865	* necessary to decrypt the EFEK in the auth_tok parsed from
1866	* the metadata. There may be several potential matches, but	1866	* the metadata. There may be several potential matches, but
1867	* just one will be sufficient to decrypt to get the FEK. */	1867	* just one will be sufficient to decrypt to get the FEK. */
1868	find_next_matching_auth_tok:	1868	find_next_matching_auth_tok:
1869	found_auth_tok = 0;	1869	found_auth_tok = 0;
1870	list_for_each_entry(auth_tok_list_item, &auth_tok_list, list) {	1870	list_for_each_entry(auth_tok_list_item, &auth_tok_list, list) {
1871	candidate_auth_tok = &auth_tok_list_item->auth_tok;	1871	candidate_auth_tok = &auth_tok_list_item->auth_tok;
1872	if (unlikely(ecryptfs_verbosity > 0)) {	1872	if (unlikely(ecryptfs_verbosity > 0)) {
1873	ecryptfs_printk(KERN_DEBUG,	1873	ecryptfs_printk(KERN_DEBUG,
1874	"Considering cadidate auth tok:\n");	1874	"Considering cadidate auth tok:\n");
1875	ecryptfs_dump_auth_tok(candidate_auth_tok);	1875	ecryptfs_dump_auth_tok(candidate_auth_tok);
1876	}	1876	}
1877	rc = ecryptfs_get_auth_tok_sig(&candidate_auth_tok_sig,	1877	rc = ecryptfs_get_auth_tok_sig(&candidate_auth_tok_sig,
1878	candidate_auth_tok);	1878	candidate_auth_tok);
1879	if (rc) {	1879	if (rc) {
1880	printk(KERN_ERR	1880	printk(KERN_ERR
1881	"Unrecognized candidate auth tok type: [%d]\n",	1881	"Unrecognized candidate auth tok type: [%d]\n",
1882	candidate_auth_tok->token_type);	1882	candidate_auth_tok->token_type);
1883	rc = -EINVAL;	1883	rc = -EINVAL;
1884	goto out_wipe_list;	1884	goto out_wipe_list;
1885	}	1885	}
1886	rc = ecryptfs_find_auth_tok_for_sig(&auth_tok_key,	1886	rc = ecryptfs_find_auth_tok_for_sig(&auth_tok_key,
1887	&matching_auth_tok,	1887	&matching_auth_tok,
1888	crypt_stat->mount_crypt_stat,	1888	crypt_stat->mount_crypt_stat,
1889	candidate_auth_tok_sig);	1889	candidate_auth_tok_sig);
1890	if (!rc) {	1890	if (!rc) {
1891	found_auth_tok = 1;	1891	found_auth_tok = 1;
1892	goto found_matching_auth_tok;	1892	goto found_matching_auth_tok;
1893	}	1893	}
1894	}	1894	}
1895	if (!found_auth_tok) {	1895	if (!found_auth_tok) {
1896	ecryptfs_printk(KERN_ERR, "Could not find a usable "	1896	ecryptfs_printk(KERN_ERR, "Could not find a usable "
1897	"authentication token\n");	1897	"authentication token\n");
1898	rc = -EIO;	1898	rc = -EIO;
1899	goto out_wipe_list;	1899	goto out_wipe_list;
1900	}	1900	}
1901	found_matching_auth_tok:	1901	found_matching_auth_tok:
1902	if (candidate_auth_tok->token_type == ECRYPTFS_PRIVATE_KEY) {	1902	if (candidate_auth_tok->token_type == ECRYPTFS_PRIVATE_KEY) {
1903	memcpy(&(candidate_auth_tok->token.private_key),	1903	memcpy(&(candidate_auth_tok->token.private_key),
1904	&(matching_auth_tok->token.private_key),	1904	&(matching_auth_tok->token.private_key),
1905	sizeof(struct ecryptfs_private_key));	1905	sizeof(struct ecryptfs_private_key));
1906	up_write(&(auth_tok_key->sem));	1906	up_write(&(auth_tok_key->sem));
1907	key_put(auth_tok_key);	1907	key_put(auth_tok_key);
1908	rc = decrypt_pki_encrypted_session_key(candidate_auth_tok,	1908	rc = decrypt_pki_encrypted_session_key(candidate_auth_tok,
1909	crypt_stat);	1909	crypt_stat);
1910	} else if (candidate_auth_tok->token_type == ECRYPTFS_PASSWORD) {	1910	} else if (candidate_auth_tok->token_type == ECRYPTFS_PASSWORD) {
1911	memcpy(&(candidate_auth_tok->token.password),	1911	memcpy(&(candidate_auth_tok->token.password),
1912	&(matching_auth_tok->token.password),	1912	&(matching_auth_tok->token.password),
1913	sizeof(struct ecryptfs_password));	1913	sizeof(struct ecryptfs_password));
1914	up_write(&(auth_tok_key->sem));	1914	up_write(&(auth_tok_key->sem));
1915	key_put(auth_tok_key);	1915	key_put(auth_tok_key);
1916	rc = decrypt_passphrase_encrypted_session_key(	1916	rc = decrypt_passphrase_encrypted_session_key(
1917	candidate_auth_tok, crypt_stat);	1917	candidate_auth_tok, crypt_stat);
1918	} else {	1918	} else {
1919	up_write(&(auth_tok_key->sem));	1919	up_write(&(auth_tok_key->sem));
1920	key_put(auth_tok_key);	1920	key_put(auth_tok_key);
1921	rc = -EINVAL;	1921	rc = -EINVAL;
1922	}	1922	}
1923	if (rc) {	1923	if (rc) {
1924	struct ecryptfs_auth_tok_list_item *auth_tok_list_item_tmp;	1924	struct ecryptfs_auth_tok_list_item *auth_tok_list_item_tmp;
1925		1925
1926	ecryptfs_printk(KERN_WARNING, "Error decrypting the "	1926	ecryptfs_printk(KERN_WARNING, "Error decrypting the "
1927	"session key for authentication token with sig "	1927	"session key for authentication token with sig "
1928	"[%.*s]; rc = [%d]. Removing auth tok "	1928	"[%.*s]; rc = [%d]. Removing auth tok "
1929	"candidate from the list and searching for "	1929	"candidate from the list and searching for "
1930	"the next match.\n", ECRYPTFS_SIG_SIZE_HEX,	1930	"the next match.\n", ECRYPTFS_SIG_SIZE_HEX,
1931	candidate_auth_tok_sig, rc);	1931	candidate_auth_tok_sig, rc);
1932	list_for_each_entry_safe(auth_tok_list_item,	1932	list_for_each_entry_safe(auth_tok_list_item,
1933	auth_tok_list_item_tmp,	1933	auth_tok_list_item_tmp,
1934	&auth_tok_list, list) {	1934	&auth_tok_list, list) {
1935	if (candidate_auth_tok	1935	if (candidate_auth_tok
1936	== &auth_tok_list_item->auth_tok) {	1936	== &auth_tok_list_item->auth_tok) {
1937	list_del(&auth_tok_list_item->list);	1937	list_del(&auth_tok_list_item->list);
1938	kmem_cache_free(	1938	kmem_cache_free(
1939	ecryptfs_auth_tok_list_item_cache,	1939	ecryptfs_auth_tok_list_item_cache,
1940	auth_tok_list_item);	1940	auth_tok_list_item);
1941	goto find_next_matching_auth_tok;	1941	goto find_next_matching_auth_tok;
1942	}	1942	}
1943	}	1943	}
1944	BUG();	1944	BUG();
1945	}	1945	}
1946	rc = ecryptfs_compute_root_iv(crypt_stat);	1946	rc = ecryptfs_compute_root_iv(crypt_stat);
1947	if (rc) {	1947	if (rc) {
1948	ecryptfs_printk(KERN_ERR, "Error computing "	1948	ecryptfs_printk(KERN_ERR, "Error computing "
1949	"the root IV\n");	1949	"the root IV\n");
1950	goto out_wipe_list;	1950	goto out_wipe_list;
1951	}	1951	}
1952	rc = ecryptfs_init_crypt_ctx(crypt_stat);	1952	rc = ecryptfs_init_crypt_ctx(crypt_stat);
1953	if (rc) {	1953	if (rc) {
1954	ecryptfs_printk(KERN_ERR, "Error initializing crypto "	1954	ecryptfs_printk(KERN_ERR, "Error initializing crypto "
1955	"context for cipher [%s]; rc = [%d]\n",	1955	"context for cipher [%s]; rc = [%d]\n",
1956	crypt_stat->cipher, rc);	1956	crypt_stat->cipher, rc);
1957	}	1957	}
1958	out_wipe_list:	1958	out_wipe_list:
1959	wipe_auth_tok_list(&auth_tok_list);	1959	wipe_auth_tok_list(&auth_tok_list);
1960	out:	1960	out:
1961	return rc;	1961	return rc;
1962	}	1962	}
1963		1963
1964	static int	1964	static int
1965	pki_encrypt_session_key(struct key *auth_tok_key,	1965	pki_encrypt_session_key(struct key *auth_tok_key,
1966	struct ecryptfs_auth_tok *auth_tok,	1966	struct ecryptfs_auth_tok *auth_tok,
1967	struct ecryptfs_crypt_stat *crypt_stat,	1967	struct ecryptfs_crypt_stat *crypt_stat,
1968	struct ecryptfs_key_record *key_rec)	1968	struct ecryptfs_key_record *key_rec)
1969	{	1969	{
1970	struct ecryptfs_msg_ctx *msg_ctx = NULL;	1970	struct ecryptfs_msg_ctx *msg_ctx = NULL;
1971	char *payload = NULL;	1971	char *payload = NULL;
1972	size_t payload_len = 0;	1972	size_t payload_len = 0;
1973	struct ecryptfs_message *msg;	1973	struct ecryptfs_message *msg;
1974	int rc;	1974	int rc;
1975		1975
1976	rc = write_tag_66_packet(auth_tok->token.private_key.signature,	1976	rc = write_tag_66_packet(auth_tok->token.private_key.signature,
1977	ecryptfs_code_for_cipher_string(	1977	ecryptfs_code_for_cipher_string(
1978	crypt_stat->cipher,	1978	crypt_stat->cipher,
1979	crypt_stat->key_size),	1979	crypt_stat->key_size),
1980	crypt_stat, &payload, &payload_len);	1980	crypt_stat, &payload, &payload_len);
1981	up_write(&(auth_tok_key->sem));	1981	up_write(&(auth_tok_key->sem));
1982	key_put(auth_tok_key);	1982	key_put(auth_tok_key);
1983	if (rc) {	1983	if (rc) {
1984	ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet\n");	1984	ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet\n");
1985	goto out;	1985	goto out;
1986	}	1986	}
1987	rc = ecryptfs_send_message(payload, payload_len, &msg_ctx);	1987	rc = ecryptfs_send_message(payload, payload_len, &msg_ctx);
1988	if (rc) {	1988	if (rc) {
1989	ecryptfs_printk(KERN_ERR, "Error sending message to "	1989	ecryptfs_printk(KERN_ERR, "Error sending message to "
1990	"ecryptfsd: %d\n", rc);	1990	"ecryptfsd: %d\n", rc);
1991	goto out;	1991	goto out;
1992	}	1992	}
1993	rc = ecryptfs_wait_for_response(msg_ctx, &msg);	1993	rc = ecryptfs_wait_for_response(msg_ctx, &msg);
1994	if (rc) {	1994	if (rc) {
1995	ecryptfs_printk(KERN_ERR, "Failed to receive tag 67 packet "	1995	ecryptfs_printk(KERN_ERR, "Failed to receive tag 67 packet "
1996	"from the user space daemon\n");	1996	"from the user space daemon\n");
1997	rc = -EIO;	1997	rc = -EIO;
1998	goto out;	1998	goto out;
1999	}	1999	}
2000	rc = parse_tag_67_packet(key_rec, msg);	2000	rc = parse_tag_67_packet(key_rec, msg);
2001	if (rc)	2001	if (rc)
2002	ecryptfs_printk(KERN_ERR, "Error parsing tag 67 packet\n");	2002	ecryptfs_printk(KERN_ERR, "Error parsing tag 67 packet\n");
2003	kfree(msg);	2003	kfree(msg);
2004	out:	2004	out:
2005	kfree(payload);	2005	kfree(payload);
2006	return rc;	2006	return rc;
2007	}	2007	}
2008	/**	2008	/**
2009	* write_tag_1_packet - Write an RFC2440-compatible tag 1 (public key) packet	2009	* write_tag_1_packet - Write an RFC2440-compatible tag 1 (public key) packet
2010	* @dest: Buffer into which to write the packet	2010	* @dest: Buffer into which to write the packet
2011	* @remaining_bytes: Maximum number of bytes that can be writtn	2011	* @remaining_bytes: Maximum number of bytes that can be writtn
2012	* @auth_tok_key: The authentication token key to unlock and put when done with	2012	* @auth_tok_key: The authentication token key to unlock and put when done with
2013	* @auth_tok	2013	* @auth_tok
2014	* @auth_tok: The authentication token used for generating the tag 1 packet	2014	* @auth_tok: The authentication token used for generating the tag 1 packet
2015	* @crypt_stat: The cryptographic context	2015	* @crypt_stat: The cryptographic context
2016	* @key_rec: The key record struct for the tag 1 packet	2016	* @key_rec: The key record struct for the tag 1 packet
2017	* @packet_size: This function will write the number of bytes that end	2017	* @packet_size: This function will write the number of bytes that end
2018	* up constituting the packet; set to zero on error	2018	* up constituting the packet; set to zero on error
2019	*	2019	*
2020	* Returns zero on success; non-zero on error.	2020	* Returns zero on success; non-zero on error.
2021	*/	2021	*/
2022	static int	2022	static int
2023	write_tag_1_packet(char dest, size_t remaining_bytes,	2023	write_tag_1_packet(char dest, size_t remaining_bytes,
2024	struct key auth_tok_key, struct ecryptfs_auth_tok auth_tok,	2024	struct key auth_tok_key, struct ecryptfs_auth_tok auth_tok,
2025	struct ecryptfs_crypt_stat *crypt_stat,	2025	struct ecryptfs_crypt_stat *crypt_stat,
2026	struct ecryptfs_key_record key_rec, size_t packet_size)	2026	struct ecryptfs_key_record key_rec, size_t packet_size)
2027	{	2027	{
2028	size_t i;	2028	size_t i;
2029	size_t encrypted_session_key_valid = 0;	2029	size_t encrypted_session_key_valid = 0;
2030	size_t packet_size_length;	2030	size_t packet_size_length;
2031	size_t max_packet_size;	2031	size_t max_packet_size;
2032	int rc = 0;	2032	int rc = 0;
2033		2033
2034	(*packet_size) = 0;	2034	(*packet_size) = 0;
2035	ecryptfs_from_hex(key_rec->sig, auth_tok->token.private_key.signature,	2035	ecryptfs_from_hex(key_rec->sig, auth_tok->token.private_key.signature,
2036	ECRYPTFS_SIG_SIZE);	2036	ECRYPTFS_SIG_SIZE);
2037	encrypted_session_key_valid = 0;	2037	encrypted_session_key_valid = 0;
2038	for (i = 0; i < crypt_stat->key_size; i++)	2038	for (i = 0; i < crypt_stat->key_size; i++)
2039	encrypted_session_key_valid \|=	2039	encrypted_session_key_valid \|=
2040	auth_tok->session_key.encrypted_key[i];	2040	auth_tok->session_key.encrypted_key[i];
2041	if (encrypted_session_key_valid) {	2041	if (encrypted_session_key_valid) {
2042	memcpy(key_rec->enc_key,	2042	memcpy(key_rec->enc_key,
2043	auth_tok->session_key.encrypted_key,	2043	auth_tok->session_key.encrypted_key,
2044	auth_tok->session_key.encrypted_key_size);	2044	auth_tok->session_key.encrypted_key_size);
2045	up_write(&(auth_tok_key->sem));	2045	up_write(&(auth_tok_key->sem));
2046	key_put(auth_tok_key);	2046	key_put(auth_tok_key);
2047	goto encrypted_session_key_set;	2047	goto encrypted_session_key_set;
2048	}	2048	}
2049	if (auth_tok->session_key.encrypted_key_size == 0)	2049	if (auth_tok->session_key.encrypted_key_size == 0)
2050	auth_tok->session_key.encrypted_key_size =	2050	auth_tok->session_key.encrypted_key_size =
2051	auth_tok->token.private_key.key_size;	2051	auth_tok->token.private_key.key_size;
2052	rc = pki_encrypt_session_key(auth_tok_key, auth_tok, crypt_stat,	2052	rc = pki_encrypt_session_key(auth_tok_key, auth_tok, crypt_stat,
2053	key_rec);	2053	key_rec);
2054	if (rc) {	2054	if (rc) {
2055	printk(KERN_ERR "Failed to encrypt session key via a key "	2055	printk(KERN_ERR "Failed to encrypt session key via a key "
2056	"module; rc = [%d]\n", rc);	2056	"module; rc = [%d]\n", rc);
2057	goto out;	2057	goto out;
2058	}	2058	}
2059	if (ecryptfs_verbosity > 0) {	2059	if (ecryptfs_verbosity > 0) {
2060	ecryptfs_printk(KERN_DEBUG, "Encrypted key:\n");	2060	ecryptfs_printk(KERN_DEBUG, "Encrypted key:\n");
2061	ecryptfs_dump_hex(key_rec->enc_key, key_rec->enc_key_size);	2061	ecryptfs_dump_hex(key_rec->enc_key, key_rec->enc_key_size);
2062	}	2062	}
2063	encrypted_session_key_set:	2063	encrypted_session_key_set:
2064	/* This format is inspired by OpenPGP; see RFC 2440	2064	/* This format is inspired by OpenPGP; see RFC 2440
2065	* packet tag 1 */	2065	* packet tag 1 */
2066	max_packet_size = (1 /* Tag 1 identifier */	2066	max_packet_size = (1 /* Tag 1 identifier */
2067	+ 3 /* Max Tag 1 packet size */	2067	+ 3 /* Max Tag 1 packet size */
2068	+ 1 /* Version */	2068	+ 1 /* Version */
2069	+ ECRYPTFS_SIG_SIZE /* Key identifier */	2069	+ ECRYPTFS_SIG_SIZE /* Key identifier */
2070	+ 1 /* Cipher identifier */	2070	+ 1 /* Cipher identifier */
2071	+ key_rec->enc_key_size); /* Encrypted key size */	2071	+ key_rec->enc_key_size); /* Encrypted key size */
2072	if (max_packet_size > (*remaining_bytes)) {	2072	if (max_packet_size > (*remaining_bytes)) {
2073	printk(KERN_ERR "Packet length larger than maximum allowable; "	2073	printk(KERN_ERR "Packet length larger than maximum allowable; "
2074	"need up to [%td] bytes, but there are only [%td] "	2074	"need up to [%td] bytes, but there are only [%td] "
2075	"available\n", max_packet_size, (*remaining_bytes));	2075	"available\n", max_packet_size, (*remaining_bytes));
2076	rc = -EINVAL;	2076	rc = -EINVAL;
2077	goto out;	2077	goto out;
2078	}	2078	}
2079	dest[(*packet_size)++] = ECRYPTFS_TAG_1_PACKET_TYPE;	2079	dest[(*packet_size)++] = ECRYPTFS_TAG_1_PACKET_TYPE;
2080	rc = ecryptfs_write_packet_length(&dest[(*packet_size)],	2080	rc = ecryptfs_write_packet_length(&dest[(*packet_size)],
2081	(max_packet_size - 4),	2081	(max_packet_size - 4),
2082	&packet_size_length);	2082	&packet_size_length);
2083	if (rc) {	2083	if (rc) {
2084	ecryptfs_printk(KERN_ERR, "Error generating tag 1 packet "	2084	ecryptfs_printk(KERN_ERR, "Error generating tag 1 packet "
2085	"header; cannot generate packet length\n");	2085	"header; cannot generate packet length\n");
2086	goto out;	2086	goto out;
2087	}	2087	}
2088	(*packet_size) += packet_size_length;	2088	(*packet_size) += packet_size_length;
2089	dest[(packet_size)++] = 0x03; / version 3 */	2089	dest[(packet_size)++] = 0x03; / version 3 */
2090	memcpy(&dest[(*packet_size)], key_rec->sig, ECRYPTFS_SIG_SIZE);	2090	memcpy(&dest[(*packet_size)], key_rec->sig, ECRYPTFS_SIG_SIZE);
2091	(*packet_size) += ECRYPTFS_SIG_SIZE;	2091	(*packet_size) += ECRYPTFS_SIG_SIZE;
2092	dest[(*packet_size)++] = RFC2440_CIPHER_RSA;	2092	dest[(*packet_size)++] = RFC2440_CIPHER_RSA;
2093	memcpy(&dest[(*packet_size)], key_rec->enc_key,	2093	memcpy(&dest[(*packet_size)], key_rec->enc_key,
2094	key_rec->enc_key_size);	2094	key_rec->enc_key_size);
2095	(*packet_size) += key_rec->enc_key_size;	2095	(*packet_size) += key_rec->enc_key_size;
2096	out:	2096	out:
2097	if (rc)	2097	if (rc)
2098	(*packet_size) = 0;	2098	(*packet_size) = 0;
2099	else	2099	else
2100	(remaining_bytes) -= (packet_size);	2100	(remaining_bytes) -= (packet_size);
2101	return rc;	2101	return rc;
2102	}	2102	}
2103		2103
2104	/**	2104	/**
2105	* write_tag_11_packet	2105	* write_tag_11_packet
2106	* @dest: Target into which Tag 11 packet is to be written	2106	* @dest: Target into which Tag 11 packet is to be written
2107	* @remaining_bytes: Maximum packet length	2107	* @remaining_bytes: Maximum packet length
2108	* @contents: Byte array of contents to copy in	2108	* @contents: Byte array of contents to copy in
2109	* @contents_length: Number of bytes in contents	2109	* @contents_length: Number of bytes in contents
2110	* @packet_length: Length of the Tag 11 packet written; zero on error	2110	* @packet_length: Length of the Tag 11 packet written; zero on error
2111	*	2111	*
2112	* Returns zero on success; non-zero on error.	2112	* Returns zero on success; non-zero on error.
2113	*/	2113	*/
2114	static int	2114	static int
2115	write_tag_11_packet(char dest, size_t remaining_bytes, char *contents,	2115	write_tag_11_packet(char dest, size_t remaining_bytes, char *contents,
2116	size_t contents_length, size_t *packet_length)	2116	size_t contents_length, size_t *packet_length)
2117	{	2117	{
2118	size_t packet_size_length;	2118	size_t packet_size_length;
2119	size_t max_packet_size;	2119	size_t max_packet_size;
2120	int rc = 0;	2120	int rc = 0;
2121		2121
2122	(*packet_length) = 0;	2122	(*packet_length) = 0;
2123	/* This format is inspired by OpenPGP; see RFC 2440	2123	/* This format is inspired by OpenPGP; see RFC 2440
2124	* packet tag 11 */	2124	* packet tag 11 */
2125	max_packet_size = (1 /* Tag 11 identifier */	2125	max_packet_size = (1 /* Tag 11 identifier */
2126	+ 3 /* Max Tag 11 packet size */	2126	+ 3 /* Max Tag 11 packet size */
2127	+ 1 /* Binary format specifier */	2127	+ 1 /* Binary format specifier */
2128	+ 1 /* Filename length */	2128	+ 1 /* Filename length */
2129	+ 8 /* Filename ("_CONSOLE") */	2129	+ 8 /* Filename ("_CONSOLE") */
2130	+ 4 /* Modification date */	2130	+ 4 /* Modification date */
2131	+ contents_length); /* Literal data */	2131	+ contents_length); /* Literal data */
2132	if (max_packet_size > (*remaining_bytes)) {	2132	if (max_packet_size > (*remaining_bytes)) {
2133	printk(KERN_ERR "Packet length larger than maximum allowable; "	2133	printk(KERN_ERR "Packet length larger than maximum allowable; "
2134	"need up to [%td] bytes, but there are only [%td] "	2134	"need up to [%td] bytes, but there are only [%td] "
2135	"available\n", max_packet_size, (*remaining_bytes));	2135	"available\n", max_packet_size, (*remaining_bytes));
2136	rc = -EINVAL;	2136	rc = -EINVAL;
2137	goto out;	2137	goto out;
2138	}	2138	}
2139	dest[(*packet_length)++] = ECRYPTFS_TAG_11_PACKET_TYPE;	2139	dest[(*packet_length)++] = ECRYPTFS_TAG_11_PACKET_TYPE;
2140	rc = ecryptfs_write_packet_length(&dest[(*packet_length)],	2140	rc = ecryptfs_write_packet_length(&dest[(*packet_length)],
2141	(max_packet_size - 4),	2141	(max_packet_size - 4),
2142	&packet_size_length);	2142	&packet_size_length);
2143	if (rc) {	2143	if (rc) {
2144	printk(KERN_ERR "Error generating tag 11 packet header; cannot "	2144	printk(KERN_ERR "Error generating tag 11 packet header; cannot "
2145	"generate packet length. rc = [%d]\n", rc);	2145	"generate packet length. rc = [%d]\n", rc);
2146	goto out;	2146	goto out;
2147	}	2147	}
2148	(*packet_length) += packet_size_length;	2148	(*packet_length) += packet_size_length;
2149	dest[(packet_length)++] = 0x62; / binary data format specifier */	2149	dest[(packet_length)++] = 0x62; / binary data format specifier */
2150	dest[(*packet_length)++] = 8;	2150	dest[(*packet_length)++] = 8;
2151	memcpy(&dest[(*packet_length)], "_CONSOLE", 8);	2151	memcpy(&dest[(*packet_length)], "_CONSOLE", 8);
2152	(*packet_length) += 8;	2152	(*packet_length) += 8;
2153	memset(&dest[(*packet_length)], 0x00, 4);	2153	memset(&dest[(*packet_length)], 0x00, 4);
2154	(*packet_length) += 4;	2154	(*packet_length) += 4;
2155	memcpy(&dest[(*packet_length)], contents, contents_length);	2155	memcpy(&dest[(*packet_length)], contents, contents_length);
2156	(*packet_length) += contents_length;	2156	(*packet_length) += contents_length;
2157	out:	2157	out:
2158	if (rc)	2158	if (rc)
2159	(*packet_length) = 0;	2159	(*packet_length) = 0;
2160	else	2160	else
2161	(remaining_bytes) -= (packet_length);	2161	(remaining_bytes) -= (packet_length);
2162	return rc;	2162	return rc;
2163	}	2163	}
2164		2164
2165	/**	2165	/**
2166	* write_tag_3_packet	2166	* write_tag_3_packet
2167	* @dest: Buffer into which to write the packet	2167	* @dest: Buffer into which to write the packet
2168	* @remaining_bytes: Maximum number of bytes that can be written	2168	* @remaining_bytes: Maximum number of bytes that can be written
2169	* @auth_tok: Authentication token	2169	* @auth_tok: Authentication token
2170	* @crypt_stat: The cryptographic context	2170	* @crypt_stat: The cryptographic context
2171	* @key_rec: encrypted key	2171	* @key_rec: encrypted key
2172	* @packet_size: This function will write the number of bytes that end	2172	* @packet_size: This function will write the number of bytes that end
2173	* up constituting the packet; set to zero on error	2173	* up constituting the packet; set to zero on error
2174	*	2174	*
2175	* Returns zero on success; non-zero on error.	2175	* Returns zero on success; non-zero on error.
2176	*/	2176	*/
2177	static int	2177	static int
2178	write_tag_3_packet(char dest, size_t remaining_bytes,	2178	write_tag_3_packet(char dest, size_t remaining_bytes,
2179	struct ecryptfs_auth_tok *auth_tok,	2179	struct ecryptfs_auth_tok *auth_tok,
2180	struct ecryptfs_crypt_stat *crypt_stat,	2180	struct ecryptfs_crypt_stat *crypt_stat,
2181	struct ecryptfs_key_record key_rec, size_t packet_size)	2181	struct ecryptfs_key_record key_rec, size_t packet_size)
2182	{	2182	{
2183	size_t i;	2183	size_t i;
2184	size_t encrypted_session_key_valid = 0;	2184	size_t encrypted_session_key_valid = 0;
2185	char session_key_encryption_key[ECRYPTFS_MAX_KEY_BYTES];	2185	char session_key_encryption_key[ECRYPTFS_MAX_KEY_BYTES];
2186	struct scatterlist dst_sg[2];	2186	struct scatterlist dst_sg[2];
2187	struct scatterlist src_sg[2];	2187	struct scatterlist src_sg[2];
2188	struct mutex *tfm_mutex = NULL;	2188	struct mutex *tfm_mutex = NULL;
2189	u8 cipher_code;	2189	u8 cipher_code;
2190	size_t packet_size_length;	2190	size_t packet_size_length;
2191	size_t max_packet_size;	2191	size_t max_packet_size;
2192	struct ecryptfs_mount_crypt_stat *mount_crypt_stat =	2192	struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
2193	crypt_stat->mount_crypt_stat;	2193	crypt_stat->mount_crypt_stat;
2194	struct blkcipher_desc desc = {	2194	struct blkcipher_desc desc = {
2195	.tfm = NULL,	2195	.tfm = NULL,
2196	.flags = CRYPTO_TFM_REQ_MAY_SLEEP	2196	.flags = CRYPTO_TFM_REQ_MAY_SLEEP
2197	};	2197	};
2198	int rc = 0;	2198	int rc = 0;
2199		2199
2200	(*packet_size) = 0;	2200	(*packet_size) = 0;
2201	ecryptfs_from_hex(key_rec->sig, auth_tok->token.password.signature,	2201	ecryptfs_from_hex(key_rec->sig, auth_tok->token.password.signature,
2202	ECRYPTFS_SIG_SIZE);	2202	ECRYPTFS_SIG_SIZE);
2203	rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(&desc.tfm, &tfm_mutex,	2203	rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(&desc.tfm, &tfm_mutex,
2204	crypt_stat->cipher);	2204	crypt_stat->cipher);
2205	if (unlikely(rc)) {	2205	if (unlikely(rc)) {
2206	printk(KERN_ERR "Internal error whilst attempting to get "	2206	printk(KERN_ERR "Internal error whilst attempting to get "
2207	"tfm and mutex for cipher name [%s]; rc = [%d]\n",	2207	"tfm and mutex for cipher name [%s]; rc = [%d]\n",
2208	crypt_stat->cipher, rc);	2208	crypt_stat->cipher, rc);
2209	goto out;	2209	goto out;
2210	}	2210	}
2211	if (mount_crypt_stat->global_default_cipher_key_size == 0) {	2211	if (mount_crypt_stat->global_default_cipher_key_size == 0) {
2212	struct blkcipher_alg *alg = crypto_blkcipher_alg(desc.tfm);	2212	struct blkcipher_alg *alg = crypto_blkcipher_alg(desc.tfm);
2213		2213
2214	printk(KERN_WARNING "No key size specified at mount; "	2214	printk(KERN_WARNING "No key size specified at mount; "
2215	"defaulting to [%d]\n", alg->max_keysize);	2215	"defaulting to [%d]\n", alg->max_keysize);
2216	mount_crypt_stat->global_default_cipher_key_size =	2216	mount_crypt_stat->global_default_cipher_key_size =
2217	alg->max_keysize;	2217	alg->max_keysize;
2218	}	2218	}
2219	if (crypt_stat->key_size == 0)	2219	if (crypt_stat->key_size == 0)
2220	crypt_stat->key_size =	2220	crypt_stat->key_size =
2221	mount_crypt_stat->global_default_cipher_key_size;	2221	mount_crypt_stat->global_default_cipher_key_size;
2222	if (auth_tok->session_key.encrypted_key_size == 0)	2222	if (auth_tok->session_key.encrypted_key_size == 0)
2223	auth_tok->session_key.encrypted_key_size =	2223	auth_tok->session_key.encrypted_key_size =
2224	crypt_stat->key_size;	2224	crypt_stat->key_size;
2225	if (crypt_stat->key_size == 24	2225	if (crypt_stat->key_size == 24
2226	&& strcmp("aes", crypt_stat->cipher) == 0) {	2226	&& strcmp("aes", crypt_stat->cipher) == 0) {
2227	memset((crypt_stat->key + 24), 0, 8);	2227	memset((crypt_stat->key + 24), 0, 8);
2228	auth_tok->session_key.encrypted_key_size = 32;	2228	auth_tok->session_key.encrypted_key_size = 32;
2229	} else	2229	} else
2230	auth_tok->session_key.encrypted_key_size = crypt_stat->key_size;	2230	auth_tok->session_key.encrypted_key_size = crypt_stat->key_size;
2231	key_rec->enc_key_size =	2231	key_rec->enc_key_size =
2232	auth_tok->session_key.encrypted_key_size;	2232	auth_tok->session_key.encrypted_key_size;
2233	encrypted_session_key_valid = 0;	2233	encrypted_session_key_valid = 0;
2234	for (i = 0; i < auth_tok->session_key.encrypted_key_size; i++)	2234	for (i = 0; i < auth_tok->session_key.encrypted_key_size; i++)
2235	encrypted_session_key_valid \|=	2235	encrypted_session_key_valid \|=
2236	auth_tok->session_key.encrypted_key[i];	2236	auth_tok->session_key.encrypted_key[i];
2237	if (encrypted_session_key_valid) {	2237	if (encrypted_session_key_valid) {
2238	ecryptfs_printk(KERN_DEBUG, "encrypted_session_key_valid != 0; "	2238	ecryptfs_printk(KERN_DEBUG, "encrypted_session_key_valid != 0; "
2239	"using auth_tok->session_key.encrypted_key, "	2239	"using auth_tok->session_key.encrypted_key, "
2240	"where key_rec->enc_key_size = [%zd]\n",	2240	"where key_rec->enc_key_size = [%zd]\n",
2241	key_rec->enc_key_size);	2241	key_rec->enc_key_size);
2242	memcpy(key_rec->enc_key,	2242	memcpy(key_rec->enc_key,
2243	auth_tok->session_key.encrypted_key,	2243	auth_tok->session_key.encrypted_key,
2244	key_rec->enc_key_size);	2244	key_rec->enc_key_size);
2245	goto encrypted_session_key_set;	2245	goto encrypted_session_key_set;
2246	}	2246	}
2247	if (auth_tok->token.password.flags &	2247	if (auth_tok->token.password.flags &
2248	ECRYPTFS_SESSION_KEY_ENCRYPTION_KEY_SET) {	2248	ECRYPTFS_SESSION_KEY_ENCRYPTION_KEY_SET) {
2249	ecryptfs_printk(KERN_DEBUG, "Using previously generated "	2249	ecryptfs_printk(KERN_DEBUG, "Using previously generated "
2250	"session key encryption key of size [%d]\n",	2250	"session key encryption key of size [%d]\n",
2251	auth_tok->token.password.	2251	auth_tok->token.password.
2252	session_key_encryption_key_bytes);	2252	session_key_encryption_key_bytes);
2253	memcpy(session_key_encryption_key,	2253	memcpy(session_key_encryption_key,
2254	auth_tok->token.password.session_key_encryption_key,	2254	auth_tok->token.password.session_key_encryption_key,
2255	crypt_stat->key_size);	2255	crypt_stat->key_size);
2256	ecryptfs_printk(KERN_DEBUG,	2256	ecryptfs_printk(KERN_DEBUG,
2257	"Cached session key encryption key:\n");	2257	"Cached session key encryption key:\n");
2258	if (ecryptfs_verbosity > 0)	2258	if (ecryptfs_verbosity > 0)
2259	ecryptfs_dump_hex(session_key_encryption_key, 16);	2259	ecryptfs_dump_hex(session_key_encryption_key, 16);
2260	}	2260	}
2261	if (unlikely(ecryptfs_verbosity > 0)) {	2261	if (unlikely(ecryptfs_verbosity > 0)) {
2262	ecryptfs_printk(KERN_DEBUG, "Session key encryption key:\n");	2262	ecryptfs_printk(KERN_DEBUG, "Session key encryption key:\n");
2263	ecryptfs_dump_hex(session_key_encryption_key, 16);	2263	ecryptfs_dump_hex(session_key_encryption_key, 16);
2264	}	2264	}
2265	rc = virt_to_scatterlist(crypt_stat->key, key_rec->enc_key_size,	2265	rc = virt_to_scatterlist(crypt_stat->key, key_rec->enc_key_size,
2266	src_sg, 2);	2266	src_sg, 2);
2267	if (rc < 1 \|\| rc > 2) {	2267	if (rc < 1 \|\| rc > 2) {
2268	ecryptfs_printk(KERN_ERR, "Error generating scatterlist "	2268	ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
2269	"for crypt_stat session key; expected rc = 1; "	2269	"for crypt_stat session key; expected rc = 1; "
2270	"got rc = [%d]. key_rec->enc_key_size = [%zd]\n",	2270	"got rc = [%d]. key_rec->enc_key_size = [%zd]\n",
2271	rc, key_rec->enc_key_size);	2271	rc, key_rec->enc_key_size);
2272	rc = -ENOMEM;	2272	rc = -ENOMEM;
2273	goto out;	2273	goto out;
2274	}	2274	}
2275	rc = virt_to_scatterlist(key_rec->enc_key, key_rec->enc_key_size,	2275	rc = virt_to_scatterlist(key_rec->enc_key, key_rec->enc_key_size,
2276	dst_sg, 2);	2276	dst_sg, 2);
2277	if (rc < 1 \|\| rc > 2) {	2277	if (rc < 1 \|\| rc > 2) {
2278	ecryptfs_printk(KERN_ERR, "Error generating scatterlist "	2278	ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
2279	"for crypt_stat encrypted session key; "	2279	"for crypt_stat encrypted session key; "
2280	"expected rc = 1; got rc = [%d]. "	2280	"expected rc = 1; got rc = [%d]. "
2281	"key_rec->enc_key_size = [%zd]\n", rc,	2281	"key_rec->enc_key_size = [%zd]\n", rc,
2282	key_rec->enc_key_size);	2282	key_rec->enc_key_size);
2283	rc = -ENOMEM;	2283	rc = -ENOMEM;
2284	goto out;	2284	goto out;
2285	}	2285	}
2286	mutex_lock(tfm_mutex);	2286	mutex_lock(tfm_mutex);
2287	rc = crypto_blkcipher_setkey(desc.tfm, session_key_encryption_key,	2287	rc = crypto_blkcipher_setkey(desc.tfm, session_key_encryption_key,
2288	crypt_stat->key_size);	2288	crypt_stat->key_size);
2289	if (rc < 0) {	2289	if (rc < 0) {
2290	mutex_unlock(tfm_mutex);	2290	mutex_unlock(tfm_mutex);
2291	ecryptfs_printk(KERN_ERR, "Error setting key for crypto "	2291	ecryptfs_printk(KERN_ERR, "Error setting key for crypto "
2292	"context; rc = [%d]\n", rc);	2292	"context; rc = [%d]\n", rc);
2293	goto out;	2293	goto out;
2294	}	2294	}
2295	rc = 0;	2295	rc = 0;
2296	ecryptfs_printk(KERN_DEBUG, "Encrypting [%zd] bytes of the key\n",	2296	ecryptfs_printk(KERN_DEBUG, "Encrypting [%zd] bytes of the key\n",
2297	crypt_stat->key_size);	2297	crypt_stat->key_size);
2298	rc = crypto_blkcipher_encrypt(&desc, dst_sg, src_sg,	2298	rc = crypto_blkcipher_encrypt(&desc, dst_sg, src_sg,
2299	(*key_rec).enc_key_size);	2299	(*key_rec).enc_key_size);
2300	mutex_unlock(tfm_mutex);	2300	mutex_unlock(tfm_mutex);
2301	if (rc) {	2301	if (rc) {
2302	printk(KERN_ERR "Error encrypting; rc = [%d]\n", rc);	2302	printk(KERN_ERR "Error encrypting; rc = [%d]\n", rc);
2303	goto out;	2303	goto out;
2304	}	2304	}
2305	ecryptfs_printk(KERN_DEBUG, "This should be the encrypted key:\n");	2305	ecryptfs_printk(KERN_DEBUG, "This should be the encrypted key:\n");
2306	if (ecryptfs_verbosity > 0) {	2306	if (ecryptfs_verbosity > 0) {
2307	ecryptfs_printk(KERN_DEBUG, "EFEK of size [%zd]:\n",	2307	ecryptfs_printk(KERN_DEBUG, "EFEK of size [%zd]:\n",
2308	key_rec->enc_key_size);	2308	key_rec->enc_key_size);
2309	ecryptfs_dump_hex(key_rec->enc_key,	2309	ecryptfs_dump_hex(key_rec->enc_key,
2310	key_rec->enc_key_size);	2310	key_rec->enc_key_size);
2311	}	2311	}
2312	encrypted_session_key_set:	2312	encrypted_session_key_set:
2313	/* This format is inspired by OpenPGP; see RFC 2440	2313	/* This format is inspired by OpenPGP; see RFC 2440
2314	* packet tag 3 */	2314	* packet tag 3 */
2315	max_packet_size = (1 /* Tag 3 identifier */	2315	max_packet_size = (1 /* Tag 3 identifier */
2316	+ 3 /* Max Tag 3 packet size */	2316	+ 3 /* Max Tag 3 packet size */
2317	+ 1 /* Version */	2317	+ 1 /* Version */
2318	+ 1 /* Cipher code */	2318	+ 1 /* Cipher code */
2319	+ 1 /* S2K specifier */	2319	+ 1 /* S2K specifier */
2320	+ 1 /* Hash identifier */	2320	+ 1 /* Hash identifier */
2321	+ ECRYPTFS_SALT_SIZE /* Salt */	2321	+ ECRYPTFS_SALT_SIZE /* Salt */
2322	+ 1 /* Hash iterations */	2322	+ 1 /* Hash iterations */
2323	+ key_rec->enc_key_size); /* Encrypted key size */	2323	+ key_rec->enc_key_size); /* Encrypted key size */
2324	if (max_packet_size > (*remaining_bytes)) {	2324	if (max_packet_size > (*remaining_bytes)) {
2325	printk(KERN_ERR "Packet too large; need up to [%td] bytes, but "	2325	printk(KERN_ERR "Packet too large; need up to [%td] bytes, but "
2326	"there are only [%td] available\n", max_packet_size,	2326	"there are only [%td] available\n", max_packet_size,
2327	(*remaining_bytes));	2327	(*remaining_bytes));
2328	rc = -EINVAL;	2328	rc = -EINVAL;
2329	goto out;	2329	goto out;
2330	}	2330	}
2331	dest[(*packet_size)++] = ECRYPTFS_TAG_3_PACKET_TYPE;	2331	dest[(*packet_size)++] = ECRYPTFS_TAG_3_PACKET_TYPE;
2332	/* Chop off the Tag 3 identifier(1) and Tag 3 packet size(3)	2332	/* Chop off the Tag 3 identifier(1) and Tag 3 packet size(3)
2333	* to get the number of octets in the actual Tag 3 packet */	2333	* to get the number of octets in the actual Tag 3 packet */
2334	rc = ecryptfs_write_packet_length(&dest[(*packet_size)],	2334	rc = ecryptfs_write_packet_length(&dest[(*packet_size)],
2335	(max_packet_size - 4),	2335	(max_packet_size - 4),
2336	&packet_size_length);	2336	&packet_size_length);
2337	if (rc) {	2337	if (rc) {
2338	printk(KERN_ERR "Error generating tag 3 packet header; cannot "	2338	printk(KERN_ERR "Error generating tag 3 packet header; cannot "
2339	"generate packet length. rc = [%d]\n", rc);	2339	"generate packet length. rc = [%d]\n", rc);
2340	goto out;	2340	goto out;
2341	}	2341	}
2342	(*packet_size) += packet_size_length;	2342	(*packet_size) += packet_size_length;
2343	dest[(packet_size)++] = 0x04; / version 4 */	2343	dest[(packet_size)++] = 0x04; / version 4 */
2344	/* TODO: Break from RFC2440 so that arbitrary ciphers can be	2344	/* TODO: Break from RFC2440 so that arbitrary ciphers can be
2345	* specified with strings */	2345	* specified with strings */
2346	cipher_code = ecryptfs_code_for_cipher_string(crypt_stat->cipher,	2346	cipher_code = ecryptfs_code_for_cipher_string(crypt_stat->cipher,
2347	crypt_stat->key_size);	2347	crypt_stat->key_size);
2348	if (cipher_code == 0) {	2348	if (cipher_code == 0) {
2349	ecryptfs_printk(KERN_WARNING, "Unable to generate code for "	2349	ecryptfs_printk(KERN_WARNING, "Unable to generate code for "
2350	"cipher [%s]\n", crypt_stat->cipher);	2350	"cipher [%s]\n", crypt_stat->cipher);
2351	rc = -EINVAL;	2351	rc = -EINVAL;
2352	goto out;	2352	goto out;
2353	}	2353	}
2354	dest[(*packet_size)++] = cipher_code;	2354	dest[(*packet_size)++] = cipher_code;
2355	dest[(packet_size)++] = 0x03; / S2K */	2355	dest[(packet_size)++] = 0x03; / S2K */
2356	dest[(packet_size)++] = 0x01; / MD5 (TODO: parameterize) */	2356	dest[(packet_size)++] = 0x01; / MD5 (TODO: parameterize) */
2357	memcpy(&dest[(*packet_size)], auth_tok->token.password.salt,	2357	memcpy(&dest[(*packet_size)], auth_tok->token.password.salt,
2358	ECRYPTFS_SALT_SIZE);	2358	ECRYPTFS_SALT_SIZE);
2359	(packet_size) += ECRYPTFS_SALT_SIZE; / salt */	2359	(packet_size) += ECRYPTFS_SALT_SIZE; / salt */
2360	dest[(packet_size)++] = 0x60; / hash iterations (65536) */	2360	dest[(packet_size)++] = 0x60; / hash iterations (65536) */
2361	memcpy(&dest[(*packet_size)], key_rec->enc_key,	2361	memcpy(&dest[(*packet_size)], key_rec->enc_key,
2362	key_rec->enc_key_size);	2362	key_rec->enc_key_size);
2363	(*packet_size) += key_rec->enc_key_size;	2363	(*packet_size) += key_rec->enc_key_size;
2364	out:	2364	out:
2365	if (rc)	2365	if (rc)
2366	(*packet_size) = 0;	2366	(*packet_size) = 0;
2367	else	2367	else
2368	(remaining_bytes) -= (packet_size);	2368	(remaining_bytes) -= (packet_size);
2369	return rc;	2369	return rc;
2370	}	2370	}
2371		2371
2372	struct kmem_cache *ecryptfs_key_record_cache;	2372	struct kmem_cache *ecryptfs_key_record_cache;
2373		2373
2374	/**	2374	/**
2375	* ecryptfs_generate_key_packet_set	2375	* ecryptfs_generate_key_packet_set
2376	* @dest_base: Virtual address from which to write the key record set	2376	* @dest_base: Virtual address from which to write the key record set
2377	* @crypt_stat: The cryptographic context from which the	2377	* @crypt_stat: The cryptographic context from which the
2378	* authentication tokens will be retrieved	2378	* authentication tokens will be retrieved
2379	* @ecryptfs_dentry: The dentry, used to retrieve the mount crypt stat	2379	* @ecryptfs_dentry: The dentry, used to retrieve the mount crypt stat
2380	* for the global parameters	2380	* for the global parameters
2381	* @len: The amount written	2381	* @len: The amount written
2382	* @max: The maximum amount of data allowed to be written	2382	* @max: The maximum amount of data allowed to be written
2383	*	2383	*
2384	* Generates a key packet set and writes it to the virtual address	2384	* Generates a key packet set and writes it to the virtual address
2385	* passed in.	2385	* passed in.
2386	*	2386	*
2387	* Returns zero on success; non-zero on error.	2387	* Returns zero on success; non-zero on error.
2388	*/	2388	*/
2389	int	2389	int
2390	ecryptfs_generate_key_packet_set(char *dest_base,	2390	ecryptfs_generate_key_packet_set(char *dest_base,
2391	struct ecryptfs_crypt_stat *crypt_stat,	2391	struct ecryptfs_crypt_stat *crypt_stat,
2392	struct dentry ecryptfs_dentry, size_t len,	2392	struct dentry ecryptfs_dentry, size_t len,
2393	size_t max)	2393	size_t max)
2394	{	2394	{
2395	struct ecryptfs_auth_tok *auth_tok;	2395	struct ecryptfs_auth_tok *auth_tok;
2396	struct key *auth_tok_key = NULL;	2396	struct key *auth_tok_key = NULL;
2397	struct ecryptfs_mount_crypt_stat *mount_crypt_stat =	2397	struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
2398	&ecryptfs_superblock_to_private(	2398	&ecryptfs_superblock_to_private(
2399	ecryptfs_dentry->d_sb)->mount_crypt_stat;	2399	ecryptfs_dentry->d_sb)->mount_crypt_stat;
2400	size_t written;	2400	size_t written;
2401	struct ecryptfs_key_record *key_rec;	2401	struct ecryptfs_key_record *key_rec;
2402	struct ecryptfs_key_sig *key_sig;	2402	struct ecryptfs_key_sig *key_sig;
2403	int rc = 0;	2403	int rc = 0;
2404		2404
2405	(*len) = 0;	2405	(*len) = 0;
2406	mutex_lock(&crypt_stat->keysig_list_mutex);	2406	mutex_lock(&crypt_stat->keysig_list_mutex);
2407	key_rec = kmem_cache_alloc(ecryptfs_key_record_cache, GFP_KERNEL);	2407	key_rec = kmem_cache_alloc(ecryptfs_key_record_cache, GFP_KERNEL);
2408	if (!key_rec) {	2408	if (!key_rec) {
2409	rc = -ENOMEM;	2409	rc = -ENOMEM;
2410	goto out;	2410	goto out;
2411	}	2411	}
2412	list_for_each_entry(key_sig, &crypt_stat->keysig_list,	2412	list_for_each_entry(key_sig, &crypt_stat->keysig_list,
2413	crypt_stat_list) {	2413	crypt_stat_list) {
2414	memset(key_rec, 0, sizeof(*key_rec));	2414	memset(key_rec, 0, sizeof(*key_rec));
2415	rc = ecryptfs_find_global_auth_tok_for_sig(&auth_tok_key,	2415	rc = ecryptfs_find_global_auth_tok_for_sig(&auth_tok_key,
2416	&auth_tok,	2416	&auth_tok,
2417	mount_crypt_stat,	2417	mount_crypt_stat,
2418	key_sig->keysig);	2418	key_sig->keysig);
2419	if (rc) {	2419	if (rc) {
2420	printk(KERN_WARNING "Unable to retrieve auth tok with "	2420	printk(KERN_WARNING "Unable to retrieve auth tok with "
2421	"sig = [%s]\n", key_sig->keysig);	2421	"sig = [%s]\n", key_sig->keysig);
2422	rc = process_find_global_auth_tok_for_sig_err(rc);	2422	rc = process_find_global_auth_tok_for_sig_err(rc);
2423	goto out_free;	2423	goto out_free;
2424	}	2424	}
2425	if (auth_tok->token_type == ECRYPTFS_PASSWORD) {	2425	if (auth_tok->token_type == ECRYPTFS_PASSWORD) {
2426	rc = write_tag_3_packet((dest_base + (*len)),	2426	rc = write_tag_3_packet((dest_base + (*len)),
2427	&max, auth_tok,	2427	&max, auth_tok,
2428	crypt_stat, key_rec,	2428	crypt_stat, key_rec,
2429	&written);	2429	&written);
2430	up_write(&(auth_tok_key->sem));	2430	up_write(&(auth_tok_key->sem));
2431	key_put(auth_tok_key);	2431	key_put(auth_tok_key);
2432	if (rc) {	2432	if (rc) {
2433	ecryptfs_printk(KERN_WARNING, "Error "	2433	ecryptfs_printk(KERN_WARNING, "Error "
2434	"writing tag 3 packet\n");	2434	"writing tag 3 packet\n");
2435	goto out_free;	2435	goto out_free;
2436	}	2436	}
2437	(*len) += written;	2437	(*len) += written;
2438	/* Write auth tok signature packet */	2438	/* Write auth tok signature packet */
2439	rc = write_tag_11_packet((dest_base + (*len)), &max,	2439	rc = write_tag_11_packet((dest_base + (*len)), &max,
2440	key_rec->sig,	2440	key_rec->sig,
2441	ECRYPTFS_SIG_SIZE, &written);	2441	ECRYPTFS_SIG_SIZE, &written);
2442	if (rc) {	2442	if (rc) {
2443	ecryptfs_printk(KERN_ERR, "Error writing "	2443	ecryptfs_printk(KERN_ERR, "Error writing "
2444	"auth tok signature packet\n");	2444	"auth tok signature packet\n");
2445	goto out_free;	2445	goto out_free;
2446	}	2446	}
2447	(*len) += written;	2447	(*len) += written;
2448	} else if (auth_tok->token_type == ECRYPTFS_PRIVATE_KEY) {	2448	} else if (auth_tok->token_type == ECRYPTFS_PRIVATE_KEY) {
2449	rc = write_tag_1_packet(dest_base + (*len), &max,	2449	rc = write_tag_1_packet(dest_base + (*len), &max,
2450	auth_tok_key, auth_tok,	2450	auth_tok_key, auth_tok,
2451	crypt_stat, key_rec, &written);	2451	crypt_stat, key_rec, &written);
2452	if (rc) {	2452	if (rc) {
2453	ecryptfs_printk(KERN_WARNING, "Error "	2453	ecryptfs_printk(KERN_WARNING, "Error "
2454	"writing tag 1 packet\n");	2454	"writing tag 1 packet\n");
2455	goto out_free;	2455	goto out_free;
2456	}	2456	}
2457	(*len) += written;	2457	(*len) += written;
2458	} else {	2458	} else {
2459	up_write(&(auth_tok_key->sem));	2459	up_write(&(auth_tok_key->sem));
2460	key_put(auth_tok_key);	2460	key_put(auth_tok_key);
2461	ecryptfs_printk(KERN_WARNING, "Unsupported "	2461	ecryptfs_printk(KERN_WARNING, "Unsupported "
2462	"authentication token type\n");	2462	"authentication token type\n");
2463	rc = -EINVAL;	2463	rc = -EINVAL;
2464	goto out_free;	2464	goto out_free;
2465	}	2465	}
2466	}	2466	}
2467	if (likely(max > 0)) {	2467	if (likely(max > 0)) {
2468	dest_base[(*len)] = 0x00;	2468	dest_base[(*len)] = 0x00;
2469	} else {	2469	} else {
2470	ecryptfs_printk(KERN_ERR, "Error writing boundary byte\n");	2470	ecryptfs_printk(KERN_ERR, "Error writing boundary byte\n");
2471	rc = -EIO;	2471	rc = -EIO;
2472	}	2472	}
2473	out_free:	2473	out_free:
2474	kmem_cache_free(ecryptfs_key_record_cache, key_rec);	2474	kmem_cache_free(ecryptfs_key_record_cache, key_rec);
2475	out:	2475	out:
2476	if (rc)	2476	if (rc)
2477	(*len) = 0;	2477	(*len) = 0;
2478	mutex_unlock(&crypt_stat->keysig_list_mutex);	2478	mutex_unlock(&crypt_stat->keysig_list_mutex);
2479	return rc;	2479	return rc;
2480	}	2480	}
2481		2481
2482	struct kmem_cache *ecryptfs_key_sig_cache;	2482	struct kmem_cache *ecryptfs_key_sig_cache;
2483		2483
2484	int ecryptfs_add_keysig(struct ecryptfs_crypt_stat crypt_stat, char sig)	2484	int ecryptfs_add_keysig(struct ecryptfs_crypt_stat crypt_stat, char sig)
2485	{	2485	{
2486	struct ecryptfs_key_sig *new_key_sig;	2486	struct ecryptfs_key_sig *new_key_sig;
2487		2487
2488	new_key_sig = kmem_cache_alloc(ecryptfs_key_sig_cache, GFP_KERNEL);	2488	new_key_sig = kmem_cache_alloc(ecryptfs_key_sig_cache, GFP_KERNEL);
2489	if (!new_key_sig) {	2489	if (!new_key_sig) {
2490	printk(KERN_ERR	2490	printk(KERN_ERR
2491	"Error allocating from ecryptfs_key_sig_cache\n");	2491	"Error allocating from ecryptfs_key_sig_cache\n");
2492	return -ENOMEM;	2492	return -ENOMEM;
2493	}	2493	}
2494	memcpy(new_key_sig->keysig, sig, ECRYPTFS_SIG_SIZE_HEX);	2494	memcpy(new_key_sig->keysig, sig, ECRYPTFS_SIG_SIZE_HEX);
2495	new_key_sig->keysig[ECRYPTFS_SIG_SIZE_HEX] = '\0';	2495	new_key_sig->keysig[ECRYPTFS_SIG_SIZE_HEX] = '\0';
2496	/* Caller must hold keysig_list_mutex */	2496	/* Caller must hold keysig_list_mutex */
2497	list_add(&new_key_sig->crypt_stat_list, &crypt_stat->keysig_list);	2497	list_add(&new_key_sig->crypt_stat_list, &crypt_stat->keysig_list);
2498		2498
2499	return 0;	2499	return 0;
2500	}	2500	}
2501		2501
2502	struct kmem_cache *ecryptfs_global_auth_tok_cache;	2502	struct kmem_cache *ecryptfs_global_auth_tok_cache;
2503		2503
2504	int	2504	int
2505	ecryptfs_add_global_auth_tok(struct ecryptfs_mount_crypt_stat *mount_crypt_stat,	2505	ecryptfs_add_global_auth_tok(struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
2506	char *sig, u32 global_auth_tok_flags)	2506	char *sig, u32 global_auth_tok_flags)
2507	{	2507	{
2508	struct ecryptfs_global_auth_tok *new_auth_tok;	2508	struct ecryptfs_global_auth_tok *new_auth_tok;
2509	int rc = 0;	2509	int rc = 0;
2510		2510
2511	new_auth_tok = kmem_cache_zalloc(ecryptfs_global_auth_tok_cache,	2511	new_auth_tok = kmem_cache_zalloc(ecryptfs_global_auth_tok_cache,
2512	GFP_KERNEL);	2512	GFP_KERNEL);
2513	if (!new_auth_tok) {	2513	if (!new_auth_tok) {
2514	rc = -ENOMEM;	2514	rc = -ENOMEM;
2515	printk(KERN_ERR "Error allocating from "	2515	printk(KERN_ERR "Error allocating from "
2516	"ecryptfs_global_auth_tok_cache\n");	2516	"ecryptfs_global_auth_tok_cache\n");
2517	goto out;	2517	goto out;
2518	}	2518	}
2519	memcpy(new_auth_tok->sig, sig, ECRYPTFS_SIG_SIZE_HEX);	2519	memcpy(new_auth_tok->sig, sig, ECRYPTFS_SIG_SIZE_HEX);
2520	new_auth_tok->flags = global_auth_tok_flags;	2520	new_auth_tok->flags = global_auth_tok_flags;
2521	new_auth_tok->sig[ECRYPTFS_SIG_SIZE_HEX] = '\0';	2521	new_auth_tok->sig[ECRYPTFS_SIG_SIZE_HEX] = '\0';
2522	mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex);	2522	mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex);
2523	list_add(&new_auth_tok->mount_crypt_stat_list,	2523	list_add(&new_auth_tok->mount_crypt_stat_list,
2524	&mount_crypt_stat->global_auth_tok_list);	2524	&mount_crypt_stat->global_auth_tok_list);
2525	mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex);	2525	mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex);
2526	out:	2526	out:
2527	return rc;	2527	return rc;
2528	}	2528	}
2529		2529
2530		2530

fs/ecryptfs/main.c

Diff comments View file @ 298647e

 /**
  * eCryptfs: Linux filesystem encryption layer
  *
  * Copyright (C) 1997-2003 Erez Zadok
  * Copyright (C) 2001-2003 Stony Brook University
  * Copyright (C) 2004-2007 International Business Machines Corp.
  *   Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
  *              Michael C. Thompson <mcthomps@us.ibm.com>
  *              Tyler Hicks <tyhicks@ou.edu>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  * 02111-1307, USA.
  */
 #include <linux/dcache.h>
 #include <linux/file.h>
 #include <linux/module.h>
 #include <linux/namei.h>
 #include <linux/skbuff.h>
 #include <linux/crypto.h>
 #include <linux/mount.h>
 #include <linux/pagemap.h>
 #include <linux/key.h>
 #include <linux/parser.h>
 #include <linux/fs_stack.h>
 #include <linux/slab.h>
 #include <linux/magic.h>
 #include "ecryptfs_kernel.h"
 /**
  * Module parameter that defines the ecryptfs_verbosity level.
  */
 int ecryptfs_verbosity = 0;
 module_param(ecryptfs_verbosity, int, 0);
 MODULE_PARM_DESC(ecryptfs_verbosity,
 		 "Initial verbosity level (0 or 1; defaults to "
 		 "0, which is Quiet)");
 /**
  * Module parameter that defines the number of message buffer elements
  */
 unsigned int ecryptfs_message_buf_len = ECRYPTFS_DEFAULT_MSG_CTX_ELEMS;
 module_param(ecryptfs_message_buf_len, uint, 0);
 MODULE_PARM_DESC(ecryptfs_message_buf_len,
 		 "Number of message buffer elements");
 /**
  * Module parameter that defines the maximum guaranteed amount of time to wait
  * for a response from ecryptfsd.  The actual sleep time will be, more than
  * likely, a small amount greater than this specified value, but only less if
  * the message successfully arrives.
  */
 signed long ecryptfs_message_wait_timeout = ECRYPTFS_MAX_MSG_CTX_TTL / HZ;
 module_param(ecryptfs_message_wait_timeout, long, 0);
 MODULE_PARM_DESC(ecryptfs_message_wait_timeout,
 		 "Maximum number of seconds that an operation will "
 		 "sleep while waiting for a message response from "
 		 "userspace");
 /**
  * Module parameter that is an estimate of the maximum number of users
  * that will be concurrently using eCryptfs. Set this to the right
  * value to balance performance and memory use.
  */
 unsigned int ecryptfs_number_of_users = ECRYPTFS_DEFAULT_NUM_USERS;
 module_param(ecryptfs_number_of_users, uint, 0);
 MODULE_PARM_DESC(ecryptfs_number_of_users, "An estimate of the number of "
 		 "concurrent users of eCryptfs");
 void __ecryptfs_printk(const char *fmt, ...)
 {
 	va_list args;
 	va_start(args, fmt);
 	if (fmt[1] == '7') { /* KERN_DEBUG */
 		if (ecryptfs_verbosity >= 1)
 			vprintk(fmt, args);
 	} else
 		vprintk(fmt, args);
 	va_end(args);
 }
 /**
  * ecryptfs_init_lower_file
  * @ecryptfs_dentry: Fully initialized eCryptfs dentry object, with
  *                   the lower dentry and the lower mount set
  *
  * eCryptfs only ever keeps a single open file for every lower
  * inode. All I/O operations to the lower inode occur through that
  * file. When the first eCryptfs dentry that interposes with the first
  * lower dentry for that inode is created, this function creates the
  * lower file struct and associates it with the eCryptfs
  * inode. When all eCryptfs files associated with the inode are released, the
  * file is closed.
  *
  * The lower file will be opened with read/write permissions, if
  * possible. Otherwise, it is opened read-only.
  *
  * This function does nothing if a lower file is already
  * associated with the eCryptfs inode.
  *
  * Returns zero on success; non-zero otherwise
  */
 static int ecryptfs_init_lower_file(struct dentry *dentry,
 				    struct file **lower_file)
 {
 	const struct cred *cred = current_cred();
 	struct path *path = ecryptfs_dentry_to_lower_path(dentry);
 	int rc;
 	rc = ecryptfs_privileged_open(lower_file, path->dentry, path->mnt,
 				      cred);
 	if (rc) {
 		printk(KERN_ERR "Error opening lower file "
 		       "for lower_dentry [0x%p] and lower_mnt [0x%p]; "
 		       "rc = [%d]\n", path->dentry, path->mnt, rc);
 		(*lower_file) = NULL;
 	}
 	return rc;
 }
 int ecryptfs_get_lower_file(struct dentry *dentry, struct inode *inode)
 {
 	struct ecryptfs_inode_info *inode_info;
 	int count, rc = 0;
 	inode_info = ecryptfs_inode_to_private(inode);
 	mutex_lock(&inode_info->lower_file_mutex);
 	count = atomic_inc_return(&inode_info->lower_file_count);
 	if (WARN_ON_ONCE(count < 1))
 		rc = -EINVAL;
 	else if (count == 1) {
 		rc = ecryptfs_init_lower_file(dentry,
 					      &inode_info->lower_file);
 		if (rc)
 			atomic_set(&inode_info->lower_file_count, 0);
 	}
 	mutex_unlock(&inode_info->lower_file_mutex);
 	return rc;
 }
 void ecryptfs_put_lower_file(struct inode *inode)
 {
 	struct ecryptfs_inode_info *inode_info;
 	inode_info = ecryptfs_inode_to_private(inode);
 	if (atomic_dec_and_mutex_lock(&inode_info->lower_file_count,
 				      &inode_info->lower_file_mutex)) {
 		filemap_write_and_wait(inode->i_mapping);
 		fput(inode_info->lower_file);
 		inode_info->lower_file = NULL;
 		mutex_unlock(&inode_info->lower_file_mutex);
 	}
 }
 enum { ecryptfs_opt_sig, ecryptfs_opt_ecryptfs_sig,
        ecryptfs_opt_cipher, ecryptfs_opt_ecryptfs_cipher,
        ecryptfs_opt_ecryptfs_key_bytes,
        ecryptfs_opt_passthrough, ecryptfs_opt_xattr_metadata,
        ecryptfs_opt_encrypted_view, ecryptfs_opt_fnek_sig,
        ecryptfs_opt_fn_cipher, ecryptfs_opt_fn_cipher_key_bytes,
        ecryptfs_opt_unlink_sigs, ecryptfs_opt_mount_auth_tok_only,
        ecryptfs_opt_check_dev_ruid,
        ecryptfs_opt_err };
 static const match_table_t tokens = {
 	{ecryptfs_opt_sig, "sig=%s"},
 	{ecryptfs_opt_ecryptfs_sig, "ecryptfs_sig=%s"},
 	{ecryptfs_opt_cipher, "cipher=%s"},
 	{ecryptfs_opt_ecryptfs_cipher, "ecryptfs_cipher=%s"},
 	{ecryptfs_opt_ecryptfs_key_bytes, "ecryptfs_key_bytes=%u"},
 	{ecryptfs_opt_passthrough, "ecryptfs_passthrough"},
 	{ecryptfs_opt_xattr_metadata, "ecryptfs_xattr_metadata"},
 	{ecryptfs_opt_encrypted_view, "ecryptfs_encrypted_view"},
 	{ecryptfs_opt_fnek_sig, "ecryptfs_fnek_sig=%s"},
 	{ecryptfs_opt_fn_cipher, "ecryptfs_fn_cipher=%s"},
 	{ecryptfs_opt_fn_cipher_key_bytes, "ecryptfs_fn_key_bytes=%u"},
 	{ecryptfs_opt_unlink_sigs, "ecryptfs_unlink_sigs"},
 	{ecryptfs_opt_mount_auth_tok_only, "ecryptfs_mount_auth_tok_only"},
 	{ecryptfs_opt_check_dev_ruid, "ecryptfs_check_dev_ruid"},
 	{ecryptfs_opt_err, NULL}
 };
 static int ecryptfs_init_global_auth_toks(
 	struct ecryptfs_mount_crypt_stat *mount_crypt_stat)
 {
 	struct ecryptfs_global_auth_tok *global_auth_tok;
 	struct ecryptfs_auth_tok *auth_tok;
 	int rc = 0;
 	list_for_each_entry(global_auth_tok,
 			    &mount_crypt_stat->global_auth_tok_list,
 			    mount_crypt_stat_list) {
 		rc = ecryptfs_keyring_auth_tok_for_sig(
 			&global_auth_tok->global_auth_tok_key, &auth_tok,
 			global_auth_tok->sig);
 		if (rc) {
 			printk(KERN_ERR "Could not find valid key in user "
 			       "session keyring for sig specified in mount "
 			       "option: [%s]\n", global_auth_tok->sig);
 			global_auth_tok->flags |= ECRYPTFS_AUTH_TOK_INVALID;
 			goto out;
 		} else {
 			global_auth_tok->flags &= ~ECRYPTFS_AUTH_TOK_INVALID;
 			up_write(&(global_auth_tok->global_auth_tok_key)->sem);
 		}
 	}
 out:
 	return rc;
 }
 static void ecryptfs_init_mount_crypt_stat(
 	struct ecryptfs_mount_crypt_stat *mount_crypt_stat)
 {
 	memset((void *)mount_crypt_stat, 0,
 	       sizeof(struct ecryptfs_mount_crypt_stat));
 	INIT_LIST_HEAD(&mount_crypt_stat->global_auth_tok_list);
 	mutex_init(&mount_crypt_stat->global_auth_tok_list_mutex);
 	mount_crypt_stat->flags |= ECRYPTFS_MOUNT_CRYPT_STAT_INITIALIZED;
 }
 /**
  * ecryptfs_parse_options
  * @sb: The ecryptfs super block
  * @options: The options passed to the kernel
  * @check_ruid: set to 1 if device uid should be checked against the ruid
  *
  * Parse mount options:
  * debug=N 	   - ecryptfs_verbosity level for debug output
  * sig=XXX	   - description(signature) of the key to use
  *
  * Returns the dentry object of the lower-level (lower/interposed)
  * directory; We want to mount our stackable file system on top of
  * that lower directory.
  *
  * The signature of the key to use must be the description of a key
  * already in the keyring. Mounting will fail if the key can not be
  * found.
  *
  * Returns zero on success; non-zero on error
  */
 static int ecryptfs_parse_options(struct ecryptfs_sb_info *sbi, char *options,
 				  uid_t *check_ruid)
 {
 	char *p;
 	int rc = 0;
 	int sig_set = 0;
 	int cipher_name_set = 0;
 	int fn_cipher_name_set = 0;
 	int cipher_key_bytes;
 	int cipher_key_bytes_set = 0;
 	int fn_cipher_key_bytes;
 	int fn_cipher_key_bytes_set = 0;
 	struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
 		&sbi->mount_crypt_stat;
 	substring_t args[MAX_OPT_ARGS];
 	int token;
 	char *sig_src;
 	char *cipher_name_dst;
 	char *cipher_name_src;
 	char *fn_cipher_name_dst;
 	char *fn_cipher_name_src;
 	char *fnek_dst;
 	char *fnek_src;
 	char *cipher_key_bytes_src;
 	char *fn_cipher_key_bytes_src;
 	u8 cipher_code;
 	*check_ruid = 0;
 	if (!options) {
 		rc = -EINVAL;
 		goto out;
 	}
 	ecryptfs_init_mount_crypt_stat(mount_crypt_stat);
 	while ((p = strsep(&options, ",")) != NULL) {
 		if (!*p)
 			continue;
 		token = match_token(p, tokens, args);
 		switch (token) {
 		case ecryptfs_opt_sig:
 		case ecryptfs_opt_ecryptfs_sig:
 			sig_src = args[0].from;
 			rc = ecryptfs_add_global_auth_tok(mount_crypt_stat,
 							  sig_src, 0);
 			if (rc) {
 				printk(KERN_ERR "Error attempting to register "
 				       "global sig; rc = [%d]\n", rc);
 				goto out;
 			}
 			sig_set = 1;
 			break;
 		case ecryptfs_opt_cipher:
 		case ecryptfs_opt_ecryptfs_cipher:
 			cipher_name_src = args[0].from;
 			cipher_name_dst =
 				mount_crypt_stat->
 				global_default_cipher_name;
 			strncpy(cipher_name_dst, cipher_name_src,
 				ECRYPTFS_MAX_CIPHER_NAME_SIZE);
 			cipher_name_dst[ECRYPTFS_MAX_CIPHER_NAME_SIZE] = '\0';
 			cipher_name_set = 1;
 			break;
 		case ecryptfs_opt_ecryptfs_key_bytes:
 			cipher_key_bytes_src = args[0].from;
 			cipher_key_bytes =
 				(int)simple_strtol(cipher_key_bytes_src,
 						   &cipher_key_bytes_src, 0);
 			mount_crypt_stat->global_default_cipher_key_size =
 				cipher_key_bytes;
 			cipher_key_bytes_set = 1;
 			break;
 		case ecryptfs_opt_passthrough:
 			mount_crypt_stat->flags |=
 				ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED;
 			break;
 		case ecryptfs_opt_xattr_metadata:
 			mount_crypt_stat->flags |=
 				ECRYPTFS_XATTR_METADATA_ENABLED;
 			break;
 		case ecryptfs_opt_encrypted_view:
 			mount_crypt_stat->flags |=
 				ECRYPTFS_XATTR_METADATA_ENABLED;
 			mount_crypt_stat->flags |=
 				ECRYPTFS_ENCRYPTED_VIEW_ENABLED;
 			break;
 		case ecryptfs_opt_fnek_sig:
 			fnek_src = args[0].from;
 			fnek_dst =
 				mount_crypt_stat->global_default_fnek_sig;
 			strncpy(fnek_dst, fnek_src, ECRYPTFS_SIG_SIZE_HEX);
 			mount_crypt_stat->global_default_fnek_sig[
 				ECRYPTFS_SIG_SIZE_HEX] = '\0';
 			rc = ecryptfs_add_global_auth_tok(
 				mount_crypt_stat,
 				mount_crypt_stat->global_default_fnek_sig,
 				ECRYPTFS_AUTH_TOK_FNEK);
 			if (rc) {
 				printk(KERN_ERR "Error attempting to register "
 				       "global fnek sig [%s]; rc = [%d]\n",
 				       mount_crypt_stat->global_default_fnek_sig,
 				       rc);
 				goto out;
 			}
 			mount_crypt_stat->flags |=
 				(ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES
 				 | ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK);
 			break;
 		case ecryptfs_opt_fn_cipher:
 			fn_cipher_name_src = args[0].from;
 			fn_cipher_name_dst =
 				mount_crypt_stat->global_default_fn_cipher_name;
 			strncpy(fn_cipher_name_dst, fn_cipher_name_src,
 				ECRYPTFS_MAX_CIPHER_NAME_SIZE);
 			mount_crypt_stat->global_default_fn_cipher_name[
 				ECRYPTFS_MAX_CIPHER_NAME_SIZE] = '\0';
 			fn_cipher_name_set = 1;
 			break;
 		case ecryptfs_opt_fn_cipher_key_bytes:
 			fn_cipher_key_bytes_src = args[0].from;
 			fn_cipher_key_bytes =
 				(int)simple_strtol(fn_cipher_key_bytes_src,
 						   &fn_cipher_key_bytes_src, 0);
 			mount_crypt_stat->global_default_fn_cipher_key_bytes =
 				fn_cipher_key_bytes;
 			fn_cipher_key_bytes_set = 1;
 			break;
 		case ecryptfs_opt_unlink_sigs:
 			mount_crypt_stat->flags |= ECRYPTFS_UNLINK_SIGS;
 			break;
 		case ecryptfs_opt_mount_auth_tok_only:
 			mount_crypt_stat->flags |=
 				ECRYPTFS_GLOBAL_MOUNT_AUTH_TOK_ONLY;
 			break;
 		case ecryptfs_opt_check_dev_ruid:
 			*check_ruid = 1;
 			break;
 		case ecryptfs_opt_err:
 		default:
 			printk(KERN_WARNING
 			       "%s: eCryptfs: unrecognized option [%s]\n",
 			       __func__, p);
 		}
 	}
 	if (!sig_set) {
 		rc = -EINVAL;
 		ecryptfs_printk(KERN_ERR, "You must supply at least one valid "
 				"auth tok signature as a mount "
 				"parameter; see the eCryptfs README\n");
 		goto out;
 	}
 	if (!cipher_name_set) {
 		int cipher_name_len = strlen(ECRYPTFS_DEFAULT_CIPHER);
 		BUG_ON(cipher_name_len >= ECRYPTFS_MAX_CIPHER_NAME_SIZE);
 		strcpy(mount_crypt_stat->global_default_cipher_name,
 		       ECRYPTFS_DEFAULT_CIPHER);
 	}
 	if ((mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES)
 	    && !fn_cipher_name_set)
 		strcpy(mount_crypt_stat->global_default_fn_cipher_name,
 		       mount_crypt_stat->global_default_cipher_name);
 	if (!cipher_key_bytes_set)
 		mount_crypt_stat->global_default_cipher_key_size = 0;
 	if ((mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES)
 	    && !fn_cipher_key_bytes_set)
 		mount_crypt_stat->global_default_fn_cipher_key_bytes =
 			mount_crypt_stat->global_default_cipher_key_size;
 	cipher_code = ecryptfs_code_for_cipher_string(
 		mount_crypt_stat->global_default_cipher_name,
 		mount_crypt_stat->global_default_cipher_key_size);
 	if (!cipher_code) {
 		ecryptfs_printk(KERN_ERR,
 				"eCryptfs doesn't support cipher: %s",
 				mount_crypt_stat->global_default_cipher_name);
 		rc = -EINVAL;
 		goto out;
 	}
 	mutex_lock(&key_tfm_list_mutex);
 	if (!ecryptfs_tfm_exists(mount_crypt_stat->global_default_cipher_name,
 				 NULL)) {
 		rc = ecryptfs_add_new_key_tfm(
 			NULL, mount_crypt_stat->global_default_cipher_name,
 			mount_crypt_stat->global_default_cipher_key_size);
 		if (rc) {
 			printk(KERN_ERR "Error attempting to initialize "
 			       "cipher with name = [%s] and key size = [%td]; "
 			       "rc = [%d]\n",
 			       mount_crypt_stat->global_default_cipher_name,
 			       mount_crypt_stat->global_default_cipher_key_size,
 			       rc);
 			rc = -EINVAL;
 			mutex_unlock(&key_tfm_list_mutex);
 			goto out;
 		}
 	}
 	if ((mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES)
 	    && !ecryptfs_tfm_exists(
 		    mount_crypt_stat->global_default_fn_cipher_name, NULL)) {
 		rc = ecryptfs_add_new_key_tfm(
 			NULL, mount_crypt_stat->global_default_fn_cipher_name,
 			mount_crypt_stat->global_default_fn_cipher_key_bytes);
 		if (rc) {
 			printk(KERN_ERR "Error attempting to initialize "
 			       "cipher with name = [%s] and key size = [%td]; "
 			       "rc = [%d]\n",
 			       mount_crypt_stat->global_default_fn_cipher_name,
 			       mount_crypt_stat->global_default_fn_cipher_key_bytes,
 			       rc);
 			rc = -EINVAL;
 			mutex_unlock(&key_tfm_list_mutex);
 			goto out;
 		}
 	}
 	mutex_unlock(&key_tfm_list_mutex);
 	rc = ecryptfs_init_global_auth_toks(mount_crypt_stat);
 	if (rc)
 		printk(KERN_WARNING "One or more global auth toks could not "
 		       "properly register; rc = [%d]\n", rc);
 out:
 	return rc;
 }
 struct kmem_cache *ecryptfs_sb_info_cache;
 static struct file_system_type ecryptfs_fs_type;
 /**
  * ecryptfs_get_sb
  * @fs_type
  * @flags
  * @dev_name: The path to mount over
  * @raw_data: The options passed into the kernel
  */
 static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags,
 			const char *dev_name, void *raw_data)
 {
 	struct super_block *s;
 	struct ecryptfs_sb_info *sbi;
+	struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
 	struct ecryptfs_dentry_info *root_info;
 	const char *err = "Getting sb failed";
 	struct inode *inode;
 	struct path path;
 	uid_t check_ruid;
 	int rc;
 	sbi = kmem_cache_zalloc(ecryptfs_sb_info_cache, GFP_KERNEL);
 	if (!sbi) {
 		rc = -ENOMEM;
 		goto out;
 	}
 	rc = ecryptfs_parse_options(sbi, raw_data, &check_ruid);
 	if (rc) {
 		err = "Error parsing options";
 		goto out;
 	}
+	mount_crypt_stat = &sbi->mount_crypt_stat;
 	s = sget(fs_type, NULL, set_anon_super, flags, NULL);
 	if (IS_ERR(s)) {
 		rc = PTR_ERR(s);
 		goto out;
 	}
 	rc = bdi_setup_and_register(&sbi->bdi, "ecryptfs", BDI_CAP_MAP_COPY);
 	if (rc)
 		goto out1;
 	ecryptfs_set_superblock_private(s, sbi);
 	s->s_bdi = &sbi->bdi;
 	/* ->kill_sb() will take care of sbi after that point */
 	sbi = NULL;
 	s->s_op = &ecryptfs_sops;
 	s->s_d_op = &ecryptfs_dops;
 	err = "Reading sb failed";
 	rc = kern_path(dev_name, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path);
 	if (rc) {
 		ecryptfs_printk(KERN_WARNING, "kern_path() failed\n");
 		goto out1;
 	}
 	if (path.dentry->d_sb->s_type == &ecryptfs_fs_type) {
 		rc = -EINVAL;
 		printk(KERN_ERR "Mount on filesystem of type "
 			"eCryptfs explicitly disallowed due to "
 			"known incompatibilities\n");
 		goto out_free;
 	}
 	if (check_ruid && !uid_eq(path.dentry->d_inode->i_uid, current_uid())) {
 		rc = -EPERM;
 		printk(KERN_ERR "Mount of device (uid: %d) not owned by "
 		       "requested user (uid: %d)\n",
 			i_uid_read(path.dentry->d_inode),
 			from_kuid(&init_user_ns, current_uid()));
 		goto out_free;
 	}
 	ecryptfs_set_superblock_lower(s, path.dentry->d_sb);
 	/**
 	 * Set the POSIX ACL flag based on whether they're enabled in the lower
-	 * mount. Force a read-only eCryptfs mount if the lower mount is ro.
+	 * mount.
-	 * Allow a ro eCryptfs mount even when the lower mount is rw.
 	 */
 	s->s_flags = flags & ~MS_POSIXACL;
-	s->s_flags |= path.dentry->d_sb->s_flags & (MS_RDONLY | MS_POSIXACL);
+	s->s_flags |= path.dentry->d_sb->s_flags & MS_POSIXACL;
+	/**
+	 * Force a read-only eCryptfs mount when:
+	 *   1) The lower mount is ro
+	 *   2) The ecryptfs_encrypted_view mount option is specified
+	 */
+	if (path.dentry->d_sb->s_flags & MS_RDONLY ||
+	    mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED)
+		s->s_flags |= MS_RDONLY;
 	s->s_maxbytes = path.dentry->d_sb->s_maxbytes;
 	s->s_blocksize = path.dentry->d_sb->s_blocksize;
 	s->s_magic = ECRYPTFS_SUPER_MAGIC;
 	s->s_stack_depth = path.dentry->d_sb->s_stack_depth + 1;
 	rc = -EINVAL;
 	if (s->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) {
 		pr_err("eCryptfs: maximum fs stacking depth exceeded\n");
 		goto out_free;
 	}
 	inode = ecryptfs_get_inode(path.dentry->d_inode, s);
 	rc = PTR_ERR(inode);
 	if (IS_ERR(inode))
 		goto out_free;
 	s->s_root = d_make_root(inode);
 	if (!s->s_root) {
 		rc = -ENOMEM;
 		goto out_free;
 	}
 	rc = -ENOMEM;
 	root_info = kmem_cache_zalloc(ecryptfs_dentry_info_cache, GFP_KERNEL);
 	if (!root_info)
 		goto out_free;
 	/* ->kill_sb() will take care of root_info */
 	ecryptfs_set_dentry_private(s->s_root, root_info);
 	root_info->lower_path = path;
 	s->s_flags |= MS_ACTIVE;
 	return dget(s->s_root);
 out_free:
 	path_put(&path);
 out1:
 	deactivate_locked_super(s);
 out:
 	if (sbi) {
 		ecryptfs_destroy_mount_crypt_stat(&sbi->mount_crypt_stat);
 		kmem_cache_free(ecryptfs_sb_info_cache, sbi);
 	}
 	printk(KERN_ERR "%s; rc = [%d]\n", err, rc);
 	return ERR_PTR(rc);
 }
 /**
  * ecryptfs_kill_block_super
  * @sb: The ecryptfs super block
  *
  * Used to bring the superblock down and free the private data.
  */
 static void ecryptfs_kill_block_super(struct super_block *sb)
 {
 	struct ecryptfs_sb_info *sb_info = ecryptfs_superblock_to_private(sb);
 	kill_anon_super(sb);
 	if (!sb_info)
 		return;
 	ecryptfs_destroy_mount_crypt_stat(&sb_info->mount_crypt_stat);
 	bdi_destroy(&sb_info->bdi);
 	kmem_cache_free(ecryptfs_sb_info_cache, sb_info);
 }
 static struct file_system_type ecryptfs_fs_type = {
 	.owner = THIS_MODULE,
 	.name = "ecryptfs",
 	.mount = ecryptfs_mount,
 	.kill_sb = ecryptfs_kill_block_super,
 	.fs_flags = 0
 };
 MODULE_ALIAS_FS("ecryptfs");
 /**
  * inode_info_init_once
  *
  * Initializes the ecryptfs_inode_info_cache when it is created
  */
 static void
 inode_info_init_once(void *vptr)
 {
 	struct ecryptfs_inode_info *ei = (struct ecryptfs_inode_info *)vptr;
 	inode_init_once(&ei->vfs_inode);
 }
 static struct ecryptfs_cache_info {
 	struct kmem_cache **cache;
 	const char *name;
 	size_t size;
 	void (*ctor)(void *obj);
 } ecryptfs_cache_infos[] = {
 	{
 		.cache = &ecryptfs_auth_tok_list_item_cache,
 		.name = "ecryptfs_auth_tok_list_item",
 		.size = sizeof(struct ecryptfs_auth_tok_list_item),
 	},
 	{
 		.cache = &ecryptfs_file_info_cache,
 		.name = "ecryptfs_file_cache",
 		.size = sizeof(struct ecryptfs_file_info),
 	},
 	{
 		.cache = &ecryptfs_dentry_info_cache,
 		.name = "ecryptfs_dentry_info_cache",
 		.size = sizeof(struct ecryptfs_dentry_info),
 	},
 	{
 		.cache = &ecryptfs_inode_info_cache,
 		.name = "ecryptfs_inode_cache",
 		.size = sizeof(struct ecryptfs_inode_info),
 		.ctor = inode_info_init_once,
 	},
 	{
 		.cache = &ecryptfs_sb_info_cache,
 		.name = "ecryptfs_sb_cache",
 		.size = sizeof(struct ecryptfs_sb_info),
 	},
 	{
 		.cache = &ecryptfs_header_cache,
 		.name = "ecryptfs_headers",
 		.size = PAGE_CACHE_SIZE,
 	},
 	{
 		.cache = &ecryptfs_xattr_cache,
 		.name = "ecryptfs_xattr_cache",
 		.size = PAGE_CACHE_SIZE,
 	},
 	{
 		.cache = &ecryptfs_key_record_cache,
 		.name = "ecryptfs_key_record_cache",
 		.size = sizeof(struct ecryptfs_key_record),
 	},
 	{
 		.cache = &ecryptfs_key_sig_cache,
 		.name = "ecryptfs_key_sig_cache",
 		.size = sizeof(struct ecryptfs_key_sig),
 	},
 	{
 		.cache = &ecryptfs_global_auth_tok_cache,
 		.name = "ecryptfs_global_auth_tok_cache",
 		.size = sizeof(struct ecryptfs_global_auth_tok),
 	},
 	{
 		.cache = &ecryptfs_key_tfm_cache,
 		.name = "ecryptfs_key_tfm_cache",
 		.size = sizeof(struct ecryptfs_key_tfm),
 	},
 };
 static void ecryptfs_free_kmem_caches(void)
 {
 	int i;
 	/*
 	 * Make sure all delayed rcu free inodes are flushed before we
 	 * destroy cache.
 	 */
 	rcu_barrier();
 	for (i = 0; i < ARRAY_SIZE(ecryptfs_cache_infos); i++) {
 		struct ecryptfs_cache_info *info;
 		info = &ecryptfs_cache_infos[i];
 		if (*(info->cache))
 			kmem_cache_destroy(*(info->cache));
 	}
 }
 /**
  * ecryptfs_init_kmem_caches
  *
  * Returns zero on success; non-zero otherwise
  */
 static int ecryptfs_init_kmem_caches(void)
 {
 	int i;
 	for (i = 0; i < ARRAY_SIZE(ecryptfs_cache_infos); i++) {
 		struct ecryptfs_cache_info *info;
 		info = &ecryptfs_cache_infos[i];
 		*(info->cache) = kmem_cache_create(info->name, info->size,
 				0, SLAB_HWCACHE_ALIGN, info->ctor);
 		if (!*(info->cache)) {
 			ecryptfs_free_kmem_caches();
 			ecryptfs_printk(KERN_WARNING, "%s: "
 					"kmem_cache_create failed\n",
 					info->name);
 			return -ENOMEM;
 		}
 	}
 	return 0;
 }
 static struct kobject *ecryptfs_kobj;
 static ssize_t version_show(struct kobject *kobj,
 			    struct kobj_attribute *attr, char *buff)
 {
 	return snprintf(buff, PAGE_SIZE, "%d\n", ECRYPTFS_VERSIONING_MASK);
 }
 static struct kobj_attribute version_attr = __ATTR_RO(version);
 static struct attribute *attributes[] = {
 	&version_attr.attr,
 	NULL,
 };
 static struct attribute_group attr_group = {
 	.attrs = attributes,
 };
 static int do_sysfs_registration(void)
 {
 	int rc;
 	ecryptfs_kobj = kobject_create_and_add("ecryptfs", fs_kobj);
 	if (!ecryptfs_kobj) {
 		printk(KERN_ERR "Unable to create ecryptfs kset\n");
 		rc = -ENOMEM;
 		goto out;
 	}
 	rc = sysfs_create_group(ecryptfs_kobj, &attr_group);
 	if (rc) {
 		printk(KERN_ERR
 		       "Unable to create ecryptfs version attributes\n");
 		kobject_put(ecryptfs_kobj);
 	}
 out:
 	return rc;
 }
 static void do_sysfs_unregistration(void)
 {
 	sysfs_remove_group(ecryptfs_kobj, &attr_group);
 	kobject_put(ecryptfs_kobj);
 }
 static int __init ecryptfs_init(void)
 {
 	int rc;
 	if (ECRYPTFS_DEFAULT_EXTENT_SIZE > PAGE_CACHE_SIZE) {
 		rc = -EINVAL;
 		ecryptfs_printk(KERN_ERR, "The eCryptfs extent size is "
 				"larger than the host's page size, and so "
 				"eCryptfs cannot run on this system. The "
 				"default eCryptfs extent size is [%u] bytes; "
 				"the page size is [%lu] bytes.\n",
 				ECRYPTFS_DEFAULT_EXTENT_SIZE,
 				(unsigned long)PAGE_CACHE_SIZE);
 		goto out;
 	}
 	rc = ecryptfs_init_kmem_caches();
 	if (rc) {
 		printk(KERN_ERR
 		       "Failed to allocate one or more kmem_cache objects\n");
 		goto out;
 	}
 	rc = do_sysfs_registration();
 	if (rc) {
 		printk(KERN_ERR "sysfs registration failed\n");
 		goto out_free_kmem_caches;
 	}
 	rc = ecryptfs_init_kthread();
 	if (rc) {
 		printk(KERN_ERR "%s: kthread initialization failed; "
 		       "rc = [%d]\n", __func__, rc);
 		goto out_do_sysfs_unregistration;
 	}
 	rc = ecryptfs_init_messaging();
 	if (rc) {
 		printk(KERN_ERR "Failure occurred while attempting to "
 				"initialize the communications channel to "
 				"ecryptfsd\n");
 		goto out_destroy_kthread;
 	}
 	rc = ecryptfs_init_crypto();
 	if (rc) {
 		printk(KERN_ERR "Failure whilst attempting to init crypto; "
 		       "rc = [%d]\n", rc);
 		goto out_release_messaging;
 	}
 	rc = register_filesystem(&ecryptfs_fs_type);
 	if (rc) {
 		printk(KERN_ERR "Failed to register filesystem\n");
 		goto out_destroy_crypto;
 	}
 	if (ecryptfs_verbosity > 0)
 		printk(KERN_CRIT "eCryptfs verbosity set to %d. Secret values "
 			"will be written to the syslog!\n", ecryptfs_verbosity);
 	goto out;
 out_destroy_crypto:
 	ecryptfs_destroy_crypto();
 out_release_messaging:
 	ecryptfs_release_messaging();
 out_destroy_kthread:
 	ecryptfs_destroy_kthread();
 out_do_sysfs_unregistration:
 	do_sysfs_unregistration();
 out_free_kmem_caches:
 	ecryptfs_free_kmem_caches();
 out:
 	return rc;
 }
 static void __exit ecryptfs_exit(void)
 {
 	int rc;
 	rc = ecryptfs_destroy_crypto();
 	if (rc)
 		printk(KERN_ERR "Failure whilst attempting to destroy crypto; "
 		       "rc = [%d]\n", rc);
 	ecryptfs_release_messaging();
 	ecryptfs_destroy_kthread();
 	do_sysfs_unregistration();
 	unregister_filesystem(&ecryptfs_fs_type);
 	ecryptfs_free_kmem_caches();
 }
 MODULE_AUTHOR("Michael A. Halcrow <mhalcrow@us.ibm.com>");
 MODULE_DESCRIPTION("eCryptfs");
 MODULE_LICENSE("GPL");
 module_init(ecryptfs_init)
 module_exit(ecryptfs_exit)