2015-04-11 19:48:01 +08:00
|
|
|
/*
|
|
|
|
* linux/fs/ext4/crypto_policy.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 2015, Google, Inc.
|
|
|
|
*
|
|
|
|
* This contains encryption policy functions for ext4
|
|
|
|
*
|
|
|
|
* Written by Michael Halcrow, 2015.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/random.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
|
2015-07-17 23:16:47 +08:00
|
|
|
#include "ext4_jbd2.h"
|
2015-04-11 19:48:01 +08:00
|
|
|
#include "ext4.h"
|
|
|
|
#include "xattr.h"
|
|
|
|
|
|
|
|
static int ext4_inode_has_encryption_context(struct inode *inode)
|
|
|
|
{
|
|
|
|
int res = ext4_xattr_get(inode, EXT4_XATTR_INDEX_ENCRYPTION,
|
|
|
|
EXT4_XATTR_NAME_ENCRYPTION_CONTEXT, NULL, 0);
|
|
|
|
return (res > 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* check whether the policy is consistent with the encryption context
|
|
|
|
* for the inode
|
|
|
|
*/
|
|
|
|
static int ext4_is_encryption_context_consistent_with_policy(
|
|
|
|
struct inode *inode, const struct ext4_encryption_policy *policy)
|
|
|
|
{
|
|
|
|
struct ext4_encryption_context ctx;
|
|
|
|
int res = ext4_xattr_get(inode, EXT4_XATTR_INDEX_ENCRYPTION,
|
|
|
|
EXT4_XATTR_NAME_ENCRYPTION_CONTEXT, &ctx,
|
|
|
|
sizeof(ctx));
|
|
|
|
if (res != sizeof(ctx))
|
|
|
|
return 0;
|
|
|
|
return (memcmp(ctx.master_key_descriptor, policy->master_key_descriptor,
|
|
|
|
EXT4_KEY_DESCRIPTOR_SIZE) == 0 &&
|
2015-05-02 04:56:50 +08:00
|
|
|
(ctx.flags ==
|
|
|
|
policy->flags) &&
|
2015-04-11 19:48:01 +08:00
|
|
|
(ctx.contents_encryption_mode ==
|
|
|
|
policy->contents_encryption_mode) &&
|
|
|
|
(ctx.filenames_encryption_mode ==
|
|
|
|
policy->filenames_encryption_mode));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ext4_create_encryption_context_from_policy(
|
|
|
|
struct inode *inode, const struct ext4_encryption_policy *policy)
|
|
|
|
{
|
|
|
|
struct ext4_encryption_context ctx;
|
2015-07-17 23:16:47 +08:00
|
|
|
handle_t *handle;
|
|
|
|
int res, res2;
|
2015-04-11 19:48:01 +08:00
|
|
|
|
2015-05-19 01:18:47 +08:00
|
|
|
res = ext4_convert_inline_data(inode);
|
|
|
|
if (res)
|
|
|
|
return res;
|
|
|
|
|
2015-04-11 19:48:01 +08:00
|
|
|
ctx.format = EXT4_ENCRYPTION_CONTEXT_FORMAT_V1;
|
|
|
|
memcpy(ctx.master_key_descriptor, policy->master_key_descriptor,
|
|
|
|
EXT4_KEY_DESCRIPTOR_SIZE);
|
2015-04-12 12:43:56 +08:00
|
|
|
if (!ext4_valid_contents_enc_mode(policy->contents_encryption_mode)) {
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"%s: Invalid contents encryption mode %d\n", __func__,
|
|
|
|
policy->contents_encryption_mode);
|
2015-05-02 04:56:50 +08:00
|
|
|
return -EINVAL;
|
2015-04-12 12:43:56 +08:00
|
|
|
}
|
2015-04-12 12:56:17 +08:00
|
|
|
if (!ext4_valid_filenames_enc_mode(policy->filenames_encryption_mode)) {
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"%s: Invalid filenames encryption mode %d\n", __func__,
|
|
|
|
policy->filenames_encryption_mode);
|
2015-05-02 04:56:50 +08:00
|
|
|
return -EINVAL;
|
2015-04-12 12:56:17 +08:00
|
|
|
}
|
2015-05-02 04:56:50 +08:00
|
|
|
if (policy->flags & ~EXT4_POLICY_FLAGS_VALID)
|
|
|
|
return -EINVAL;
|
2015-04-11 19:48:01 +08:00
|
|
|
ctx.contents_encryption_mode = policy->contents_encryption_mode;
|
|
|
|
ctx.filenames_encryption_mode = policy->filenames_encryption_mode;
|
2015-05-02 04:56:50 +08:00
|
|
|
ctx.flags = policy->flags;
|
2015-04-11 19:48:01 +08:00
|
|
|
BUILD_BUG_ON(sizeof(ctx.nonce) != EXT4_KEY_DERIVATION_NONCE_SIZE);
|
|
|
|
get_random_bytes(ctx.nonce, EXT4_KEY_DERIVATION_NONCE_SIZE);
|
|
|
|
|
2015-07-17 23:16:47 +08:00
|
|
|
handle = ext4_journal_start(inode, EXT4_HT_MISC,
|
|
|
|
ext4_jbd2_credits_xattr(inode));
|
|
|
|
if (IS_ERR(handle))
|
|
|
|
return PTR_ERR(handle);
|
2015-04-11 19:48:01 +08:00
|
|
|
res = ext4_xattr_set(inode, EXT4_XATTR_INDEX_ENCRYPTION,
|
|
|
|
EXT4_XATTR_NAME_ENCRYPTION_CONTEXT, &ctx,
|
|
|
|
sizeof(ctx), 0);
|
2015-07-17 23:16:47 +08:00
|
|
|
if (!res) {
|
2015-04-11 19:48:01 +08:00
|
|
|
ext4_set_inode_flag(inode, EXT4_INODE_ENCRYPT);
|
2015-07-17 23:16:47 +08:00
|
|
|
res = ext4_mark_inode_dirty(handle, inode);
|
|
|
|
if (res)
|
|
|
|
EXT4_ERROR_INODE(inode, "Failed to mark inode dirty");
|
|
|
|
}
|
|
|
|
res2 = ext4_journal_stop(handle);
|
|
|
|
if (!res)
|
|
|
|
res = res2;
|
2015-04-11 19:48:01 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ext4_process_policy(const struct ext4_encryption_policy *policy,
|
|
|
|
struct inode *inode)
|
|
|
|
{
|
|
|
|
if (policy->version != 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!ext4_inode_has_encryption_context(inode)) {
|
2015-06-01 01:35:14 +08:00
|
|
|
if (!S_ISDIR(inode->i_mode))
|
|
|
|
return -EINVAL;
|
2015-04-11 19:48:01 +08:00
|
|
|
if (!ext4_empty_dir(inode))
|
|
|
|
return -ENOTEMPTY;
|
|
|
|
return ext4_create_encryption_context_from_policy(inode,
|
|
|
|
policy);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ext4_is_encryption_context_consistent_with_policy(inode, policy))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
printk(KERN_WARNING "%s: Policy inconsistent with encryption context\n",
|
|
|
|
__func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ext4_get_policy(struct inode *inode, struct ext4_encryption_policy *policy)
|
|
|
|
{
|
|
|
|
struct ext4_encryption_context ctx;
|
|
|
|
|
|
|
|
int res = ext4_xattr_get(inode, EXT4_XATTR_INDEX_ENCRYPTION,
|
|
|
|
EXT4_XATTR_NAME_ENCRYPTION_CONTEXT,
|
|
|
|
&ctx, sizeof(ctx));
|
|
|
|
if (res != sizeof(ctx))
|
|
|
|
return -ENOENT;
|
|
|
|
if (ctx.format != EXT4_ENCRYPTION_CONTEXT_FORMAT_V1)
|
|
|
|
return -EINVAL;
|
|
|
|
policy->version = 0;
|
|
|
|
policy->contents_encryption_mode = ctx.contents_encryption_mode;
|
|
|
|
policy->filenames_encryption_mode = ctx.filenames_encryption_mode;
|
2015-05-02 04:56:50 +08:00
|
|
|
policy->flags = ctx.flags;
|
2015-04-11 19:48:01 +08:00
|
|
|
memcpy(&policy->master_key_descriptor, ctx.master_key_descriptor,
|
|
|
|
EXT4_KEY_DESCRIPTOR_SIZE);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ext4_is_child_context_consistent_with_parent(struct inode *parent,
|
|
|
|
struct inode *child)
|
|
|
|
{
|
ext4 crypto: reorganize how we store keys in the inode
This is a pretty massive patch which does a number of different things:
1) The per-inode encryption information is now stored in an allocated
data structure, ext4_crypt_info, instead of directly in the node.
This reduces the size usage of an in-memory inode when it is not
using encryption.
2) We drop the ext4_fname_crypto_ctx entirely, and use the per-inode
encryption structure instead. This remove an unnecessary memory
allocation and free for the fname_crypto_ctx as well as allowing us
to reuse the ctfm in a directory for multiple lookups and file
creations.
3) We also cache the inode's policy information in the ext4_crypt_info
structure so we don't have to continually read it out of the
extended attributes.
4) We now keep the keyring key in the inode's encryption structure
instead of releasing it after we are done using it to derive the
per-inode key. This allows us to test to see if the key has been
revoked; if it has, we prevent the use of the derived key and free
it.
5) When an inode is released (or when the derived key is freed), we
will use memset_explicit() to zero out the derived key, so it's not
left hanging around in memory. This implies that when a user logs
out, it is important to first revoke the key, and then unlink it,
and then finally, to use "echo 3 > /proc/sys/vm/drop_caches" to
release any decrypted pages and dcache entries from the system
caches.
6) All this, and we also shrink the number of lines of code by around
100. :-)
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2015-05-19 01:17:47 +08:00
|
|
|
struct ext4_crypt_info *parent_ci, *child_ci;
|
2015-04-11 19:48:01 +08:00
|
|
|
int res;
|
|
|
|
|
|
|
|
if ((parent == NULL) || (child == NULL)) {
|
|
|
|
pr_err("parent %p child %p\n", parent, child);
|
|
|
|
BUG_ON(1);
|
|
|
|
}
|
|
|
|
/* no restrictions if the parent directory is not encrypted */
|
|
|
|
if (!ext4_encrypted_inode(parent))
|
|
|
|
return 1;
|
|
|
|
/* if the child directory is not encrypted, this is always a problem */
|
|
|
|
if (!ext4_encrypted_inode(child))
|
|
|
|
return 0;
|
ext4 crypto: reorganize how we store keys in the inode
This is a pretty massive patch which does a number of different things:
1) The per-inode encryption information is now stored in an allocated
data structure, ext4_crypt_info, instead of directly in the node.
This reduces the size usage of an in-memory inode when it is not
using encryption.
2) We drop the ext4_fname_crypto_ctx entirely, and use the per-inode
encryption structure instead. This remove an unnecessary memory
allocation and free for the fname_crypto_ctx as well as allowing us
to reuse the ctfm in a directory for multiple lookups and file
creations.
3) We also cache the inode's policy information in the ext4_crypt_info
structure so we don't have to continually read it out of the
extended attributes.
4) We now keep the keyring key in the inode's encryption structure
instead of releasing it after we are done using it to derive the
per-inode key. This allows us to test to see if the key has been
revoked; if it has, we prevent the use of the derived key and free
it.
5) When an inode is released (or when the derived key is freed), we
will use memset_explicit() to zero out the derived key, so it's not
left hanging around in memory. This implies that when a user logs
out, it is important to first revoke the key, and then unlink it,
and then finally, to use "echo 3 > /proc/sys/vm/drop_caches" to
release any decrypted pages and dcache entries from the system
caches.
6) All this, and we also shrink the number of lines of code by around
100. :-)
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2015-05-19 01:17:47 +08:00
|
|
|
res = ext4_get_encryption_info(parent);
|
|
|
|
if (res)
|
|
|
|
return 0;
|
|
|
|
res = ext4_get_encryption_info(child);
|
|
|
|
if (res)
|
|
|
|
return 0;
|
|
|
|
parent_ci = EXT4_I(parent)->i_crypt_info;
|
|
|
|
child_ci = EXT4_I(child)->i_crypt_info;
|
|
|
|
if (!parent_ci && !child_ci)
|
|
|
|
return 1;
|
|
|
|
if (!parent_ci || !child_ci)
|
2015-04-11 19:48:01 +08:00
|
|
|
return 0;
|
ext4 crypto: reorganize how we store keys in the inode
This is a pretty massive patch which does a number of different things:
1) The per-inode encryption information is now stored in an allocated
data structure, ext4_crypt_info, instead of directly in the node.
This reduces the size usage of an in-memory inode when it is not
using encryption.
2) We drop the ext4_fname_crypto_ctx entirely, and use the per-inode
encryption structure instead. This remove an unnecessary memory
allocation and free for the fname_crypto_ctx as well as allowing us
to reuse the ctfm in a directory for multiple lookups and file
creations.
3) We also cache the inode's policy information in the ext4_crypt_info
structure so we don't have to continually read it out of the
extended attributes.
4) We now keep the keyring key in the inode's encryption structure
instead of releasing it after we are done using it to derive the
per-inode key. This allows us to test to see if the key has been
revoked; if it has, we prevent the use of the derived key and free
it.
5) When an inode is released (or when the derived key is freed), we
will use memset_explicit() to zero out the derived key, so it's not
left hanging around in memory. This implies that when a user logs
out, it is important to first revoke the key, and then unlink it,
and then finally, to use "echo 3 > /proc/sys/vm/drop_caches" to
release any decrypted pages and dcache entries from the system
caches.
6) All this, and we also shrink the number of lines of code by around
100. :-)
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2015-05-19 01:17:47 +08:00
|
|
|
|
|
|
|
return (memcmp(parent_ci->ci_master_key,
|
|
|
|
child_ci->ci_master_key,
|
2015-04-11 19:48:01 +08:00
|
|
|
EXT4_KEY_DESCRIPTOR_SIZE) == 0 &&
|
ext4 crypto: reorganize how we store keys in the inode
This is a pretty massive patch which does a number of different things:
1) The per-inode encryption information is now stored in an allocated
data structure, ext4_crypt_info, instead of directly in the node.
This reduces the size usage of an in-memory inode when it is not
using encryption.
2) We drop the ext4_fname_crypto_ctx entirely, and use the per-inode
encryption structure instead. This remove an unnecessary memory
allocation and free for the fname_crypto_ctx as well as allowing us
to reuse the ctfm in a directory for multiple lookups and file
creations.
3) We also cache the inode's policy information in the ext4_crypt_info
structure so we don't have to continually read it out of the
extended attributes.
4) We now keep the keyring key in the inode's encryption structure
instead of releasing it after we are done using it to derive the
per-inode key. This allows us to test to see if the key has been
revoked; if it has, we prevent the use of the derived key and free
it.
5) When an inode is released (or when the derived key is freed), we
will use memset_explicit() to zero out the derived key, so it's not
left hanging around in memory. This implies that when a user logs
out, it is important to first revoke the key, and then unlink it,
and then finally, to use "echo 3 > /proc/sys/vm/drop_caches" to
release any decrypted pages and dcache entries from the system
caches.
6) All this, and we also shrink the number of lines of code by around
100. :-)
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2015-05-19 01:17:47 +08:00
|
|
|
(parent_ci->ci_data_mode == child_ci->ci_data_mode) &&
|
|
|
|
(parent_ci->ci_filename_mode == child_ci->ci_filename_mode) &&
|
|
|
|
(parent_ci->ci_flags == child_ci->ci_flags));
|
2015-04-11 19:48:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ext4_inherit_context() - Sets a child context from its parent
|
|
|
|
* @parent: Parent inode from which the context is inherited.
|
|
|
|
* @child: Child inode that inherits the context from @parent.
|
|
|
|
*
|
|
|
|
* Return: Zero on success, non-zero otherwise
|
|
|
|
*/
|
|
|
|
int ext4_inherit_context(struct inode *parent, struct inode *child)
|
|
|
|
{
|
|
|
|
struct ext4_encryption_context ctx;
|
ext4 crypto: reorganize how we store keys in the inode
This is a pretty massive patch which does a number of different things:
1) The per-inode encryption information is now stored in an allocated
data structure, ext4_crypt_info, instead of directly in the node.
This reduces the size usage of an in-memory inode when it is not
using encryption.
2) We drop the ext4_fname_crypto_ctx entirely, and use the per-inode
encryption structure instead. This remove an unnecessary memory
allocation and free for the fname_crypto_ctx as well as allowing us
to reuse the ctfm in a directory for multiple lookups and file
creations.
3) We also cache the inode's policy information in the ext4_crypt_info
structure so we don't have to continually read it out of the
extended attributes.
4) We now keep the keyring key in the inode's encryption structure
instead of releasing it after we are done using it to derive the
per-inode key. This allows us to test to see if the key has been
revoked; if it has, we prevent the use of the derived key and free
it.
5) When an inode is released (or when the derived key is freed), we
will use memset_explicit() to zero out the derived key, so it's not
left hanging around in memory. This implies that when a user logs
out, it is important to first revoke the key, and then unlink it,
and then finally, to use "echo 3 > /proc/sys/vm/drop_caches" to
release any decrypted pages and dcache entries from the system
caches.
6) All this, and we also shrink the number of lines of code by around
100. :-)
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2015-05-19 01:17:47 +08:00
|
|
|
struct ext4_crypt_info *ci;
|
|
|
|
int res;
|
|
|
|
|
|
|
|
res = ext4_get_encryption_info(parent);
|
|
|
|
if (res < 0)
|
|
|
|
return res;
|
|
|
|
ci = EXT4_I(parent)->i_crypt_info;
|
2015-06-01 01:35:39 +08:00
|
|
|
if (ci == NULL)
|
|
|
|
return -ENOKEY;
|
2015-04-11 19:48:01 +08:00
|
|
|
|
ext4 crypto: reorganize how we store keys in the inode
This is a pretty massive patch which does a number of different things:
1) The per-inode encryption information is now stored in an allocated
data structure, ext4_crypt_info, instead of directly in the node.
This reduces the size usage of an in-memory inode when it is not
using encryption.
2) We drop the ext4_fname_crypto_ctx entirely, and use the per-inode
encryption structure instead. This remove an unnecessary memory
allocation and free for the fname_crypto_ctx as well as allowing us
to reuse the ctfm in a directory for multiple lookups and file
creations.
3) We also cache the inode's policy information in the ext4_crypt_info
structure so we don't have to continually read it out of the
extended attributes.
4) We now keep the keyring key in the inode's encryption structure
instead of releasing it after we are done using it to derive the
per-inode key. This allows us to test to see if the key has been
revoked; if it has, we prevent the use of the derived key and free
it.
5) When an inode is released (or when the derived key is freed), we
will use memset_explicit() to zero out the derived key, so it's not
left hanging around in memory. This implies that when a user logs
out, it is important to first revoke the key, and then unlink it,
and then finally, to use "echo 3 > /proc/sys/vm/drop_caches" to
release any decrypted pages and dcache entries from the system
caches.
6) All this, and we also shrink the number of lines of code by around
100. :-)
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2015-05-19 01:17:47 +08:00
|
|
|
ctx.format = EXT4_ENCRYPTION_CONTEXT_FORMAT_V1;
|
|
|
|
if (DUMMY_ENCRYPTION_ENABLED(EXT4_SB(parent->i_sb))) {
|
|
|
|
ctx.contents_encryption_mode = EXT4_ENCRYPTION_MODE_AES_256_XTS;
|
|
|
|
ctx.filenames_encryption_mode =
|
|
|
|
EXT4_ENCRYPTION_MODE_AES_256_CTS;
|
|
|
|
ctx.flags = 0;
|
|
|
|
memset(ctx.master_key_descriptor, 0x42,
|
|
|
|
EXT4_KEY_DESCRIPTOR_SIZE);
|
|
|
|
res = 0;
|
|
|
|
} else {
|
|
|
|
ctx.contents_encryption_mode = ci->ci_data_mode;
|
|
|
|
ctx.filenames_encryption_mode = ci->ci_filename_mode;
|
|
|
|
ctx.flags = ci->ci_flags;
|
|
|
|
memcpy(ctx.master_key_descriptor, ci->ci_master_key,
|
|
|
|
EXT4_KEY_DESCRIPTOR_SIZE);
|
2015-04-16 13:56:00 +08:00
|
|
|
}
|
2015-04-11 19:48:01 +08:00
|
|
|
get_random_bytes(ctx.nonce, EXT4_KEY_DERIVATION_NONCE_SIZE);
|
|
|
|
res = ext4_xattr_set(child, EXT4_XATTR_INDEX_ENCRYPTION,
|
|
|
|
EXT4_XATTR_NAME_ENCRYPTION_CONTEXT, &ctx,
|
|
|
|
sizeof(ctx), 0);
|
2015-05-19 01:18:47 +08:00
|
|
|
if (!res) {
|
2015-04-11 19:48:01 +08:00
|
|
|
ext4_set_inode_flag(child, EXT4_INODE_ENCRYPT);
|
2015-05-19 01:18:47 +08:00
|
|
|
ext4_clear_inode_state(child, EXT4_STATE_MAY_INLINE_DATA);
|
2015-06-01 01:34:29 +08:00
|
|
|
res = ext4_get_encryption_info(child);
|
2015-05-19 01:18:47 +08:00
|
|
|
}
|
2015-04-11 19:48:01 +08:00
|
|
|
return res;
|
|
|
|
}
|