mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-25 13:43:55 +08:00
7130098096
userspace utilities to change the file system's UUID without rewriting all of the file system metadata. A number of miscellaneous fixes, the most significant of which are in the ext4 encryption support. Anyone wishing to use the encryption feature should backport all of the ext4 crypto patches up to 4.4 to get fixes to a memory leak and file system corruption bug. There are also cleanups in ext4's feature test macros and in ext4's sysfs support code. -----BEGIN PGP SIGNATURE----- Version: GnuPG v2 iQEcBAABCAAGBQJWPMOAAAoJEPL5WVaVDYGjDYAH/jVIz+WpPkZn/J1Oepy1WPDm Azxv+tUvKffXQ7sRwGZEU7snLaeamKxtrvHUXKLT4PIQB6m6o4/kk8o71ovv5PRT FvuMz1j7qsqEk5ZFQnqI7xosao/RovjfkvL5g+WsAN//C+vxO35bg4fVvZmf73GQ vloe6igM/qxiUAuMX0jlXjUI1Zyo+H3bXOC6LjnUCOPwZMRcQ9zMtoYjkWryTzo1 4udepGRSfcWeZkWXqt9KIe6slYRmq3BtXWJ0+Zvx6gKWrXVIisINLDHYAEVBXAf4 6VUiDKL6wIytkwt3vGwYSY11wNQC5ky3qV/tJlPnpbYfUP0vEvT4UXljoaR/YQc= =m3Q9 -----END PGP SIGNATURE----- Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4 Pull ext4 updates from Ted Ts'o: "Add support for the CSUM_SEED feature which will allow future userspace utilities to change the file system's UUID without rewriting all of the file system metadata. A number of miscellaneous fixes, the most significant of which are in the ext4 encryption support. Anyone wishing to use the encryption feature should backport all of the ext4 crypto patches up to 4.4 to get fixes to a memory leak and file system corruption bug. There are also cleanups in ext4's feature test macros and in ext4's sysfs support code" * tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (26 commits) fs/ext4: remove unnecessary new_valid_dev check ext4: fix abs() usage in ext4_mb_check_group_pa ext4: do not allow journal_opts for fs w/o journal ext4: explicit mount options parsing cleanup ext4, jbd2: ensure entering into panic after recording an error in superblock [PATCH] fix calculation of meta_bg descriptor backups ext4: fix potential use after free in __ext4_journal_stop jbd2: fix checkpoint list cleanup ext4: fix xfstest generic/269 double revoked buffer bug with bigalloc ext4: make the bitmap read routines return real error codes jbd2: clean up feature test macros with predicate functions ext4: clean up feature test macros with predicate functions ext4: call out CRC and corruption errors with specific error codes ext4: store checksum seed in superblock ext4: reserve code points for the project quota feature ext4: promote ext4 over ext2 in the default probe order jbd2: gate checksum calculations on crc driver presence, not sb flags ext4: use private version of page_zero_new_buffers() for data=journal mode ext4 crypto: fix bugs in ext4_encrypted_zeroout() ext4 crypto: replace some BUG_ON()'s with error checks ...
273 lines
7.1 KiB
C
273 lines
7.1 KiB
C
/*
|
|
* linux/fs/ext4/crypto_key.c
|
|
*
|
|
* Copyright (C) 2015, Google, Inc.
|
|
*
|
|
* This contains encryption key functions for ext4
|
|
*
|
|
* Written by Michael Halcrow, Ildar Muslukhov, and Uday Savagaonkar, 2015.
|
|
*/
|
|
|
|
#include <keys/encrypted-type.h>
|
|
#include <keys/user-type.h>
|
|
#include <linux/random.h>
|
|
#include <linux/scatterlist.h>
|
|
#include <uapi/linux/keyctl.h>
|
|
|
|
#include "ext4.h"
|
|
#include "xattr.h"
|
|
|
|
static void derive_crypt_complete(struct crypto_async_request *req, int rc)
|
|
{
|
|
struct ext4_completion_result *ecr = req->data;
|
|
|
|
if (rc == -EINPROGRESS)
|
|
return;
|
|
|
|
ecr->res = rc;
|
|
complete(&ecr->completion);
|
|
}
|
|
|
|
/**
|
|
* ext4_derive_key_aes() - Derive a key using AES-128-ECB
|
|
* @deriving_key: Encryption key used for derivation.
|
|
* @source_key: Source key to which to apply derivation.
|
|
* @derived_key: Derived key.
|
|
*
|
|
* Return: Zero on success; non-zero otherwise.
|
|
*/
|
|
static int ext4_derive_key_aes(char deriving_key[EXT4_AES_128_ECB_KEY_SIZE],
|
|
char source_key[EXT4_AES_256_XTS_KEY_SIZE],
|
|
char derived_key[EXT4_AES_256_XTS_KEY_SIZE])
|
|
{
|
|
int res = 0;
|
|
struct ablkcipher_request *req = NULL;
|
|
DECLARE_EXT4_COMPLETION_RESULT(ecr);
|
|
struct scatterlist src_sg, dst_sg;
|
|
struct crypto_ablkcipher *tfm = crypto_alloc_ablkcipher("ecb(aes)", 0,
|
|
0);
|
|
|
|
if (IS_ERR(tfm)) {
|
|
res = PTR_ERR(tfm);
|
|
tfm = NULL;
|
|
goto out;
|
|
}
|
|
crypto_ablkcipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
|
|
req = ablkcipher_request_alloc(tfm, GFP_NOFS);
|
|
if (!req) {
|
|
res = -ENOMEM;
|
|
goto out;
|
|
}
|
|
ablkcipher_request_set_callback(req,
|
|
CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,
|
|
derive_crypt_complete, &ecr);
|
|
res = crypto_ablkcipher_setkey(tfm, deriving_key,
|
|
EXT4_AES_128_ECB_KEY_SIZE);
|
|
if (res < 0)
|
|
goto out;
|
|
sg_init_one(&src_sg, source_key, EXT4_AES_256_XTS_KEY_SIZE);
|
|
sg_init_one(&dst_sg, derived_key, EXT4_AES_256_XTS_KEY_SIZE);
|
|
ablkcipher_request_set_crypt(req, &src_sg, &dst_sg,
|
|
EXT4_AES_256_XTS_KEY_SIZE, NULL);
|
|
res = crypto_ablkcipher_encrypt(req);
|
|
if (res == -EINPROGRESS || res == -EBUSY) {
|
|
wait_for_completion(&ecr.completion);
|
|
res = ecr.res;
|
|
}
|
|
|
|
out:
|
|
if (req)
|
|
ablkcipher_request_free(req);
|
|
if (tfm)
|
|
crypto_free_ablkcipher(tfm);
|
|
return res;
|
|
}
|
|
|
|
void ext4_free_crypt_info(struct ext4_crypt_info *ci)
|
|
{
|
|
if (!ci)
|
|
return;
|
|
|
|
if (ci->ci_keyring_key)
|
|
key_put(ci->ci_keyring_key);
|
|
crypto_free_ablkcipher(ci->ci_ctfm);
|
|
kmem_cache_free(ext4_crypt_info_cachep, ci);
|
|
}
|
|
|
|
void ext4_free_encryption_info(struct inode *inode,
|
|
struct ext4_crypt_info *ci)
|
|
{
|
|
struct ext4_inode_info *ei = EXT4_I(inode);
|
|
struct ext4_crypt_info *prev;
|
|
|
|
if (ci == NULL)
|
|
ci = ACCESS_ONCE(ei->i_crypt_info);
|
|
if (ci == NULL)
|
|
return;
|
|
prev = cmpxchg(&ei->i_crypt_info, ci, NULL);
|
|
if (prev != ci)
|
|
return;
|
|
|
|
ext4_free_crypt_info(ci);
|
|
}
|
|
|
|
int _ext4_get_encryption_info(struct inode *inode)
|
|
{
|
|
struct ext4_inode_info *ei = EXT4_I(inode);
|
|
struct ext4_crypt_info *crypt_info;
|
|
char full_key_descriptor[EXT4_KEY_DESC_PREFIX_SIZE +
|
|
(EXT4_KEY_DESCRIPTOR_SIZE * 2) + 1];
|
|
struct key *keyring_key = NULL;
|
|
struct ext4_encryption_key *master_key;
|
|
struct ext4_encryption_context ctx;
|
|
const struct user_key_payload *ukp;
|
|
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
|
|
struct crypto_ablkcipher *ctfm;
|
|
const char *cipher_str;
|
|
char raw_key[EXT4_MAX_KEY_SIZE];
|
|
char mode;
|
|
int res;
|
|
|
|
if (!ext4_read_workqueue) {
|
|
res = ext4_init_crypto();
|
|
if (res)
|
|
return res;
|
|
}
|
|
|
|
retry:
|
|
crypt_info = ACCESS_ONCE(ei->i_crypt_info);
|
|
if (crypt_info) {
|
|
if (!crypt_info->ci_keyring_key ||
|
|
key_validate(crypt_info->ci_keyring_key) == 0)
|
|
return 0;
|
|
ext4_free_encryption_info(inode, crypt_info);
|
|
goto retry;
|
|
}
|
|
|
|
res = ext4_xattr_get(inode, EXT4_XATTR_INDEX_ENCRYPTION,
|
|
EXT4_XATTR_NAME_ENCRYPTION_CONTEXT,
|
|
&ctx, sizeof(ctx));
|
|
if (res < 0) {
|
|
if (!DUMMY_ENCRYPTION_ENABLED(sbi))
|
|
return res;
|
|
ctx.contents_encryption_mode = EXT4_ENCRYPTION_MODE_AES_256_XTS;
|
|
ctx.filenames_encryption_mode =
|
|
EXT4_ENCRYPTION_MODE_AES_256_CTS;
|
|
ctx.flags = 0;
|
|
} else if (res != sizeof(ctx))
|
|
return -EINVAL;
|
|
res = 0;
|
|
|
|
crypt_info = kmem_cache_alloc(ext4_crypt_info_cachep, GFP_KERNEL);
|
|
if (!crypt_info)
|
|
return -ENOMEM;
|
|
|
|
crypt_info->ci_flags = ctx.flags;
|
|
crypt_info->ci_data_mode = ctx.contents_encryption_mode;
|
|
crypt_info->ci_filename_mode = ctx.filenames_encryption_mode;
|
|
crypt_info->ci_ctfm = NULL;
|
|
crypt_info->ci_keyring_key = NULL;
|
|
memcpy(crypt_info->ci_master_key, ctx.master_key_descriptor,
|
|
sizeof(crypt_info->ci_master_key));
|
|
if (S_ISREG(inode->i_mode))
|
|
mode = crypt_info->ci_data_mode;
|
|
else if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
|
|
mode = crypt_info->ci_filename_mode;
|
|
else
|
|
BUG();
|
|
switch (mode) {
|
|
case EXT4_ENCRYPTION_MODE_AES_256_XTS:
|
|
cipher_str = "xts(aes)";
|
|
break;
|
|
case EXT4_ENCRYPTION_MODE_AES_256_CTS:
|
|
cipher_str = "cts(cbc(aes))";
|
|
break;
|
|
default:
|
|
printk_once(KERN_WARNING
|
|
"ext4: unsupported key mode %d (ino %u)\n",
|
|
mode, (unsigned) inode->i_ino);
|
|
res = -ENOKEY;
|
|
goto out;
|
|
}
|
|
if (DUMMY_ENCRYPTION_ENABLED(sbi)) {
|
|
memset(raw_key, 0x42, EXT4_AES_256_XTS_KEY_SIZE);
|
|
goto got_key;
|
|
}
|
|
memcpy(full_key_descriptor, EXT4_KEY_DESC_PREFIX,
|
|
EXT4_KEY_DESC_PREFIX_SIZE);
|
|
sprintf(full_key_descriptor + EXT4_KEY_DESC_PREFIX_SIZE,
|
|
"%*phN", EXT4_KEY_DESCRIPTOR_SIZE,
|
|
ctx.master_key_descriptor);
|
|
full_key_descriptor[EXT4_KEY_DESC_PREFIX_SIZE +
|
|
(2 * EXT4_KEY_DESCRIPTOR_SIZE)] = '\0';
|
|
keyring_key = request_key(&key_type_logon, full_key_descriptor, NULL);
|
|
if (IS_ERR(keyring_key)) {
|
|
res = PTR_ERR(keyring_key);
|
|
keyring_key = NULL;
|
|
goto out;
|
|
}
|
|
crypt_info->ci_keyring_key = keyring_key;
|
|
if (keyring_key->type != &key_type_logon) {
|
|
printk_once(KERN_WARNING
|
|
"ext4: key type must be logon\n");
|
|
res = -ENOKEY;
|
|
goto out;
|
|
}
|
|
ukp = user_key_payload(keyring_key);
|
|
if (ukp->datalen != sizeof(struct ext4_encryption_key)) {
|
|
res = -EINVAL;
|
|
goto out;
|
|
}
|
|
master_key = (struct ext4_encryption_key *)ukp->data;
|
|
BUILD_BUG_ON(EXT4_AES_128_ECB_KEY_SIZE !=
|
|
EXT4_KEY_DERIVATION_NONCE_SIZE);
|
|
if (master_key->size != EXT4_AES_256_XTS_KEY_SIZE) {
|
|
printk_once(KERN_WARNING
|
|
"ext4: key size incorrect: %d\n",
|
|
master_key->size);
|
|
res = -ENOKEY;
|
|
goto out;
|
|
}
|
|
res = ext4_derive_key_aes(ctx.nonce, master_key->raw,
|
|
raw_key);
|
|
if (res)
|
|
goto out;
|
|
got_key:
|
|
ctfm = crypto_alloc_ablkcipher(cipher_str, 0, 0);
|
|
if (!ctfm || IS_ERR(ctfm)) {
|
|
res = ctfm ? PTR_ERR(ctfm) : -ENOMEM;
|
|
printk(KERN_DEBUG
|
|
"%s: error %d (inode %u) allocating crypto tfm\n",
|
|
__func__, res, (unsigned) inode->i_ino);
|
|
goto out;
|
|
}
|
|
crypt_info->ci_ctfm = ctfm;
|
|
crypto_ablkcipher_clear_flags(ctfm, ~0);
|
|
crypto_tfm_set_flags(crypto_ablkcipher_tfm(ctfm),
|
|
CRYPTO_TFM_REQ_WEAK_KEY);
|
|
res = crypto_ablkcipher_setkey(ctfm, raw_key,
|
|
ext4_encryption_key_size(mode));
|
|
if (res)
|
|
goto out;
|
|
memzero_explicit(raw_key, sizeof(raw_key));
|
|
if (cmpxchg(&ei->i_crypt_info, NULL, crypt_info) != NULL) {
|
|
ext4_free_crypt_info(crypt_info);
|
|
goto retry;
|
|
}
|
|
return 0;
|
|
|
|
out:
|
|
if (res == -ENOKEY)
|
|
res = 0;
|
|
ext4_free_crypt_info(crypt_info);
|
|
memzero_explicit(raw_key, sizeof(raw_key));
|
|
return res;
|
|
}
|
|
|
|
int ext4_has_encryption_key(struct inode *inode)
|
|
{
|
|
struct ext4_inode_info *ei = EXT4_I(inode);
|
|
|
|
return (ei->i_crypt_info != NULL);
|
|
}
|