Re: [PATCH v1] eCryptfs: enhancing eCryptfs to be used with external crypto engine

From: Tyler Hicks
Date: Tue Nov 10 2015 - 17:18:20 EST

Next message: Dan Williams: "Re: [PATCH 1/4] nvdimm: Add wrapper for IOCTL pass thru."
Previous message: Joe Perches: "Re: [PATCH] video: constify geode ops structures"
In reply to: andreym: "Re: [PATCH v1] eCryptfs: enhancing eCryptfs to be used with external crypto engine"
Next in thread: andreym: "Re: [PATCH v1] eCryptfs: enhancing eCryptfs to be used with external crypto engine"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

On 2015-11-10 15:20:59, andreym@xxxxxxxxxxxxxx wrote:
> This is a hardware inline accelerator, meaning that it operates on much
> lower layer, block layer and device driver layer. The HW encrypts plain
> requests sent from block layer directly, thus doing it much more
> efficiently rather than using crypto API.

I feel like basing this on eCryptfs is an odd choice. The overhead of
setting up an eCryptfs mount (and requiring CAP_SYS_ADMIN) and the
duplication of page cache and dentry cache entries (for upper and lower
caches) seems like considerable baggage for such a nifty, new hardware
feature.

> In order to use such HW efficiently with eCryptfs, eCryptfs encryption has
> to be canceled and it will need to call for external module instead that
> will do the correct marking for the blocks to distinguish between those
> that need to be encrypted by the HW from those that do not need.
>
> We are considering posting the code that will call
> ecryptfs_register_to_events() as a separate patch, but haven't done so
> yet. It is HW specific.
> Currently we are only proposing framework change so that it can allow for
> external modules to be connected

In that case, I cannot accept this patch. I will have no way to test the
external module functionality and will not be able to make changes to
that area of the code because it will not be possible for me to fix
anything that I've broken. I won't even be able to know if I've broken
anything.

If you are able to upstream the external module code, then I'll do a
proper review of this patch. I should note that I've only glanced at the
patch but if feels like it should be broken up into smaller, easier to
review patches before it can be properly reviewed.

Tyler

>
> > On 2015-11-09 20:56:02, andreym@xxxxxxxxxxxxxx wrote:
> >> Hello, Tyler
> >>
> >> I'll try to provide more detailed explanation, should it be satisfactory
> >> enough I will update the patch description.
> >>
> >> The problem with current eCryptfs is that it has total control on how
> >> and
> >> when the encryption is performed and this control can't be altered. One
> >> example when this can be a problem is when we want to utilize an
> >> underlying inline HW encryption engine which allows encrypting blocks
> >> 'on
> >> the fly' as they are being written to the storage. In such a case
> >> relevant
> >> blocks just need to be marked as 'should be encrypted'. No actual
> >> encryption should be done by eCryptfs as it will be much slower.
> >
> > Is this a hardware crypto accelerator? If so, why not create a crypto
> > api driver so all subsystems can take advantage of the acceleration
> > instead of baking support into individual subsystems?
> >
> >> The provided framework allows transferring this control (if needed) to
> >> some external module which will do the encryption itfelf or just mark
> >> the
> >> appropriate blocks.
> >>
> >> There is no caller for ecryptfs_register_to_events() since this change
> >> only provides framework, it doesn't provide the module itself, the
> >> module
> >> could be HW dependent.
> >
> > Will the code that you plan to call ecryptfs_register_to_events() be
> > upstream? If so, have you posted it?
> >
> > Tyler
> >
> >> Regarding the mounting option, it merely serves as example of new cipher
> >> mode that can be served by registered module.
> >> There is a special callback function that should be implemented by the
> >> registered module that tells whether a particular cipher is supported by
> >> it :
> >> is_cipher_supported_cb()
> >>
> >> The mounting option itself is not necessary, I can remove it
> >>
> >> > Hello Andrey!
> >> >
> >> > On 2015-11-08 10:10:00, Andrey Markovytch wrote:
> >> >> From: Andrey Markovytch <andreym@xxxxxxxxxxxxxxxx>
> >> >>
> >> >> Currently eCryptfs is responsible for page encryption/decryption.
> >> >> This approach will not work when there is HW inline encryption.
> >> >> The proposed change allows external module to register with eCryptfs
> >> >> and provide alternative encryption mechanism and also decide whether
> >> >> encryption should be performed at all, or deferred to a later stage
> >> via
> >> >> the inline HW engine.
> >> >> Additional cipher option was introduced to support the HW/external
> >> mode
> >> >> under that name of "aes-xts". If no external module has registered
> >> >> to support this cipher, eCryptfs will fall back to the usual "aes"
> >> >
> >> > What is "HW/external mode"? There's no description in the commit
> >> message
> >> > and ecryptfs_register_to_events() does not have a caller so I'm not
> >> sure
> >> > of the purpose. Please provide more context.
> >> >
> >> > Despite not yet understanding the purpose of this patch, I think that
> >> I
> >> > can safely say that "aes-xts" is not an appropriate mount option to
> >> use
> >> > when enabling this mode. eCryptfs may support XTS mode one day, using
> >> > the Crypto API, so "HW/external mode" should not own the mount option.
> >> >
> >> > Tyler
> >> >
> >> >>
> >> >> Signed-off-by: Lina Zarivach <linaz@xxxxxxxxxxxxxx>
> >> >> Signed-off-by: Andrey Markovytch <andreym@xxxxxxxxxxxxxx>
> >> >> ---
> >> >> fs/ecryptfs/Makefile | 4 +-
> >> >> fs/ecryptfs/caches_utils.c | 78 +++++++++
> >> >> fs/ecryptfs/crypto.c | 200 +++++++++++++++++++----
> >> >> fs/ecryptfs/debug.c | 13 ++
> >> >> fs/ecryptfs/ecryptfs_kernel.h | 78 +++++++++
> >> >> fs/ecryptfs/events.c | 361
> >> >> ++++++++++++++++++++++++++++++++++++++++++
> >> >> fs/ecryptfs/file.c | 36 +++++
> >> >> fs/ecryptfs/inode.c | 11 ++
> >> >> fs/ecryptfs/keystore.c | 101 ++++++++----
> >> >> fs/ecryptfs/main.c | 60 +++++--
> >> >> fs/ecryptfs/mmap.c | 6 +
> >> >> fs/ecryptfs/super.c | 14 +-
> >> >> include/linux/ecryptfs.h | 47 ++++++
> >> >> 13 files changed, 940 insertions(+), 69 deletions(-)
> >> >> create mode 100644 fs/ecryptfs/caches_utils.c
> >> >> create mode 100644 fs/ecryptfs/events.c
> >> >>
> >> >> diff --git a/fs/ecryptfs/Makefile b/fs/ecryptfs/Makefile
> >> >> index 49678a6..995719c 100644
> >> >> --- a/fs/ecryptfs/Makefile
> >> >> +++ b/fs/ecryptfs/Makefile
> >> >> @@ -4,7 +4,7 @@
> >> >>
> >> >> obj-$(CONFIG_ECRYPT_FS) += ecryptfs.o
> >> >>
> >> >> -ecryptfs-y := dentry.o file.o inode.o main.o super.o mmap.o
> >> >> read_write.o \
> >> >> - crypto.o keystore.o kthread.o debug.o
> >> >> +ecryptfs-y := dentry.o file.o inode.o main.o super.o mmap.o
> >> >> read_write.o events.o \
> >> >> + crypto.o keystore.o kthread.o debug.o caches_utils.o
> >> >>
> >> >> ecryptfs-$(CONFIG_ECRYPT_FS_MESSAGING) += messaging.o miscdev.o
> >> >> diff --git a/fs/ecryptfs/caches_utils.c b/fs/ecryptfs/caches_utils.c
> >> >> new file mode 100644
> >> >> index 0000000..c599c96
> >> >> --- /dev/null
> >> >> +++ b/fs/ecryptfs/caches_utils.c
> >> >> @@ -0,0 +1,78 @@
> >> >> +/*
> >> >> + * Copyright (c) 2015, The Linux Foundation. All rights reserved.
> >> >> + *
> >> >> + * This program is free software; you can redistribute it and/or
> >> modify
> >> >> + * it under the terms of the GNU General Public License version 2
> >> and
> >> >> + * only version 2 as published by the Free Software Foundation.
> >> >> + *
> >> >> + * 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.
> >> >> + */
> >> >> +
> >> >> +#include <linux/kernel.h>
> >> >> +#include <linux/fs.h>
> >> >> +#include <linux/spinlock.h>
> >> >> +#include <linux/pagemap.h>
> >> >> +#include <linux/pagevec.h>
> >> >> +
> >> >> +#include "../internal.h"
> >> >> +
> >> >> +void ecryptfs_drop_pagecache_sb(struct super_block *sb, void
> >> *unused)
> >> >> +{
> >> >> + struct inode *inode, *toput_inode = NULL;
> >> >> +
> >> >> + spin_lock(&sb->s_inode_list_lock);
> >> >> + list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
> >> >> + spin_lock(&inode->i_lock);
> >> >> + if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
> >> >> + (inode->i_mapping->nrpages == 0)) {
> >> >> + spin_unlock(&inode->i_lock);
> >> >> + continue;
> >> >> + }
> >> >> + __iget(inode);
> >> >> + spin_unlock(&inode->i_lock);
> >> >> + spin_unlock(&sb->s_inode_list_lock);
> >> >> +
> >> >> + invalidate_mapping_pages(inode->i_mapping, 0, -1);
> >> >> + iput(toput_inode);
> >> >> + toput_inode = inode;
> >> >> +
> >> >> + spin_lock(&sb->s_inode_list_lock);
> >> >> + }
> >> >> + spin_unlock(&sb->s_inode_list_lock);
> >> >> + iput(toput_inode);
> >> >> +}
> >> >> +
> >> >> +void clean_inode_pages(struct address_space *mapping,
> >> >> + pgoff_t start, pgoff_t end)
> >> >> +{
> >> >> + struct pagevec pvec;
> >> >> + pgoff_t index = start;
> >> >> + int i;
> >> >> +
> >> >> + pagevec_init(&pvec, 0);
> >> >> + while (index <= end && pagevec_lookup(&pvec, mapping, index,
> >> >> + min(end - index,
> >> >> + (pgoff_t)PAGEVEC_SIZE - 1) + 1)) {
> >> >> + for (i = 0; i < pagevec_count(&pvec); i++) {
> >> >> + struct page *page = pvec.pages[i];
> >> >> +
> >> >> + /* We rely upon deletion
> >> >> + * not changing page->index
> >> >> + */
> >> >> + index = page->index;
> >> >> + if (index > end)
> >> >> + break;
> >> >> + if (!trylock_page(page))
> >> >> + continue;
> >> >> + WARN_ON(page->index != index);
> >> >> + zero_user(page, 0, PAGE_CACHE_SIZE);
> >> >> + unlock_page(page);
> >> >> + }
> >> >> + pagevec_release(&pvec);
> >> >> + cond_resched();
> >> >> + index++;
> >> >> + }
> >> >> +}
> >> >> diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
> >> >> index 80d6901..99ebf13 100644
> >> >> --- a/fs/ecryptfs/crypto.c
> >> >> +++ b/fs/ecryptfs/crypto.c
> >> >> @@ -35,6 +35,7 @@
> >> >> #include <linux/scatterlist.h>
> >> >> #include <linux/slab.h>
> >> >> #include <asm/unaligned.h>
> >> >> +#include <linux/ecryptfs.h>
> >> >> #include "ecryptfs_kernel.h"
> >> >>
> >> >> #define DECRYPT 0
> >> >> @@ -350,9 +351,9 @@ static int crypt_scatterlist(struct
> >> >> ecryptfs_crypt_stat *crypt_stat,
> >> >> || !(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_get_key_size_to_enc_data(crypt_stat));
> >> >> ecryptfs_dump_hex(crypt_stat->key,
> >> >> - crypt_stat->key_size);
> >> >> + ecryptfs_get_key_size_to_enc_data(crypt_stat));
> >> >> }
> >> >>
> >> >> init_completion(&ecr.completion);
> >> >> @@ -371,7 +372,7 @@ static int crypt_scatterlist(struct
> >> >> ecryptfs_crypt_stat *crypt_stat,
> >> >> /* 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);
> >> >> + ecryptfs_get_key_size_to_enc_data(crypt_stat));
> >> >> if (rc) {
> >> >> ecryptfs_printk(KERN_ERR,
> >> >> "Error setting key; rc = [%d]\n",
> >> >> @@ -466,6 +467,31 @@ out:
> >> >> return rc;
> >> >> }
> >> >>
> >> >> +static void init_ecryption_parameters(bool *hw_crypt, bool
> >> >> *cipher_supported,
> >> >> + struct ecryptfs_crypt_stat *crypt_stat)
> >> >> +{
> >> >> + unsigned char final[2*ECRYPTFS_MAX_CIPHER_NAME_SIZE+1];
> >> >> +
> >> >> + if (!hw_crypt || !cipher_supported)
> >> >> + return;
> >> >> +
> >> >> + *cipher_supported = false;
> >> >> + *hw_crypt = false;
> >> >> +
> >> >> + if (get_events() && get_events()->is_cipher_supported_cb) {
> >> >> + *cipher_supported =
> >> >> + get_events()->is_cipher_supported_cb(
> >> >> + ecryptfs_get_full_cipher(crypt_stat->cipher,
> >> >> + crypt_stat->cipher_mode, final, sizeof(final)));
> >> >> + if (*cipher_supported) {
> >> >> + /* we should apply external algorythm
> >> >> + * assume that is_hw_crypt() cbck is supplied
> >> >> + */
> >> >> + *hw_crypt = get_events()->is_hw_crypt_cb();
> >> >> + }
> >> >> + }
> >> >> +}
> >> >> +
> >> >> /**
> >> >> * ecryptfs_encrypt_page
> >> >> * @page: Page mapped from the eCryptfs inode for the file; contains
> >> >> @@ -491,11 +517,18 @@ int ecryptfs_encrypt_page(struct page *page)
> >> >> loff_t extent_offset;
> >> >> loff_t lower_offset;
> >> >> int rc = 0;
> >> >> + bool is_hw_crypt;
> >> >> + bool is_cipher_supported;
> >> >> +
> >> >>
> >> >> ecryptfs_inode = page->mapping->host;
> >> >> crypt_stat =
> >> >> &(ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat);
> >> >> BUG_ON(!(crypt_stat->flags & ECRYPTFS_ENCRYPTED));
> >> >> +
> >> >> + init_ecryption_parameters(&is_hw_crypt,
> >> >> + &is_cipher_supported, crypt_stat);
> >> >> +
> >> >> enc_extent_page = alloc_page(GFP_USER);
> >> >> if (!enc_extent_page) {
> >> >> rc = -ENOMEM;
> >> >> @@ -503,24 +536,51 @@ int ecryptfs_encrypt_page(struct page *page)
> >> >> "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;
> >> >> - }
> >> >> + if (is_hw_crypt) {
> >> >> + /* no need for encryption */
> >> >> + } else {
> >> >> + for (extent_offset = 0;
> >> >> + extent_offset <
> >> >> + (PAGE_CACHE_SIZE / crypt_stat->extent_size);
> >> >> + extent_offset++) {
> >> >> +
> >> >> + if (is_cipher_supported) {
> >> >> + if (!get_events()->encrypt_cb) {
> >> >> + rc = -EPERM;
> >> >> + goto out;
> >> >> + }
> >> >> + rc = get_events()->encrypt_cb(page,
> >> >> + enc_extent_page,
> >> >> + ecryptfs_inode_to_lower(
> >> >> + ecryptfs_inode),
> >> >> + extent_offset);
> >> >> + } else {
> >> >> + rc = crypt_extent(crypt_stat,
> >> >> + enc_extent_page, page,
> >> >> + extent_offset, ENCRYPT);
> >> >> + }
> >> >> + if (rc) {
> >> >> + ecryptfs_printk(KERN_ERR,
> >> >> + "%s: Error encrypting; rc = [%d]\n",
> >> >> + __func__, rc);
> >> >> + goto out;
> >> >> + }
> >> >> + }
> >> >> }
> >> >>
> >> >> lower_offset = lower_offset_for_page(crypt_stat, page);
> >> >> - enc_extent_virt = kmap(enc_extent_page);
> >> >> + if (is_hw_crypt)
> >> >> + enc_extent_virt = kmap(page);
> >> >> + else
> >> >> + 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 (!is_hw_crypt)
> >> >> + kunmap(enc_extent_page);
> >> >> + else
> >> >> + kunmap(page);
> >> >> +
> >> >> if (rc < 0) {
> >> >> ecryptfs_printk(KERN_ERR,
> >> >> "Error attempting to write lower page; rc = [%d]\n",
> >> >> @@ -559,6 +619,8 @@ int ecryptfs_decrypt_page(struct page *page)
> >> >> unsigned long extent_offset;
> >> >> loff_t lower_offset;
> >> >> int rc = 0;
> >> >> + bool is_cipher_supported;
> >> >> + bool is_hw_crypt;
> >> >>
> >> >> ecryptfs_inode = page->mapping->host;
> >> >> crypt_stat =
> >> >> @@ -577,13 +639,33 @@ int ecryptfs_decrypt_page(struct page *page)
> >> >> goto out;
> >> >> }
> >> >>
> >> >> + init_ecryption_parameters(&is_hw_crypt,
> >> >> + &is_cipher_supported, crypt_stat);
> >> >> +
> >> >> + if (is_hw_crypt) {
> >> >> + rc = 0;
> >> >> + return rc;
> >> >> + }
> >> >> +
> >> >> for (extent_offset = 0;
> >> >> extent_offset < (PAGE_CACHE_SIZE / crypt_stat->extent_size);
> >> >> extent_offset++) {
> >> >> - rc = crypt_extent(crypt_stat, page, page,
> >> >> + if (is_cipher_supported) {
> >> >> + if (!get_events()->decrypt_cb) {
> >> >> + rc = -EPERM;
> >> >> + goto out;
> >> >> + }
> >> >> +
> >> >> + rc = get_events()->decrypt_cb(page, page,
> >> >> + ecryptfs_inode_to_lower(ecryptfs_inode),
> >> >> + extent_offset);
> >> >> +
> >> >> + } else
> >> >> + rc = crypt_extent(crypt_stat, page, page,
> >> >> extent_offset, DECRYPT);
> >> >> +
> >> >> if (rc) {
> >> >> - printk(KERN_ERR "%s: Error encrypting extent; "
> >> >> + ecryptfs_printk(KERN_ERR, "%s: Error decrypting extent;"
> >> >> "rc = [%d]\n", __func__, rc);
> >> >> goto out;
> >> >> }
> >> >> @@ -612,7 +694,7 @@ int ecryptfs_init_crypt_ctx(struct
> >> >> ecryptfs_crypt_stat *crypt_stat)
> >> >> "Initializing cipher [%s]; strlen = [%d]; "
> >> >> "key_size_bits = [%zd]\n",
> >> >> crypt_stat->cipher, (int)strlen(crypt_stat->cipher),
> >> >> - crypt_stat->key_size << 3);
> >> >> + ecryptfs_get_key_size_to_enc_data(crypt_stat) << 3);
> >> >> mutex_lock(&crypt_stat->cs_tfm_mutex);
> >> >> if (crypt_stat->tfm) {
> >> >> rc = 0;
> >> >> @@ -694,7 +776,7 @@ int ecryptfs_compute_root_iv(struct
> >> >> ecryptfs_crypt_stat *crypt_stat)
> >> >> goto out;
> >> >> }
> >> >> rc = ecryptfs_calculate_md5(dst, crypt_stat, crypt_stat->key,
> >> >> - crypt_stat->key_size);
> >> >> + ecryptfs_get_key_size_to_enc_data(crypt_stat));
> >> >> if (rc) {
> >> >> ecryptfs_printk(KERN_WARNING, "Error attempting to compute "
> >> >> "MD5 while generating root IV\n");
> >> >> @@ -721,6 +803,35 @@ static void ecryptfs_generate_new_key(struct
> >> >> ecryptfs_crypt_stat *crypt_stat)
> >> >> }
> >> >> }
> >> >>
> >> >> +static int ecryptfs_generate_new_salt(struct ecryptfs_crypt_stat
> >> >> *crypt_stat)
> >> >> +{
> >> >> + size_t salt_size = 0;
> >> >> + unsigned char final[2*ECRYPTFS_MAX_CIPHER_NAME_SIZE+1];
> >> >> +
> >> >> + salt_size = ecryptfs_get_salt_size_for_cipher(
> >> >> + ecryptfs_get_full_cipher(crypt_stat->cipher,
> >> >> + crypt_stat->cipher_mode,
> >> >> + final, sizeof(final)));
> >> >> +
> >> >> + if (salt_size == 0)
> >> >> + return 0;
> >> >> +
> >> >> + if (!ecryptfs_check_space_for_salt(crypt_stat->key_size,
> >> salt_size)) {
> >> >> + ecryptfs_printk(KERN_WARNING, "not enough space for salt\n");
> >> >> + crypt_stat->flags |= ECRYPTFS_SECURITY_WARNING;
> >> >> + return -EINVAL;
> >> >> + }
> >> >> +
> >> >> + get_random_bytes(crypt_stat->key + crypt_stat->key_size,
> >> salt_size);
> >> >> + if (unlikely(ecryptfs_verbosity > 0)) {
> >> >> + ecryptfs_printk(KERN_DEBUG, "Generated new session salt:\n");
> >> >> + ecryptfs_dump_hex(crypt_stat->key + crypt_stat->key_size,
> >> >> + salt_size);
> >> >> + }
> >> >> +
> >> >> + return 0;
> >> >> +}
> >> >> +
> >> >> /**
> >> >> * ecryptfs_copy_mount_wide_flags_to_inode_flags
> >> >> * @crypt_stat: The inode's cryptographic context
> >> >> @@ -823,7 +934,6 @@ int ecryptfs_new_file_context(struct inode
> >> >> *ecryptfs_inode)
> >> >> 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);
> >> >> @@ -837,15 +947,19 @@ int ecryptfs_new_file_context(struct inode
> >> >> *ecryptfs_inode)
> >> >> "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,
> >> >> + strlcpy(crypt_stat->cipher,
> >> >> mount_crypt_stat->global_default_cipher_name,
> >> >> - cipher_name_len);
> >> >> - crypt_stat->cipher[cipher_name_len] = '\0';
> >> >> + sizeof(crypt_stat->cipher));
> >> >> +
> >> >> + strlcpy(crypt_stat->cipher_mode,
> >> >> + mount_crypt_stat->global_default_cipher_mode,
> >> >> + sizeof(crypt_stat->cipher_mode));
> >> >> +
> >> >> crypt_stat->key_size =
> >> >> mount_crypt_stat->global_default_cipher_key_size;
> >> >> ecryptfs_generate_new_key(crypt_stat);
> >> >> + ecryptfs_generate_new_salt(crypt_stat);
> >> >> +
> >> >> rc = ecryptfs_init_crypt_ctx(crypt_stat);
> >> >> if (rc)
> >> >> ecryptfs_printk(KERN_ERR, "Error initializing cryptographic "
> >> >> @@ -971,7 +1085,8 @@ ecryptfs_cipher_code_str_map[] = {
> >> >> {"twofish", RFC2440_CIPHER_TWOFISH},
> >> >> {"cast6", RFC2440_CIPHER_CAST_6},
> >> >> {"aes", RFC2440_CIPHER_AES_192},
> >> >> - {"aes", RFC2440_CIPHER_AES_256}
> >> >> + {"aes", RFC2440_CIPHER_AES_256},
> >> >> + {"aes_xts", RFC2440_CIPHER_AES_XTS_256}
> >> >> };
> >> >>
> >> >> /**
> >> >> @@ -999,6 +1114,11 @@ u8 ecryptfs_code_for_cipher_string(char
> >> >> *cipher_name, size_t key_bytes)
> >> >> case 32:
> >> >> code = RFC2440_CIPHER_AES_256;
> >> >> }
> >> >> + } else if (strcmp(cipher_name, "aes_xts") == 0) {
> >> >> + switch (key_bytes) {
> >> >> + case 32:
> >> >> + code = RFC2440_CIPHER_AES_XTS_256;
> >> >> + }
> >> >> } else {
> >> >> for (i = 0; i < ARRAY_SIZE(ecryptfs_cipher_code_str_map); i++)
> >> >> if (strcmp(cipher_name, map[i].cipher_str) == 0) {
> >> >> @@ -1038,9 +1158,24 @@ 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;
> >> >> + unsigned int ra_pages_org;
> >> >> + struct file *lower_file = NULL;
> >> >> +
> >> >> + if (!inode)
> >> >> + return -EIO;
> >> >> + lower_file = ecryptfs_inode_to_private(inode)->lower_file;
> >> >> + if (!lower_file)
> >> >> + return -EIO;
> >> >> +
> >> >> + /*disable read a head mechanism for a while */
> >> >> + ra_pages_org = lower_file->f_ra.ra_pages;
> >> >> + lower_file->f_ra.ra_pages = 0;
> >> >>
> >> >> rc = ecryptfs_read_lower(file_size, 0,
> >> ECRYPTFS_SIZE_AND_MARKER_BYTES,
> >> >> inode);
> >> >> + lower_file->f_ra.ra_pages = ra_pages_org;
> >> >> + /* restore read a head mechanism */
> >> >> +
> >> >> if (rc < ECRYPTFS_SIZE_AND_MARKER_BYTES)
> >> >> return rc >= 0 ? -EINVAL : rc;
> >> >> rc = ecryptfs_validate_marker(marker);
> >> >> @@ -1430,6 +1565,11 @@ int ecryptfs_read_metadata(struct dentry
> >> >> *ecryptfs_dentry)
> >> >> struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
> >> >> &ecryptfs_superblock_to_private(
> >> >> ecryptfs_dentry->d_sb)->mount_crypt_stat;
> >> >> + unsigned int ra_pages_org;
> >> >> + struct file *lower_file =
> >> >> + ecryptfs_inode_to_private(ecryptfs_inode)->lower_file;
> >> >> + if (!lower_file)
> >> >> + return -EIO;
> >> >>
> >> >> ecryptfs_copy_mount_wide_flags_to_inode_flags(crypt_stat,
> >> >> mount_crypt_stat);
> >> >> @@ -1441,8 +1581,14 @@ int ecryptfs_read_metadata(struct dentry
> >> >> *ecryptfs_dentry)
> >> >> __func__);
> >> >> goto out;
> >> >> }
> >> >> + /*disable read a head mechanism */
> >> >> + ra_pages_org = lower_file->f_ra.ra_pages;
> >> >> + lower_file->f_ra.ra_pages = 0;
> >> >> +
> >> >> rc = ecryptfs_read_lower(page_virt, 0, crypt_stat->extent_size,
> >> >> ecryptfs_inode);
> >> >> + lower_file->f_ra.ra_pages = ra_pages_org; /* restore it back */
> >> >> +
> >> >> if (rc >= 0)
> >> >> rc = ecryptfs_read_headers_virt(page_virt, crypt_stat,
> >> >> ecryptfs_dentry,
> >> >> diff --git a/fs/ecryptfs/debug.c b/fs/ecryptfs/debug.c
> >> >> index 3d2bdf5..2b60137 100644
> >> >> --- a/fs/ecryptfs/debug.c
> >> >> +++ b/fs/ecryptfs/debug.c
> >> >> @@ -119,3 +119,16 @@ void ecryptfs_dump_hex(char *data, int bytes)
> >> >> printk("\n");
> >> >> }
> >> >>
> >> >> +void ecryptfs_dump_salt_hex(char *data, int key_size, char *cipher)
> >> >> +{
> >> >> + size_t salt_size = ecryptfs_get_salt_size_for_cipher(cipher);
> >> >> +
> >> >> + if (salt_size == 0)
> >> >> + return;
> >> >> +
> >> >> + if (!ecryptfs_check_space_for_salt(key_size, salt_size))
> >> >> + return;
> >> >> +
> >> >> + ecryptfs_printk(KERN_DEBUG, "Decrypted session salt key:\n");
> >> >> + ecryptfs_dump_hex(data + key_size, salt_size);
> >> >> +}
> >> >> diff --git a/fs/ecryptfs/ecryptfs_kernel.h
> >> >> b/fs/ecryptfs/ecryptfs_kernel.h
> >> >> index 5ba029e..56297f3 100644
> >> >> --- a/fs/ecryptfs/ecryptfs_kernel.h
> >> >> +++ b/fs/ecryptfs/ecryptfs_kernel.h
> >> >> @@ -245,6 +245,7 @@ struct ecryptfs_crypt_stat {
> >> >> struct mutex cs_tfm_mutex;
> >> >> struct mutex cs_hash_tfm_mutex;
> >> >> struct mutex cs_mutex;
> >> >> + unsigned char cipher_mode[ECRYPTFS_MAX_CIPHER_NAME_SIZE + 1];
> >> >> };
> >> >>
> >> >> /* inode private data. */
> >> >> @@ -267,6 +268,8 @@ struct ecryptfs_dentry_info {
> >> >> };
> >> >> };
> >> >>
> >> >> +
> >> >> +
> >> >> /**
> >> >> * ecryptfs_global_auth_tok - A key used to encrypt all new files
> >> under
> >> >> the mountpoint
> >> >> * @flags: Status flags
> >> >> @@ -345,6 +348,8 @@ struct ecryptfs_mount_crypt_stat {
> >> >> unsigned char global_default_fn_cipher_name[
> >> >> ECRYPTFS_MAX_CIPHER_NAME_SIZE + 1];
> >> >> char global_default_fnek_sig[ECRYPTFS_SIG_SIZE_HEX + 1];
> >> >> + unsigned char
> >> global_default_cipher_mode[ECRYPTFS_MAX_CIPHER_NAME_SIZE
> >> >> + + 1];
> >> >> };
> >> >>
> >> >> /* superblock private data. */
> >> >> @@ -527,6 +532,53 @@ ecryptfs_dentry_to_lower_path(struct dentry
> >> >> *dentry)
> >> >> return &((struct ecryptfs_dentry_info
> >> *)dentry->d_fsdata)->lower_path;
> >> >> }
> >> >>
> >> >> +/**
> >> >> + * Given a cipher and mode strings, the function
> >> >> + * concatenates them to create a new string of
> >> >> + * <cipher>_<mode> format.
> >> >> + */
> >> >> +static inline unsigned char *ecryptfs_get_full_cipher(
> >> >> + unsigned char *cipher, unsigned char *mode,
> >> >> + unsigned char *final, size_t final_size)
> >> >> +{
> >> >> + memset(final, 0, final_size);
> >> >> +
> >> >> + if (strlen(mode) > 0) {
> >> >> + snprintf(final, final_size, "%s_%s", cipher, mode);
> >> >> + return final;
> >> >> + }
> >> >> +
> >> >> + return cipher;
> >> >> +}
> >> >> +
> >> >> +/**
> >> >> + * Given a <cipher>[_<mode>] formatted string, the function
> >> >> + * extracts cipher string and/or mode string.
> >> >> + * Note: the passed cipher and/or mode strings will be
> >> null-terminated.
> >> >> + */
> >> >> +static inline void ecryptfs_parse_full_cipher(
> >> >> + char *s, char *cipher, char *mode)
> >> >> +{
> >> >> + char input[2*ECRYPTFS_MAX_CIPHER_NAME_SIZE+1+1];
> >> >> + /* +1 for '_'; +1 for '\0' */
> >> >> + char *p;
> >> >> + char *input_p = input;
> >> >> +
> >> >> + if (s == NULL || cipher == NULL)
> >> >> + return;
> >> >> +
> >> >> + memset(input, 0, sizeof(input));
> >> >> + strlcpy(input, s, sizeof(input));
> >> >> +
> >> >> + p = strsep(&input_p, "_");
> >> >> + strlcpy(cipher, p, ECRYPTFS_MAX_CIPHER_NAME_SIZE + 1);
> >> >> +
> >> >> +
> >> >> + /* check if mode is specified */
> >> >> + if (input_p != NULL && mode != NULL)
> >> >> + strlcpy(mode, input_p, ECRYPTFS_MAX_CIPHER_NAME_SIZE + 1);
> >> >> +}
> >> >> +
> >> >> #define ecryptfs_printk(type, fmt, arg...) \
> >> >> __ecryptfs_printk(type "%s: " fmt, __func__, ## arg);
> >> >> __printf(1, 2)
> >> >> @@ -575,6 +627,7 @@ int ecryptfs_encrypt_and_encode_filename(
> >> >> const char *name, size_t name_size);
> >> >> struct dentry *ecryptfs_lower_dentry(struct dentry *this_dentry);
> >> >> void ecryptfs_dump_hex(char *data, int bytes);
> >> >> +void ecryptfs_dump_salt_hex(char *data, int key_size, char *cipher);
> >> >> int virt_to_scatterlist(const void *addr, int size, struct
> >> scatterlist
> >> >> *sg,
> >> >> int sg_size);
> >> >> int ecryptfs_compute_root_iv(struct ecryptfs_crypt_stat
> >> *crypt_stat);
> >> >> @@ -718,4 +771,29 @@ int ecryptfs_set_f_namelen(long *namelen, long
> >> >> lower_namelen,
> >> >> int ecryptfs_derive_iv(char *iv, struct ecryptfs_crypt_stat
> >> >> *crypt_stat,
> >> >> loff_t offset);
> >> >>
> >> >> +void clean_inode_pages(struct address_space *mapping,
> >> >> + pgoff_t start, pgoff_t end);
> >> >> +
> >> >> +void ecryptfs_drop_pagecache_sb(struct super_block *sb, void
> >> *unused);
> >> >> +
> >> >> +void ecryptfs_free_events(void);
> >> >> +
> >> >> +void ecryptfs_freepage(struct page *page);
> >> >> +
> >> >> +struct ecryptfs_events *get_events(void);
> >> >> +
> >> >> +size_t ecryptfs_get_salt_size_for_cipher(const char *cipher);
> >> >> +
> >> >> +size_t ecryptfs_get_key_size_to_enc_data(
> >> >> + struct ecryptfs_crypt_stat *crypt_stat);
> >> >> +
> >> >> +size_t ecryptfs_get_key_size_to_store_key(
> >> >> + struct ecryptfs_crypt_stat *crypt_stat);
> >> >> +
> >> >> +size_t ecryptfs_get_key_size_to_restore_key(size_t stored_key_size,
> >> >> + const char *cipher);
> >> >> +
> >> >> +bool ecryptfs_check_space_for_salt(const size_t key_size,
> >> >> + const size_t salt_size);
> >> >> +
> >> >> #endif /* #ifndef ECRYPTFS_KERNEL_H */
> >> >> diff --git a/fs/ecryptfs/events.c b/fs/ecryptfs/events.c
> >> >> new file mode 100644
> >> >> index 0000000..10a8983
> >> >> --- /dev/null
> >> >> +++ b/fs/ecryptfs/events.c
> >> >> @@ -0,0 +1,361 @@
> >> >> +/**
> >> >> + * eCryptfs: Linux filesystem encryption layer
> >> >> + * Copyright (c) 2015, The Linux Foundation. All rights reserved.
> >> >> + *
> >> >> + * This program is free software; you can redistribute it and/or
> >> modify
> >> >> + * it under the terms of the GNU General Public License version 2
> >> and
> >> >> + * only version 2 as published by the Free Software Foundation.
> >> >> + *
> >> >> + * 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.
> >> >> + */
> >> >> +
> >> >> +#include <linux/string.h>
> >> >> +#include <linux/ecryptfs.h>
> >> >> +#include <linux/mutex.h>
> >> >> +#include <linux/types.h>
> >> >> +#include <linux/slab.h>
> >> >> +#include <linux/pagemap.h>
> >> >> +#include <linux/random.h>
> >> >> +#include "ecryptfs_kernel.h"
> >> >> +
> >> >> +static DEFINE_MUTEX(events_mutex);
> >> >> +static struct ecryptfs_events *events_ptr;
> >> >> +static int handle;
> >> >> +
> >> >> +void ecryptfs_free_events(void)
> >> >> +{
> >> >> + mutex_lock(&events_mutex);
> >> >> + if (events_ptr != NULL) {
> >> >> + kfree(events_ptr);
> >> >> + events_ptr = NULL;
> >> >> + }
> >> >> +
> >> >> + mutex_unlock(&events_mutex);
> >> >> +}
> >> >> +
> >> >> +/**
> >> >> + * Register to ecryptfs events, by passing callback
> >> >> + * functions to be called upon events occurrence.
> >> >> + * The function returns a handle to be passed
> >> >> + * to unregister function.
> >> >> + */
> >> >> +int ecryptfs_register_to_events(struct ecryptfs_events *ops)
> >> >> +{
> >> >> + int ret_value = 0;
> >> >> +
> >> >> + if (!ops)
> >> >> + return -EINVAL;
> >> >> +
> >> >> + mutex_lock(&events_mutex);
> >> >> +
> >> >> + if (events_ptr != NULL) {
> >> >> + ecryptfs_printk(KERN_ERR,
> >> >> + "already registered!\n");
> >> >> + ret_value = -EPERM;
> >> >> + goto out;
> >> >> + }
> >> >> + events_ptr =
> >> >> + kzalloc(sizeof(struct ecryptfs_events), GFP_KERNEL);
> >> >> +
> >> >> + if (!events_ptr) {
> >> >> + ecryptfs_printk(KERN_ERR, "malloc failure\n");
> >> >> + ret_value = -ENOMEM;
> >> >> + goto out;
> >> >> + }
> >> >> + /* copy the callbacks */
> >> >> + events_ptr->open_cb = ops->open_cb;
> >> >> + events_ptr->release_cb = ops->release_cb;
> >> >> + events_ptr->encrypt_cb = ops->encrypt_cb;
> >> >> + events_ptr->decrypt_cb = ops->decrypt_cb;
> >> >> + events_ptr->is_cipher_supported_cb =
> >> >> + ops->is_cipher_supported_cb;
> >> >> + events_ptr->is_hw_crypt_cb = ops->is_hw_crypt_cb;
> >> >> + events_ptr->get_salt_key_size_cb = ops->get_salt_key_size_cb;
> >> >> +
> >> >> + get_random_bytes(&handle, sizeof(handle));
> >> >> + ret_value = handle;
> >> >> +
> >> >> +out:
> >> >> + mutex_unlock(&events_mutex);
> >> >> + return ret_value;
> >> >> +}
> >> >> +
> >> >> +/**
> >> >> + * Unregister from ecryptfs events.
> >> >> + */
> >> >> +int ecryptfs_unregister_from_events(int user_handle)
> >> >> +{
> >> >> + int ret_value = 0;
> >> >> +
> >> >> + mutex_lock(&events_mutex);
> >> >> +
> >> >> + if (!events_ptr) {
> >> >> + ret_value = -EINVAL;
> >> >> + goto out;
> >> >> + }
> >> >> + if (user_handle != handle) {
> >> >> + ret_value = ECRYPTFS_INVALID_EVENTS_HANDLE;
> >> >> + goto out;
> >> >> + }
> >> >> +
> >> >> + kfree(events_ptr);
> >> >> + events_ptr = NULL;
> >> >> +
> >> >> +out:
> >> >> + mutex_unlock(&events_mutex);
> >> >> + return ret_value;
> >> >> +}
> >> >> +
> >> >> +/**
> >> >> + * This function decides whether the passed file offset
> >> >> + * belongs to ecryptfs metadata or not.
> >> >> + * The caller must pass ecryptfs data, which was received in one
> >> >> + * of the callback invocations.
> >> >> + */
> >> >> +bool ecryptfs_is_page_in_metadata(void *data, pgoff_t offset)
> >> >> +{
> >> >> +
> >> >> + struct ecryptfs_crypt_stat *stat = NULL;
> >> >> + bool ret = true;
> >> >> +
> >> >> + if (!data) {
> >> >> + ecryptfs_printk(KERN_ERR, "ecryptfs_is_page_in_metadata: invalid
> >> data
> >> >> parameter\n");
> >> >> + ret = false;
> >> >> + goto end;
> >> >> + }
> >> >> + stat = (struct ecryptfs_crypt_stat *)data;
> >> >> +
> >> >> + if (stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
> >> >> + ret = false;
> >> >> + goto end;
> >> >> + }
> >> >> +
> >> >> + if (offset >= (stat->metadata_size/PAGE_CACHE_SIZE)) {
> >> >> + ret = false;
> >> >> + goto end;
> >> >> + }
> >> >> +end:
> >> >> + return ret;
> >> >> +}
> >> >> +
> >> >> +/**
> >> >> + * Given two ecryptfs data, the function
> >> >> + * decides whether they are equal.
> >> >> + */
> >> >> +inline bool ecryptfs_is_data_equal(void *data1, void *data2)
> >> >> +{
> >> >> + /* pointer comparison*/
> >> >> + return data1 == data2;
> >> >> +}
> >> >> +
> >> >> +/**
> >> >> + * Given ecryptfs data, the function
> >> >> + * returns appropriate key size.
> >> >> + */
> >> >> +size_t ecryptfs_get_key_size(void *data)
> >> >> +{
> >> >> +
> >> >> + struct ecryptfs_crypt_stat *stat = NULL;
> >> >> +
> >> >> + if (!data)
> >> >> + return 0;
> >> >> +
> >> >> + stat = (struct ecryptfs_crypt_stat *)data;
> >> >> + return stat->key_size;
> >> >> +}
> >> >> +
> >> >> +/**
> >> >> + * Given ecryptfs data, the function
> >> >> + * returns appropriate salt size.
> >> >> + *
> >> >> + * !!! crypt_stat cipher name and mode must be initialized
> >> >> + */
> >> >> +size_t ecryptfs_get_salt_size(void *data)
> >> >> +{
> >> >> + struct ecryptfs_crypt_stat *stat = NULL;
> >> >> + unsigned char final[2*ECRYPTFS_MAX_CIPHER_NAME_SIZE+1];
> >> >> +
> >> >> + if (!data) {
> >> >> + ecryptfs_printk(KERN_ERR,
> >> >> + "ecryptfs_get_salt_size: invalid data parameter\n");
> >> >> + return 0;
> >> >> + }
> >> >> +
> >> >> + stat = (struct ecryptfs_crypt_stat *)data;
> >> >> + return ecryptfs_get_salt_size_for_cipher(
> >> >> + ecryptfs_get_full_cipher(stat->cipher,
> >> >> + stat->cipher_mode,
> >> >> + final, sizeof(final)));
> >> >> +
> >> >> +}
> >> >> +
> >> >> +/**
> >> >> + * Given ecryptfs data, the function
> >> >> + * returns appropriate cipher.
> >> >> + */
> >> >> +const unsigned char *ecryptfs_get_cipher(void *data)
> >> >> +{
> >> >> + unsigned char final[2*ECRYPTFS_MAX_CIPHER_NAME_SIZE+1];
> >> >> + struct ecryptfs_crypt_stat *stat = NULL;
> >> >> +
> >> >> + if (!data) {
> >> >> + ecryptfs_printk(KERN_ERR,
> >> >> + "ecryptfs_get_cipher: invalid data parameter\n");
> >> >> + return NULL;
> >> >> + }
> >> >> + stat = (struct ecryptfs_crypt_stat *)data;
> >> >> + return ecryptfs_get_full_cipher(stat->cipher, stat->cipher_mode,
> >> >> + final, sizeof(final));
> >> >> +}
> >> >> +
> >> >> +/**
> >> >> + * Given ecryptfs data, the function
> >> >> + * returns file encryption key.
> >> >> + */
> >> >> +const unsigned char *ecryptfs_get_key(void *data)
> >> >> +{
> >> >> +
> >> >> + struct ecryptfs_crypt_stat *stat = NULL;
> >> >> +
> >> >> + if (!data) {
> >> >> + ecryptfs_printk(KERN_ERR,
> >> >> + "ecryptfs_get_key: invalid data parameter\n");
> >> >> + return NULL;
> >> >> + }
> >> >> + stat = (struct ecryptfs_crypt_stat *)data;
> >> >> + return stat->key;
> >> >> +}
> >> >> +
> >> >> +/**
> >> >> + * Given ecryptfs data, the function
> >> >> + * returns file encryption salt.
> >> >> + */
> >> >> +const unsigned char *ecryptfs_get_salt(void *data)
> >> >> +{
> >> >> + struct ecryptfs_crypt_stat *stat = NULL;
> >> >> +
> >> >> + if (!data) {
> >> >> + ecryptfs_printk(KERN_ERR,
> >> >> + "ecryptfs_get_salt: invalid data parameter\n");
> >> >> + return NULL;
> >> >> + }
> >> >> + stat = (struct ecryptfs_crypt_stat *)data;
> >> >> + return stat->key + ecryptfs_get_salt_size(data);
> >> >> +}
> >> >> +
> >> >> +/**
> >> >> + * Returns ecryptfs events pointer
> >> >> + */
> >> >> +inline struct ecryptfs_events *get_events(void)
> >> >> +{
> >> >> + return events_ptr;
> >> >> +}
> >> >> +
> >> >> +/**
> >> >> + * If external crypto module requires salt in addition to key,
> >> >> + * we store it as part of key array (if there is enough space)
> >> >> + * Checks whether a salt key can fit into array allocated for
> >> >> + * regular key
> >> >> + */
> >> >> +bool ecryptfs_check_space_for_salt(const size_t key_size,
> >> >> + const size_t salt_size)
> >> >> +{
> >> >> + if ((salt_size + key_size) > ECRYPTFS_MAX_KEY_BYTES)
> >> >> + return false;
> >> >> +
> >> >> + return true;
> >> >> +}
> >> >> +
> >> >> +/*
> >> >> + * If there is salt that is used by external crypto module, it is
> >> >> stored
> >> >> + * in the same array where regular key is. Salt is going to be used
> >> by
> >> >> + * external crypto module only, so for all internal crypto
> >> operations
> >> >> salt
> >> >> + * should be ignored.
> >> >> + *
> >> >> + * Get key size in cases where it is going to be used for data
> >> >> encryption
> >> >> + * or for all other general purposes
> >> >> + */
> >> >> +size_t ecryptfs_get_key_size_to_enc_data(
> >> >> + struct ecryptfs_crypt_stat *crypt_stat)
> >> >> +{
> >> >> + if (!crypt_stat)
> >> >> + return 0;
> >> >> +
> >> >> + return crypt_stat->key_size;
> >> >> +}
> >> >> +
> >> >> +/*
> >> >> + * If there is salt that is used by external crypto module, it is
> >> >> stored
> >> >> + * in the same array where regular key is. Salt is going to be used
> >> by
> >> >> + * external crypto module only, but we still need to save and
> >> restore
> >> >> it
> >> >> + * (in encrypted form) as part of ecryptfs header along with the
> >> >> regular
> >> >> + * key.
> >> >> + *
> >> >> + * Get key size in cases where it is going to be stored persistently
> >> >> + *
> >> >> + * !!! crypt_stat cipher name and mode must be initialized
> >> >> + */
> >> >> +size_t ecryptfs_get_key_size_to_store_key(
> >> >> + struct ecryptfs_crypt_stat *crypt_stat)
> >> >> +{
> >> >> + size_t salt_size = 0;
> >> >> +
> >> >> + if (!crypt_stat)
> >> >> + return 0;
> >> >> +
> >> >> + salt_size = ecryptfs_get_salt_size(crypt_stat);
> >> >> +
> >> >> + if (!ecryptfs_check_space_for_salt(crypt_stat->key_size,
> >> salt_size)) {
> >> >> + ecryptfs_printk(KERN_WARNING,
> >> >> + "ecryptfs_get_key_size_to_store_key: not enough space for
> >> salt\n");
> >> >> + return crypt_stat->key_size;
> >> >> + }
> >> >> +
> >> >> + return crypt_stat->key_size + salt_size;
> >> >> +}
> >> >> +
> >> >> +/*
> >> >> + * If there is salt that is used by external crypto module, it is
> >> >> stored
> >> >> + * in the same array where regular key is. Salt is going to be used
> >> by
> >> >> + * external crypto module only, but we still need to save and
> >> restore
> >> >> it
> >> >> + * (in encrypted form) as part of ecryptfs header along with the
> >> >> regular
> >> >> + * key.
> >> >> + *
> >> >> + * Get key size in cases where it is going to be restored from
> >> storage
> >> >> + *
> >> >> + * !!! crypt_stat cipher name and mode must be initialized
> >> >> + */
> >> >> +size_t ecryptfs_get_key_size_to_restore_key(size_t stored_key_size,
> >> >> + const char *cipher)
> >> >> +{
> >> >> + size_t salt_size = 0;
> >> >> +
> >> >> + if (!cipher)
> >> >> + return 0;
> >> >> +
> >> >> + salt_size = ecryptfs_get_salt_size_for_cipher(cipher);
> >> >> +
> >> >> + if (salt_size >= stored_key_size) {
> >> >> + ecryptfs_printk(KERN_WARNING,
> >> >> + "ecryptfs_get_key_size_to_restore_key: salt %zu >= stred size
> >> >> %zu\n",
> >> >> + salt_size, stored_key_size);
> >> >> +
> >> >> + return stored_key_size;
> >> >> + }
> >> >> +
> >> >> + return stored_key_size - salt_size;
> >> >> +}
> >> >> +
> >> >> +/**
> >> >> + * Given cipher, the function returns appropriate salt size.
> >> >> + */
> >> >> +size_t ecryptfs_get_salt_size_for_cipher(const char *cipher)
> >> >> +{
> >> >> + if (!get_events() || !(get_events()->get_salt_key_size_cb))
> >> >> + return 0;
> >> >> +
> >> >> + return get_events()->get_salt_key_size_cb(cipher);
> >> >> +}
> >> >> diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c
> >> >> index feef8a9..c346c9e 100644
> >> >> --- a/fs/ecryptfs/file.c
> >> >> +++ b/fs/ecryptfs/file.c
> >> >> @@ -31,6 +31,7 @@
> >> >> #include <linux/security.h>
> >> >> #include <linux/compat.h>
> >> >> #include <linux/fs_stack.h>
> >> >> +#include <linux/ecryptfs.h>
> >> >> #include "ecryptfs_kernel.h"
> >> >>
> >> >> /**
> >> >> @@ -184,6 +185,9 @@ static int ecryptfs_open(struct inode *inode,
> >> struct
> >> >> file *file)
> >> >> int rc = 0;
> >> >> struct ecryptfs_crypt_stat *crypt_stat = NULL;
> >> >> struct dentry *ecryptfs_dentry = file->f_path.dentry;
> >> >> + int ret;
> >> >> +
> >> >> +
> >> >> /* Private value of ecryptfs_dentry allocated in
> >> >> * ecryptfs_lookup() */
> >> >> struct ecryptfs_file_info *file_info;
> >> >> @@ -231,12 +235,31 @@ static int ecryptfs_open(struct inode *inode,
> >> >> struct file *file)
> >> >> 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));
> >> >> +
> >> >> + if (get_events() && get_events()->open_cb) {
> >> >> +
> >> >> + ret = vfs_fsync(file, false);
> >> >> +
> >> >> + if (ret)
> >> >> + ecryptfs_printk(KERN_ERR,
> >> >> + "failed to sync file ret = %d.\n", ret);
> >> >> +
> >> >> + get_events()->open_cb(ecryptfs_inode_to_lower(inode),
> >> >> + crypt_stat);
> >> >> +
> >> >> + if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
> >> >> + truncate_inode_pages(inode->i_mapping, 0);
> >> >> + truncate_inode_pages(
> >> >> + ecryptfs_inode_to_lower(inode)->i_mapping, 0);
> >> >> + }
> >> >> + }
> >> >> goto out;
> >> >> out_put:
> >> >> ecryptfs_put_lower_file(inode);
> >> >> @@ -261,9 +284,22 @@ static int ecryptfs_flush(struct file *file,
> >> >> fl_owner_t td)
> >> >>
> >> >> static int ecryptfs_release(struct inode *inode, struct file *file)
> >> >> {
> >> >> +
> >> >> + int ret;
> >> >> +
> >> >> + ret = vfs_fsync(file, false);
> >> >> +
> >> >> + if (ret)
> >> >> + pr_err("failed to sync file ret = %d.\n", ret);
> >> >> +
> >> >> ecryptfs_put_lower_file(inode);
> >> >> kmem_cache_free(ecryptfs_file_info_cache,
> >> >> ecryptfs_file_to_private(file));
> >> >> +
> >> >> + clean_inode_pages(inode->i_mapping, 0, -1);
> >> >> + clean_inode_pages(ecryptfs_inode_to_lower(inode)->i_mapping, 0,
> >> -1);
> >> >> + truncate_inode_pages(inode->i_mapping, 0);
> >> >> + truncate_inode_pages(ecryptfs_inode_to_lower(inode)->i_mapping, 0);
> >> >> return 0;
> >> >> }
> >> >>
> >> >> diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
> >> >> index 3c4db11..e0d72e7 100644
> >> >> --- a/fs/ecryptfs/inode.c
> >> >> +++ b/fs/ecryptfs/inode.c
> >> >> @@ -261,12 +261,15 @@ out:
> >> >> *
> >> >> * Returns zero on success; non-zero on error condition
> >> >> */
> >> >> +
> >> >> +
> >> >> static int
> >> >> ecryptfs_create(struct inode *directory_inode, struct dentry
> >> >> *ecryptfs_dentry,
> >> >> umode_t mode, bool excl)
> >> >> {
> >> >> struct inode *ecryptfs_inode;
> >> >> int rc;
> >> >> + struct ecryptfs_crypt_stat *crypt_stat;
> >> >>
> >> >> ecryptfs_inode = ecryptfs_do_create(directory_inode,
> >> ecryptfs_dentry,
> >> >> mode);
> >> >> @@ -276,6 +279,7 @@ ecryptfs_create(struct inode *directory_inode,
> >> >> struct dentry *ecryptfs_dentry,
> >> >> rc = PTR_ERR(ecryptfs_inode);
> >> >> goto out;
> >> >> }
> >> >> +
> >> >> /* At this point, a file exists on "disk"; we need to make sure
> >> >> * that this on disk file is prepared to be an ecryptfs file */
> >> >> rc = ecryptfs_initialize_file(ecryptfs_dentry, ecryptfs_inode);
> >> >> @@ -288,6 +292,13 @@ ecryptfs_create(struct inode *directory_inode,
> >> >> struct dentry *ecryptfs_dentry,
> >> >> goto out;
> >> >> }
> >> >> unlock_new_inode(ecryptfs_inode);
> >> >> +
> >> >> + crypt_stat =
> >> &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
> >> >> + if (get_events() && get_events()->open_cb)
> >> >> + get_events()->open_cb(
> >> >> + ecryptfs_inode_to_lower(ecryptfs_inode),
> >> >> + crypt_stat);
> >> >> +
> >> >> d_instantiate(ecryptfs_dentry, ecryptfs_inode);
> >> >> out:
> >> >> return rc;
> >> >> diff --git a/fs/ecryptfs/keystore.c b/fs/ecryptfs/keystore.c
> >> >> index 6bd67e2..82b99c7 100644
> >> >> --- a/fs/ecryptfs/keystore.c
> >> >> +++ b/fs/ecryptfs/keystore.c
> >> >> @@ -315,7 +315,8 @@ write_tag_66_packet(char *signature, u8
> >> cipher_code,
> >> >> * | File Encryption Key Size | 1 or 2 bytes |
> >> >> * | File Encryption Key | arbitrary |
> >> >> */
> >> >> - data_len = (5 + ECRYPTFS_SIG_SIZE_HEX + crypt_stat->key_size);
> >> >> + data_len = (5 + ECRYPTFS_SIG_SIZE_HEX +
> >> >> + ecryptfs_get_key_size_to_store_key(crypt_stat));
> >> >> *packet = kmalloc(data_len, GFP_KERNEL);
> >> >> message = *packet;
> >> >> if (!message) {
> >> >> @@ -335,8 +336,9 @@ write_tag_66_packet(char *signature, u8
> >> cipher_code,
> >> >> memcpy(&message[i], signature, ECRYPTFS_SIG_SIZE_HEX);
> >> >> i += ECRYPTFS_SIG_SIZE_HEX;
> >> >> /* The encrypted key includes 1 byte cipher code and 2 byte
> >> checksum
> >> >> */
> >> >> - rc = ecryptfs_write_packet_length(&message[i], crypt_stat->key_size
> >> +
> >> >> 3,
> >> >> - &packet_size_len);
> >> >> + rc = ecryptfs_write_packet_length(&message[i],
> >> >> + ecryptfs_get_key_size_to_store_key(crypt_stat) + 3,
> >> >> + &packet_size_len);
> >> >> if (rc) {
> >> >> ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet "
> >> >> "header; cannot generate packet length\n");
> >> >> @@ -344,9 +346,10 @@ write_tag_66_packet(char *signature, u8
> >> >> cipher_code,
> >> >> }
> >> >> i += packet_size_len;
> >> >> message[i++] = cipher_code;
> >> >> - memcpy(&message[i], crypt_stat->key, crypt_stat->key_size);
> >> >> - i += crypt_stat->key_size;
> >> >> - for (j = 0; j < crypt_stat->key_size; j++)
> >> >> + memcpy(&message[i], crypt_stat->key,
> >> >> + ecryptfs_get_key_size_to_store_key(crypt_stat));
> >> >> + i += ecryptfs_get_key_size_to_store_key(crypt_stat);
> >> >> + for (j = 0; j < ecryptfs_get_key_size_to_store_key(crypt_stat);
> >> j++)
> >> >> checksum += crypt_stat->key[j];
> >> >> message[i++] = (checksum / 256) % 256;
> >> >> message[i++] = (checksum % 256);
> >> >> @@ -918,6 +921,7 @@ ecryptfs_parse_tag_70_packet(char **filename,
> >> size_t
> >> >> *filename_size,
> >> >> struct ecryptfs_parse_tag_70_packet_silly_stack *s;
> >> >> struct key *auth_tok_key = NULL;
> >> >> int rc = 0;
> >> >> + char full_cipher[ECRYPTFS_MAX_CIPHER_NAME_SIZE];
> >> >>
> >> >> (*packet_size) = 0;
> >> >> (*filename_size) = 0;
> >> >> @@ -977,12 +981,13 @@ ecryptfs_parse_tag_70_packet(char **filename,
> >> >> size_t *filename_size,
> >> >> s->fnek_sig_hex[ECRYPTFS_SIG_SIZE_HEX] = '\0';
> >> >> (*packet_size) += ECRYPTFS_SIG_SIZE;
> >> >> s->cipher_code = data[(*packet_size)++];
> >> >> - rc = ecryptfs_cipher_code_to_string(s->cipher_string,
> >> s->cipher_code);
> >> >> + rc = ecryptfs_cipher_code_to_string(full_cipher, s->cipher_code);
> >> >> if (rc) {
> >> >> printk(KERN_WARNING "%s: Cipher code [%d] is invalid\n",
> >> >> __func__, s->cipher_code);
> >> >> goto out;
> >> >> }
> >> >> + ecryptfs_parse_full_cipher(full_cipher, s->cipher_string, 0);
> >> >> rc = ecryptfs_find_auth_tok_for_sig(&auth_tok_key,
> >> >> &s->auth_tok, mount_crypt_stat,
> >> >> s->fnek_sig_hex);
> >> >> @@ -1151,6 +1156,7 @@ decrypt_pki_encrypted_session_key(struct
> >> >> ecryptfs_auth_tok *auth_tok,
> >> >> char *payload = NULL;
> >> >> size_t payload_len = 0;
> >> >> int rc;
> >> >> + char full_cipher[ECRYPTFS_MAX_CIPHER_NAME_SIZE];
> >> >>
> >> >> rc = ecryptfs_get_auth_tok_sig(&auth_tok_sig, auth_tok);
> >> >> if (rc) {
> >> >> @@ -1184,21 +1190,31 @@ decrypt_pki_encrypted_session_key(struct
> >> >> ecryptfs_auth_tok *auth_tok,
> >> >> rc);
> >> >> goto out;
> >> >> }
> >> >> - auth_tok->session_key.flags |= ECRYPTFS_CONTAINS_DECRYPTED_KEY;
> >> >> - memcpy(crypt_stat->key, auth_tok->session_key.decrypted_key,
> >> >> - auth_tok->session_key.decrypted_key_size);
> >> >> - crypt_stat->key_size = auth_tok->session_key.decrypted_key_size;
> >> >> - rc = ecryptfs_cipher_code_to_string(crypt_stat->cipher,
> >> cipher_code);
> >> >> +
> >> >> + rc = ecryptfs_cipher_code_to_string(full_cipher, cipher_code);
> >> >> if (rc) {
> >> >> ecryptfs_printk(KERN_ERR, "Cipher code [%d] is invalid\n",
> >> >> cipher_code)
> >> >> - goto out;
> >> >> + goto out;
> >> >> }
> >> >> +
> >> >> + auth_tok->session_key.flags |= ECRYPTFS_CONTAINS_DECRYPTED_KEY;
> >> >> + memcpy(crypt_stat->key, auth_tok->session_key.decrypted_key,
> >> >> + auth_tok->session_key.decrypted_key_size);
> >> >> + crypt_stat->key_size = ecryptfs_get_key_size_to_restore_key(
> >> >> + auth_tok->session_key.decrypted_key_size, full_cipher);
> >> >> +
> >> >> + ecryptfs_parse_full_cipher(full_cipher,
> >> >> + crypt_stat->cipher, crypt_stat->cipher_mode);
> >> >> +
> >> >> crypt_stat->flags |= ECRYPTFS_KEY_VALID;
> >> >> if (ecryptfs_verbosity > 0) {
> >> >> ecryptfs_printk(KERN_DEBUG, "Decrypted session key:\n");
> >> >> ecryptfs_dump_hex(crypt_stat->key,
> >> >> crypt_stat->key_size);
> >> >> +
> >> >> + ecryptfs_dump_salt_hex(crypt_stat->key, crypt_stat->key_size,
> >> >> + full_cipher);
> >> >> }
> >> >> out:
> >> >> kfree(msg);
> >> >> @@ -1380,6 +1396,7 @@ parse_tag_3_packet(struct ecryptfs_crypt_stat
> >> >> *crypt_stat,
> >> >> struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
> >> >> size_t length_size;
> >> >> int rc = 0;
> >> >> + char full_cipher[ECRYPTFS_MAX_CIPHER_NAME_SIZE];
> >> >>
> >> >> (*packet_size) = 0;
> >> >> (*new_auth_tok) = NULL;
> >> >> @@ -1453,10 +1470,13 @@ parse_tag_3_packet(struct ecryptfs_crypt_stat
> >> >> *crypt_stat,
> >> >> rc = -EINVAL;
> >> >> goto out_free;
> >> >> }
> >> >> - rc = ecryptfs_cipher_code_to_string(crypt_stat->cipher,
> >> >> + rc = ecryptfs_cipher_code_to_string(full_cipher,
> >> >> (u16)data[(*packet_size)]);
> >> >> if (rc)
> >> >> goto out_free;
> >> >> + ecryptfs_parse_full_cipher(full_cipher,
> >> >> + crypt_stat->cipher, crypt_stat->cipher_mode);
> >> >> +
> >> >> /* A little extra work to differentiate among the AES key
> >> >> * sizes; see RFC2440 */
> >> >> switch(data[(*packet_size)++]) {
> >> >> @@ -1465,7 +1485,10 @@ parse_tag_3_packet(struct ecryptfs_crypt_stat
> >> >> *crypt_stat,
> >> >> break;
> >> >> default:
> >> >> crypt_stat->key_size =
> >> >> - (*new_auth_tok)->session_key.encrypted_key_size;
> >> >> + ecryptfs_get_key_size_to_restore_key(
> >> >> + (*new_auth_tok)->session_key.encrypted_key_size,
> >> >> + full_cipher);
> >> >> +
> >> >> }
> >> >> rc = ecryptfs_init_crypt_ctx(crypt_stat);
> >> >> if (rc)
> >> >> @@ -1664,6 +1687,8 @@ static int
> >> >> decrypt_passphrase_encrypted_session_key(struct ecryptfs_auth_tok
> >> >> *auth_tok,
> >> >> struct ecryptfs_crypt_stat *crypt_stat)
> >> >> {
> >> >> +
> >> >> + unsigned char final[2*ECRYPTFS_MAX_CIPHER_NAME_SIZE+1];
> >> >> struct scatterlist dst_sg[2];
> >> >> struct scatterlist src_sg[2];
> >> >> struct mutex *tfm_mutex;
> >> >> @@ -1713,7 +1738,7 @@ decrypt_passphrase_encrypted_session_key(struct
> >> >> ecryptfs_auth_tok *auth_tok,
> >> >> mutex_lock(tfm_mutex);
> >> >> rc = crypto_blkcipher_setkey(
> >> >> desc.tfm, auth_tok->token.password.session_key_encryption_key,
> >> >> - crypt_stat->key_size);
> >> >> + auth_tok->token.password.session_key_encryption_key_bytes);
> >> >> if (unlikely(rc < 0)) {
> >> >> mutex_unlock(tfm_mutex);
> >> >> printk(KERN_ERR "Error setting key for crypto context\n");
> >> >> @@ -1736,6 +1761,10 @@
> >> decrypt_passphrase_encrypted_session_key(struct
> >> >> ecryptfs_auth_tok *auth_tok,
> >> >> crypt_stat->key_size);
> >> >> ecryptfs_dump_hex(crypt_stat->key,
> >> >> crypt_stat->key_size);
> >> >> + ecryptfs_dump_salt_hex(crypt_stat->key, crypt_stat->key_size,
> >> >> + ecryptfs_get_full_cipher(crypt_stat->cipher,
> >> >> + crypt_stat->cipher_mode,
> >> >> + final, sizeof(final)));
> >> >> }
> >> >> out:
> >> >> return rc;
> >> >> @@ -1972,12 +2001,17 @@ pki_encrypt_session_key(struct key
> >> >> *auth_tok_key,
> >> >> size_t payload_len = 0;
> >> >> struct ecryptfs_message *msg;
> >> >> int rc;
> >> >> + unsigned char final[2*ECRYPTFS_MAX_CIPHER_NAME_SIZE+1];
> >> >>
> >> >> rc = write_tag_66_packet(auth_tok->token.private_key.signature,
> >> >> - ecryptfs_code_for_cipher_string(
> >> >> - crypt_stat->cipher,
> >> >> - crypt_stat->key_size),
> >> >> - crypt_stat, &payload, &payload_len);
> >> >> + ecryptfs_code_for_cipher_string(
> >> >> + ecryptfs_get_full_cipher(
> >> >> + crypt_stat->cipher,
> >> >> + crypt_stat->cipher_mode,
> >> >> + final, sizeof(final)),
> >> >> + ecryptfs_get_key_size_to_enc_data(
> >> >> + crypt_stat)),
> >> >> + crypt_stat, &payload, &payload_len);
> >> >> up_write(&(auth_tok_key->sem));
> >> >> key_put(auth_tok_key);
> >> >> if (rc) {
> >> >> @@ -2035,7 +2069,7 @@ write_tag_1_packet(char *dest, size_t
> >> >> *remaining_bytes,
> >> >> ecryptfs_from_hex(key_rec->sig,
> >> auth_tok->token.private_key.signature,
> >> >> ECRYPTFS_SIG_SIZE);
> >> >> encrypted_session_key_valid = 0;
> >> >> - for (i = 0; i < crypt_stat->key_size; i++)
> >> >> + for (i = 0; i < ecryptfs_get_key_size_to_store_key(crypt_stat);
> >> i++)
> >> >> encrypted_session_key_valid |=
> >> >> auth_tok->session_key.encrypted_key[i];
> >> >> if (encrypted_session_key_valid) {
> >> >> @@ -2189,6 +2223,7 @@ write_tag_3_packet(char *dest, size_t
> >> >> *remaining_bytes,
> >> >> u8 cipher_code;
> >> >> size_t packet_size_length;
> >> >> size_t max_packet_size;
> >> >> + unsigned char final[2*ECRYPTFS_MAX_CIPHER_NAME_SIZE+1];
> >> >> struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
> >> >> crypt_stat->mount_crypt_stat;
> >> >> struct blkcipher_desc desc = {
> >> >> @@ -2221,13 +2256,14 @@ write_tag_3_packet(char *dest, size_t
> >> >> *remaining_bytes,
> >> >> mount_crypt_stat->global_default_cipher_key_size;
> >> >> if (auth_tok->session_key.encrypted_key_size == 0)
> >> >> auth_tok->session_key.encrypted_key_size =
> >> >> - crypt_stat->key_size;
> >> >> + ecryptfs_get_key_size_to_store_key(crypt_stat);
> >> >> if (crypt_stat->key_size == 24
> >> >> && strcmp("aes", crypt_stat->cipher) == 0) {
> >> >> memset((crypt_stat->key + 24), 0, 8);
> >> >> auth_tok->session_key.encrypted_key_size = 32;
> >> >> } else
> >> >> - auth_tok->session_key.encrypted_key_size = crypt_stat->key_size;
> >> >> + auth_tok->session_key.encrypted_key_size =
> >> >> + ecryptfs_get_key_size_to_store_key(crypt_stat);
> >> >> key_rec->enc_key_size =
> >> >> auth_tok->session_key.encrypted_key_size;
> >> >> encrypted_session_key_valid = 0;
> >> >> @@ -2251,8 +2287,8 @@ write_tag_3_packet(char *dest, size_t
> >> >> *remaining_bytes,
> >> >> auth_tok->token.password.
> >> >> session_key_encryption_key_bytes);
> >> >> memcpy(session_key_encryption_key,
> >> >> - auth_tok->token.password.session_key_encryption_key,
> >> >> - crypt_stat->key_size);
> >> >> + auth_tok->token.password.session_key_encryption_key,
> >> >> + auth_tok->token.password.session_key_encryption_key_bytes);
> >> >> ecryptfs_printk(KERN_DEBUG,
> >> >> "Cached session key encryption key:\n");
> >> >> if (ecryptfs_verbosity > 0)
> >> >> @@ -2285,7 +2321,7 @@ write_tag_3_packet(char *dest, size_t
> >> >> *remaining_bytes,
> >> >> }
> >> >> mutex_lock(tfm_mutex);
> >> >> rc = crypto_blkcipher_setkey(desc.tfm, session_key_encryption_key,
> >> >> - crypt_stat->key_size);
> >> >> + auth_tok->token.password.session_key_encryption_key_bytes);
> >> >> if (rc < 0) {
> >> >> mutex_unlock(tfm_mutex);
> >> >> ecryptfs_printk(KERN_ERR, "Error setting key for crypto "
> >> >> @@ -2294,7 +2330,12 @@ write_tag_3_packet(char *dest, size_t
> >> >> *remaining_bytes,
> >> >> }
> >> >> rc = 0;
> >> >> ecryptfs_printk(KERN_DEBUG, "Encrypting [%zd] bytes of the key\n",
> >> >> - crypt_stat->key_size);
> >> >> + crypt_stat->key_size);
> >> >> + ecryptfs_printk(KERN_DEBUG, "Encrypting [%zd] bytes of the salt
> >> >> key\n",
> >> >> + ecryptfs_get_salt_size_for_cipher(
> >> >> + ecryptfs_get_full_cipher(crypt_stat->cipher,
> >> >> + crypt_stat->cipher_mode,
> >> >> + final, sizeof(final))));
> >> >> rc = crypto_blkcipher_encrypt(&desc, dst_sg, src_sg,
> >> >> (*key_rec).enc_key_size);
> >> >> mutex_unlock(tfm_mutex);
> >> >> @@ -2343,8 +2384,10 @@ encrypted_session_key_set:
> >> >> dest[(*packet_size)++] = 0x04; /* version 4 */
> >> >> /* TODO: Break from RFC2440 so that arbitrary ciphers can be
> >> >> * specified with strings */
> >> >> - cipher_code = ecryptfs_code_for_cipher_string(crypt_stat->cipher,
> >> >> - crypt_stat->key_size);
> >> >> + cipher_code = ecryptfs_code_for_cipher_string(
> >> >> + ecryptfs_get_full_cipher(crypt_stat->cipher,
> >> >> + crypt_stat->cipher_mode, final, sizeof(final)),
> >> >> + crypt_stat->key_size);
> >> >> if (cipher_code == 0) {
> >> >> ecryptfs_printk(KERN_WARNING, "Unable to generate code for "
> >> >> "cipher [%s]\n", crypt_stat->cipher);
> >> >> diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
> >> >> index e83f31c..b8ab8c7 100644
> >> >> --- a/fs/ecryptfs/main.c
> >> >> +++ b/fs/ecryptfs/main.c
> >> >> @@ -165,7 +165,13 @@ void ecryptfs_put_lower_file(struct inode
> >> *inode)
> >> >> fput(inode_info->lower_file);
> >> >> inode_info->lower_file = NULL;
> >> >> mutex_unlock(&inode_info->lower_file_mutex);
> >> >> +
> >> >> + if (get_events() && get_events()->release_cb)
> >> >> + get_events()->release_cb(
> >> >> + ecryptfs_inode_to_lower(inode));
> >> >> }
> >> >> +
> >> >> +
> >> >> }
> >> >>
> >> >> enum { ecryptfs_opt_sig, ecryptfs_opt_ecryptfs_sig,
> >> >> @@ -266,6 +272,7 @@ static int ecryptfs_parse_options(struct
> >> >> ecryptfs_sb_info *sbi, char *options,
> >> >> int cipher_key_bytes_set = 0;
> >> >> int fn_cipher_key_bytes;
> >> >> int fn_cipher_key_bytes_set = 0;
> >> >> + size_t salt_size = 0;
> >> >> struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
> >> >> &sbi->mount_crypt_stat;
> >> >> substring_t args[MAX_OPT_ARGS];
> >> >> @@ -280,6 +287,7 @@ static int ecryptfs_parse_options(struct
> >> >> ecryptfs_sb_info *sbi, char *options,
> >> >> char *cipher_key_bytes_src;
> >> >> char *fn_cipher_key_bytes_src;
> >> >> u8 cipher_code;
> >> >> + unsigned char final[2*ECRYPTFS_MAX_CIPHER_NAME_SIZE+1];
> >> >>
> >> >> *check_ruid = 0;
> >> >>
> >> >> @@ -309,12 +317,14 @@ static int ecryptfs_parse_options(struct
> >> >> ecryptfs_sb_info *sbi, char *options,
> >> >> 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';
> >> >> + mount_crypt_stat->global_default_cipher_name;
> >> >> +
> >> >> + ecryptfs_parse_full_cipher(cipher_name_src,
> >> >> + mount_crypt_stat->global_default_cipher_name,
> >> >> + mount_crypt_stat->global_default_cipher_mode);
> >> >> +
> >> >> cipher_name_set = 1;
> >> >> +
> >> >> break;
> >> >> case ecryptfs_opt_ecryptfs_key_bytes:
> >> >> cipher_key_bytes_src = args[0].from;
> >> >> @@ -411,24 +421,50 @@ static int ecryptfs_parse_options(struct
> >> >> ecryptfs_sb_info *sbi, char *options,
> >> >> 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)
> >> >> +
> >> >> + if (cipher_key_bytes_set) {
> >> >> +
> >> >> + salt_size = ecryptfs_get_salt_size_for_cipher(
> >> >> + ecryptfs_get_full_cipher(
> >> >> + mount_crypt_stat->global_default_cipher_name,
> >> >> + mount_crypt_stat->global_default_cipher_mode,
> >> >> + final, sizeof(final)));
> >> >> +
> >> >> + if (!ecryptfs_check_space_for_salt(
> >> >> + mount_crypt_stat->global_default_cipher_key_size,
> >> >> + salt_size)) {
> >> >> + ecryptfs_printk(
> >> >> + KERN_WARNING,
> >> >> + "eCryptfs internal error: no space for salt");
> >> >> + }
> >> >> + } else
> >> >> 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,
> >> >> + ecryptfs_get_full_cipher(
> >> >> + mount_crypt_stat->global_default_cipher_name,
> >> >> + mount_crypt_stat->global_default_cipher_mode,
> >> >> + final, sizeof(final)),
> >> >> 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);
> >> >> + ecryptfs_printk(
> >> >> + KERN_ERR,
> >> >> + "eCryptfs doesn't support cipher: %s and key size %zu",
> >> >> + ecryptfs_get_full_cipher(
> >> >> + mount_crypt_stat->global_default_cipher_name,
> >> >> + mount_crypt_stat->global_default_cipher_mode,
> >> >> + final, sizeof(final)),
> >> >> + mount_crypt_stat->global_default_cipher_key_size);
> >> >> rc = -EINVAL;
> >> >> goto out;
> >> >> }
> >> >> @@ -488,6 +524,7 @@ static struct file_system_type ecryptfs_fs_type;
> >> >> * @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)
> >> >> {
> >> >> @@ -557,6 +594,8 @@ static struct dentry *ecryptfs_mount(struct
> >> >> file_system_type *fs_type, int flags
> >> >>
> >> >> ecryptfs_set_superblock_lower(s, path.dentry->d_sb);
> >> >>
> >> >> + ecryptfs_drop_pagecache_sb(ecryptfs_superblock_to_lower(s), NULL);
> >> >> +
> >> >> /**
> >> >> * Set the POSIX ACL flag based on whether they're enabled in the
> >> >> lower
> >> >> * mount.
> >> >> @@ -894,6 +933,7 @@ static void __exit ecryptfs_exit(void)
> >> >> do_sysfs_unregistration();
> >> >> unregister_filesystem(&ecryptfs_fs_type);
> >> >> ecryptfs_free_kmem_caches();
> >> >> + ecryptfs_free_events();
> >> >> }
> >> >>
> >> >> MODULE_AUTHOR("Michael A. Halcrow <mhalcrow@xxxxxxxxxx>");
> >> >> diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
> >> >> index caba848..bdbc72d 100644
> >> >> --- a/fs/ecryptfs/mmap.c
> >> >> +++ b/fs/ecryptfs/mmap.c
> >> >> @@ -552,10 +552,16 @@ static sector_t ecryptfs_bmap(struct
> >> address_space
> >> >> *mapping, sector_t block)
> >> >> return rc;
> >> >> }
> >> >>
> >> >> +void ecryptfs_freepage(struct page *page)
> >> >> +{
> >> >> + zero_user(page, 0, PAGE_CACHE_SIZE);
> >> >> +}
> >> >> +
> >> >> const struct address_space_operations ecryptfs_aops = {
> >> >> .writepage = ecryptfs_writepage,
> >> >> .readpage = ecryptfs_readpage,
> >> >> .write_begin = ecryptfs_write_begin,
> >> >> .write_end = ecryptfs_write_end,
> >> >> .bmap = ecryptfs_bmap,
> >> >> + .freepage = ecryptfs_freepage,
> >> >> };
> >> >> diff --git a/fs/ecryptfs/super.c b/fs/ecryptfs/super.c
> >> >> index afa1b81..25e436d 100644
> >> >> --- a/fs/ecryptfs/super.c
> >> >> +++ b/fs/ecryptfs/super.c
> >> >> @@ -69,6 +69,9 @@ static void ecryptfs_i_callback(struct rcu_head
> >> *head)
> >> >> {
> >> >> struct inode *inode = container_of(head, struct inode, i_rcu);
> >> >> struct ecryptfs_inode_info *inode_info;
> >> >> + if (inode == NULL)
> >> >> + return;
> >> >> +
> >> >> inode_info = ecryptfs_inode_to_private(inode);
> >> >>
> >> >> kmem_cache_free(ecryptfs_inode_info_cache, inode_info);
> >> >> @@ -88,9 +91,12 @@ static void ecryptfs_destroy_inode(struct inode
> >> >> *inode)
> >> >> struct ecryptfs_inode_info *inode_info;
> >> >>
> >> >> inode_info = ecryptfs_inode_to_private(inode);
> >> >> +
> >> >> BUG_ON(inode_info->lower_file);
> >> >> +
> >> >> ecryptfs_destroy_crypt_stat(&inode_info->crypt_stat);
> >> >> call_rcu(&inode->i_rcu, ecryptfs_i_callback);
> >> >> +
> >> >> }
> >> >>
> >> >> /**
> >> >> @@ -149,6 +155,9 @@ static int ecryptfs_show_options(struct seq_file
> >> *m,
> >> >> struct dentry *root)
> >> >> struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
> >> >> &ecryptfs_superblock_to_private(sb)->mount_crypt_stat;
> >> >> struct ecryptfs_global_auth_tok *walker;
> >> >> + unsigned char final[2*ECRYPTFS_MAX_CIPHER_NAME_SIZE+1];
> >> >> +
> >> >> + memset(final, 0, sizeof(final));
> >> >>
> >> >> mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex);
> >> >> list_for_each_entry(walker,
> >> >> @@ -162,7 +171,10 @@ static int ecryptfs_show_options(struct seq_file
> >> >> *m, struct dentry *root)
> >> >> mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex);
> >> >>
> >> >> seq_printf(m, ",ecryptfs_cipher=%s",
> >> >> - mount_crypt_stat->global_default_cipher_name);
> >> >> + ecryptfs_get_full_cipher(
> >> >> + mount_crypt_stat->global_default_cipher_name,
> >> >> + mount_crypt_stat->global_default_cipher_mode,
> >> >> + final, sizeof(final)));
> >> >>
> >> >> if (mount_crypt_stat->global_default_cipher_key_size)
> >> >> seq_printf(m, ",ecryptfs_key_bytes=%zd",
> >> >> diff --git a/include/linux/ecryptfs.h b/include/linux/ecryptfs.h
> >> >> index 8d5ab99..55433c6 100644
> >> >> --- a/include/linux/ecryptfs.h
> >> >> +++ b/include/linux/ecryptfs.h
> >> >> @@ -1,6 +1,9 @@
> >> >> #ifndef _LINUX_ECRYPTFS_H
> >> >> #define _LINUX_ECRYPTFS_H
> >> >>
> >> >> +struct inode;
> >> >> +struct page;
> >> >> +
> >> >> /* Version verification for shared data structures w/ userspace */
> >> >> #define ECRYPTFS_VERSION_MAJOR 0x00
> >> >> #define ECRYPTFS_VERSION_MINOR 0x04
> >> >> @@ -41,6 +44,7 @@
> >> >> #define RFC2440_CIPHER_AES_256 0x09
> >> >> #define RFC2440_CIPHER_TWOFISH 0x0a
> >> >> #define RFC2440_CIPHER_CAST_6 0x0b
> >> >> +#define RFC2440_CIPHER_AES_XTS_256 0x0c
> >> >>
> >> >> #define RFC2440_CIPHER_RSA 0x01
> >> >>
> >> >> @@ -102,4 +106,47 @@ struct ecryptfs_auth_tok {
> >> >> } token;
> >> >> } __attribute__ ((packed));
> >> >>
> >> >> +#define ECRYPTFS_INVALID_EVENTS_HANDLE -1
> >> >> +
> >> >> +/**
> >> >> + * ecryptfs_events struct represents a partial interface
> >> >> + * towards ecryptfs module. If registered to ecryptfs events,
> >> >> + * one can receive push notifications.
> >> >> + * A first callback received from ecryptfs will probably be
> >> >> + * about file opening (open_cb),
> >> >> + * in which ecryptfs passes its ecryptfs_data for future usage.
> >> >> + * This data represents a file and must be passed in every query
> >> >> functions
> >> >> + * such as ecryptfs_get_key_size(), ecryptfs_get_cipher() etc.
> >> >> + */
> >> >> +struct ecryptfs_events {
> >> >> + bool (*is_cipher_supported_cb)(const char *cipher);
> >> >> + void (*open_cb)(struct inode *inode, void *ecrytpfs_data);
> >> >> + void (*release_cb)(struct inode *inode);
> >> >> + int (*encrypt_cb)(struct page *in_page, struct page *out_page,
> >> >> + struct inode *inode, unsigned long extent_offset);
> >> >> + int (*decrypt_cb)(struct page *in_page, struct page *out_page,
> >> >> + struct inode *inode, unsigned long extent_offset);
> >> >> + bool (*is_hw_crypt_cb)(void);
> >> >> + size_t (*get_salt_key_size_cb)(const char *cipher);
> >> >> +};
> >> >> +
> >> >> +
> >> >> +int ecryptfs_register_to_events(struct ecryptfs_events *ops);
> >> >> +
> >> >> +int ecryptfs_unregister_from_events(int user_handle);
> >> >> +
> >> >> +const unsigned char *ecryptfs_get_key(void *ecrytpfs_data);
> >> >> +
> >> >> +size_t ecryptfs_get_key_size(void *ecrytpfs_data);
> >> >> +
> >> >> +const unsigned char *ecryptfs_get_salt(void *ecrytpfs_data);
> >> >> +
> >> >> +size_t ecryptfs_get_salt_size(void *ecrytpfs_data);
> >> >> +
> >> >> +const unsigned char *ecryptfs_get_cipher(void *ecrytpfs_data);
> >> >> +
> >> >> +bool ecryptfs_is_page_in_metadata(void *ecrytpfs_data, pgoff_t
> >> offset);
> >> >> +
> >> >> +bool ecryptfs_is_data_equal(void *ecrytpfs_data1, void
> >> >> *ecrytpfs_data2);
> >> >> +
> >> >> #endif /* _LINUX_ECRYPTFS_H */
> >> >> --
> >> >> Qualcomm Israel, on behalf of Qualcomm Innovation Center, Inc.
> >> >> The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
> >> >> Forum,
> >> >> a Linux Foundation Collaborative Project
> >> >>
> >> >
> >>
> >
>

Attachment: signature.asc
Description: Digital signature

Next message: Dan Williams: "Re: [PATCH 1/4] nvdimm: Add wrapper for IOCTL pass thru."
Previous message: Joe Perches: "Re: [PATCH] video: constify geode ops structures"
In reply to: andreym: "Re: [PATCH v1] eCryptfs: enhancing eCryptfs to be used with external crypto engine"
Next in thread: andreym: "Re: [PATCH v1] eCryptfs: enhancing eCryptfs to be used with external crypto engine"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]