mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-28 10:41:38 -04:00
Merge remote-tracking branch 'aosp/upstream-f2fs-stable-linux-5.4.y' into android-5.4-stable
* aosp/upstream-f2fs-stable-linux-5.4.y:
fs-verity: remove unnecessary extern keywords
fs-verity: fix all kerneldoc warnings
fscrypt: add support for IV_INO_LBLK_32 policies
fscrypt: make test_dummy_encryption use v2 by default
fscrypt: support test_dummy_encryption=v2
fscrypt: add fscrypt_add_test_dummy_key()
linux/parser.h: add include guards
fscrypt: remove unnecessary extern keywords
fscrypt: name all function parameters
fscrypt: fix all kerneldoc warnings
Conflicts:
fs/crypto/fscrypt_private.h
fs/crypto/keyring.c
fs/crypto/keysetup.c
fs/ext4/ext4.h
fs/ext4/super.c
fs/f2fs/f2fs.h
fs/f2fs/super.c
include/linux/fscrypt.h
Resolved the conflicts as per the corresponding android-mainline change,
I7198edbca759839aceeec2598e7a81305756c4d7.
Bug: 154167995
Test: kvm-xfstests -c ext4,f2fs,ext4/encrypt,f2fs/encrypt \
-g encrypt -g verity -g casefold
kvm-xfstests -c ext4,f2fs,ext4/encrypt,f2fs/encrypt \
-g encrypt -g verity -g casefold -m inlinecrypt
Change-Id: Id12839f7948374575f9d15eee6a9c6a9382eacf3
Signed-off-by: Eric Biggers <[email protected]>
This commit is contained in:
Eric Biggers
commit
d32db25eea
23 changed files with 637 additions and 300 deletions
|
|
@ -54,6 +54,7 @@ struct page *fscrypt_alloc_bounce_page(gfp_t gfp_flags)
|
|||
|
||||
/**
|
||||
* fscrypt_free_bounce_page() - free a ciphertext bounce page
|
||||
* @bounce_page: the bounce page to free, or NULL
|
||||
*
|
||||
* Free a bounce page that was allocated by fscrypt_encrypt_pagecache_blocks(),
|
||||
* or by fscrypt_alloc_bounce_page() directly.
|
||||
|
|
@ -144,7 +145,8 @@ int fscrypt_crypt_block(const struct inode *inode, fscrypt_direction_t rw,
|
|||
}
|
||||
|
||||
/**
|
||||
* fscrypt_encrypt_pagecache_blocks() - Encrypt filesystem blocks from a pagecache page
|
||||
* fscrypt_encrypt_pagecache_blocks() - Encrypt filesystem blocks from a
|
||||
* pagecache page
|
||||
* @page: The locked pagecache page containing the block(s) to encrypt
|
||||
* @len: Total size of the block(s) to encrypt. Must be a nonzero
|
||||
* multiple of the filesystem's block size.
|
||||
|
|
@ -234,7 +236,8 @@ int fscrypt_encrypt_block_inplace(const struct inode *inode, struct page *page,
|
|||
EXPORT_SYMBOL(fscrypt_encrypt_block_inplace);
|
||||
|
||||
/**
|
||||
* fscrypt_decrypt_pagecache_blocks() - Decrypt filesystem blocks in a pagecache page
|
||||
* fscrypt_decrypt_pagecache_blocks() - Decrypt filesystem blocks in a
|
||||
* pagecache page
|
||||
* @page: The locked pagecache page containing the block(s) to decrypt
|
||||
* @len: Total size of the block(s) to decrypt. Must be a nonzero
|
||||
* multiple of the filesystem's block size.
|
||||
|
|
@ -358,6 +361,8 @@ void fscrypt_msg(const struct inode *inode, const char *level,
|
|||
|
||||
/**
|
||||
* fscrypt_init() - Set up for fs encryption.
|
||||
*
|
||||
* Return: 0 on success; -errno on failure
|
||||
*/
|
||||
static int __init fscrypt_init(void)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@
|
|||
#include <crypto/skcipher.h>
|
||||
#include "fscrypt_private.h"
|
||||
|
||||
/**
|
||||
/*
|
||||
* struct fscrypt_nokey_name - identifier for directory entry when key is absent
|
||||
*
|
||||
* When userspace lists an encrypted directory without access to the key, the
|
||||
|
|
@ -105,9 +105,12 @@ static inline bool fscrypt_is_dot_dotdot(const struct qstr *str)
|
|||
|
||||
/**
|
||||
* fscrypt_fname_encrypt() - encrypt a filename
|
||||
*
|
||||
* The output buffer must be at least as large as the input buffer.
|
||||
* Any extra space is filled with NUL padding before encryption.
|
||||
* @inode: inode of the parent directory (for regular filenames)
|
||||
* or of the symlink (for symlink targets)
|
||||
* @iname: the filename to encrypt
|
||||
* @out: (output) the encrypted filename
|
||||
* @olen: size of the encrypted filename. It must be at least @iname->len.
|
||||
* Any extra space is filled with NUL padding before encryption.
|
||||
*
|
||||
* Return: 0 on success, -errno on failure
|
||||
*/
|
||||
|
|
@ -157,8 +160,11 @@ int fscrypt_fname_encrypt(const struct inode *inode, const struct qstr *iname,
|
|||
|
||||
/**
|
||||
* fname_decrypt() - decrypt a filename
|
||||
*
|
||||
* The caller must have allocated sufficient memory for the @oname string.
|
||||
* @inode: inode of the parent directory (for regular filenames)
|
||||
* or of the symlink (for symlink targets)
|
||||
* @iname: the encrypted filename to decrypt
|
||||
* @oname: (output) the decrypted filename. The caller must have allocated
|
||||
* enough space for this, e.g. using fscrypt_fname_alloc_buffer().
|
||||
*
|
||||
* Return: 0 on success, -errno on failure
|
||||
*/
|
||||
|
|
@ -206,7 +212,10 @@ static const char lookup_table[65] =
|
|||
#define BASE64_CHARS(nbytes) DIV_ROUND_UP((nbytes) * 4, 3)
|
||||
|
||||
/**
|
||||
* base64_encode() -
|
||||
* base64_encode() - base64-encode some bytes
|
||||
* @src: the bytes to encode
|
||||
* @len: number of bytes to encode
|
||||
* @dst: (output) the base64-encoded string. Not NUL-terminated.
|
||||
*
|
||||
* Encodes the input string using characters from the set [A-Za-z0-9+,].
|
||||
* The encoded string is roughly 4/3 times the size of the input string.
|
||||
|
|
@ -272,7 +281,12 @@ bool fscrypt_fname_encrypted_size(const struct inode *inode, u32 orig_len,
|
|||
}
|
||||
|
||||
/**
|
||||
* fscrypt_fname_alloc_buffer - allocate a buffer for presented filenames
|
||||
* fscrypt_fname_alloc_buffer() - allocate a buffer for presented filenames
|
||||
* @inode: inode of the parent directory (for regular filenames)
|
||||
* or of the symlink (for symlink targets)
|
||||
* @max_encrypted_len: maximum length of encrypted filenames the buffer will be
|
||||
* used to present
|
||||
* @crypto_str: (output) buffer to allocate
|
||||
*
|
||||
* Allocate a buffer that is large enough to hold any decrypted or encoded
|
||||
* filename (null-terminated), for the given maximum encrypted filename length.
|
||||
|
|
@ -297,9 +311,10 @@ int fscrypt_fname_alloc_buffer(const struct inode *inode,
|
|||
EXPORT_SYMBOL(fscrypt_fname_alloc_buffer);
|
||||
|
||||
/**
|
||||
* fscrypt_fname_free_buffer - free the buffer for presented filenames
|
||||
* fscrypt_fname_free_buffer() - free a buffer for presented filenames
|
||||
* @crypto_str: the buffer to free
|
||||
*
|
||||
* Free the buffer allocated by fscrypt_fname_alloc_buffer().
|
||||
* Free a buffer that was allocated by fscrypt_fname_alloc_buffer().
|
||||
*/
|
||||
void fscrypt_fname_free_buffer(struct fscrypt_str *crypto_str)
|
||||
{
|
||||
|
|
@ -311,10 +326,19 @@ void fscrypt_fname_free_buffer(struct fscrypt_str *crypto_str)
|
|||
EXPORT_SYMBOL(fscrypt_fname_free_buffer);
|
||||
|
||||
/**
|
||||
* fscrypt_fname_disk_to_usr() - converts a filename from disk space to user
|
||||
* space
|
||||
*
|
||||
* The caller must have allocated sufficient memory for the @oname string.
|
||||
* fscrypt_fname_disk_to_usr() - convert an encrypted filename to
|
||||
* user-presentable form
|
||||
* @inode: inode of the parent directory (for regular filenames)
|
||||
* or of the symlink (for symlink targets)
|
||||
* @hash: first part of the name's dirhash, if applicable. This only needs to
|
||||
* be provided if the filename is located in an indexed directory whose
|
||||
* encryption key may be unavailable. Not needed for symlink targets.
|
||||
* @minor_hash: second part of the name's dirhash, if applicable
|
||||
* @iname: encrypted filename to convert. May also be "." or "..", which
|
||||
* aren't actually encrypted.
|
||||
* @oname: output buffer for the user-presentable filename. The caller must
|
||||
* have allocated enough space for this, e.g. using
|
||||
* fscrypt_fname_alloc_buffer().
|
||||
*
|
||||
* If the key is available, we'll decrypt the disk name. Otherwise, we'll
|
||||
* encode it for presentation in fscrypt_nokey_name format.
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ struct fscrypt_context_v2 {
|
|||
u8 nonce[FS_KEY_DERIVATION_NONCE_SIZE];
|
||||
};
|
||||
|
||||
/**
|
||||
/*
|
||||
* fscrypt_context - the encryption context of an inode
|
||||
*
|
||||
* This is the on-disk equivalent of an fscrypt_policy, stored alongside each
|
||||
|
|
@ -159,7 +159,7 @@ fscrypt_policy_flags(const union fscrypt_policy *policy)
|
|||
BUG();
|
||||
}
|
||||
|
||||
/**
|
||||
/*
|
||||
* For encrypted symlinks, the ciphertext length is stored at the beginning
|
||||
* of the string in little-endian format.
|
||||
*/
|
||||
|
|
@ -258,15 +258,14 @@ typedef enum {
|
|||
|
||||
/* crypto.c */
|
||||
extern struct kmem_cache *fscrypt_info_cachep;
|
||||
extern int fscrypt_initialize(unsigned int cop_flags);
|
||||
extern int fscrypt_crypt_block(const struct inode *inode,
|
||||
fscrypt_direction_t rw, u64 lblk_num,
|
||||
struct page *src_page, struct page *dest_page,
|
||||
unsigned int len, unsigned int offs,
|
||||
gfp_t gfp_flags);
|
||||
extern struct page *fscrypt_alloc_bounce_page(gfp_t gfp_flags);
|
||||
int fscrypt_initialize(unsigned int cop_flags);
|
||||
int fscrypt_crypt_block(const struct inode *inode, fscrypt_direction_t rw,
|
||||
u64 lblk_num, struct page *src_page,
|
||||
struct page *dest_page, unsigned int len,
|
||||
unsigned int offs, gfp_t gfp_flags);
|
||||
struct page *fscrypt_alloc_bounce_page(gfp_t gfp_flags);
|
||||
|
||||
extern void __printf(3, 4) __cold
|
||||
void __printf(3, 4) __cold
|
||||
fscrypt_msg(const struct inode *inode, const char *level, const char *fmt, ...);
|
||||
|
||||
#define fscrypt_warn(inode, fmt, ...) \
|
||||
|
|
@ -292,12 +291,10 @@ void fscrypt_generate_iv(union fscrypt_iv *iv, u64 lblk_num,
|
|||
const struct fscrypt_info *ci);
|
||||
|
||||
/* fname.c */
|
||||
extern int fscrypt_fname_encrypt(const struct inode *inode,
|
||||
const struct qstr *iname,
|
||||
u8 *out, unsigned int olen);
|
||||
extern bool fscrypt_fname_encrypted_size(const struct inode *inode,
|
||||
u32 orig_len, u32 max_len,
|
||||
u32 *encrypted_len_ret);
|
||||
int fscrypt_fname_encrypt(const struct inode *inode, const struct qstr *iname,
|
||||
u8 *out, unsigned int olen);
|
||||
bool fscrypt_fname_encrypted_size(const struct inode *inode, u32 orig_len,
|
||||
u32 max_len, u32 *encrypted_len_ret);
|
||||
|
||||
/* hkdf.c */
|
||||
|
||||
|
|
@ -305,8 +302,8 @@ struct fscrypt_hkdf {
|
|||
struct crypto_shash *hmac_tfm;
|
||||
};
|
||||
|
||||
extern int fscrypt_init_hkdf(struct fscrypt_hkdf *hkdf, const u8 *master_key,
|
||||
unsigned int master_key_size);
|
||||
int fscrypt_init_hkdf(struct fscrypt_hkdf *hkdf, const u8 *master_key,
|
||||
unsigned int master_key_size);
|
||||
|
||||
/*
|
||||
* The list of contexts in which fscrypt uses HKDF. These values are used as
|
||||
|
|
@ -323,11 +320,11 @@ extern int fscrypt_init_hkdf(struct fscrypt_hkdf *hkdf, const u8 *master_key,
|
|||
#define HKDF_CONTEXT_IV_INO_LBLK_32_KEY 6
|
||||
#define HKDF_CONTEXT_INODE_HASH_KEY 7
|
||||
|
||||
extern int fscrypt_hkdf_expand(const struct fscrypt_hkdf *hkdf, u8 context,
|
||||
const u8 *info, unsigned int infolen,
|
||||
u8 *okm, unsigned int okmlen);
|
||||
int fscrypt_hkdf_expand(const struct fscrypt_hkdf *hkdf, u8 context,
|
||||
const u8 *info, unsigned int infolen,
|
||||
u8 *okm, unsigned int okmlen);
|
||||
|
||||
extern void fscrypt_destroy_hkdf(struct fscrypt_hkdf *hkdf);
|
||||
void fscrypt_destroy_hkdf(struct fscrypt_hkdf *hkdf);
|
||||
|
||||
/* inline_crypt.c */
|
||||
#ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
|
||||
|
|
@ -568,14 +565,17 @@ static inline int master_key_spec_len(const struct fscrypt_key_specifier *spec)
|
|||
return 0;
|
||||
}
|
||||
|
||||
extern struct key *
|
||||
struct key *
|
||||
fscrypt_find_master_key(struct super_block *sb,
|
||||
const struct fscrypt_key_specifier *mk_spec);
|
||||
|
||||
extern int fscrypt_verify_key_added(struct super_block *sb,
|
||||
const u8 identifier[FSCRYPT_KEY_IDENTIFIER_SIZE]);
|
||||
int fscrypt_add_test_dummy_key(struct super_block *sb,
|
||||
struct fscrypt_key_specifier *key_spec);
|
||||
|
||||
extern int __init fscrypt_init_keyring(void);
|
||||
int fscrypt_verify_key_added(struct super_block *sb,
|
||||
const u8 identifier[FSCRYPT_KEY_IDENTIFIER_SIZE]);
|
||||
|
||||
int __init fscrypt_init_keyring(void);
|
||||
|
||||
/* keysetup.c */
|
||||
|
||||
|
|
@ -590,36 +590,34 @@ struct fscrypt_mode {
|
|||
|
||||
extern struct fscrypt_mode fscrypt_modes[];
|
||||
|
||||
extern int fscrypt_prepare_key(struct fscrypt_prepared_key *prep_key,
|
||||
const u8 *raw_key, unsigned int raw_key_size,
|
||||
bool is_hw_wrapped,
|
||||
const struct fscrypt_info *ci);
|
||||
int fscrypt_prepare_key(struct fscrypt_prepared_key *prep_key,
|
||||
const u8 *raw_key, unsigned int raw_key_size,
|
||||
bool is_hw_wrapped, const struct fscrypt_info *ci);
|
||||
|
||||
extern void fscrypt_destroy_prepared_key(struct fscrypt_prepared_key *prep_key);
|
||||
void fscrypt_destroy_prepared_key(struct fscrypt_prepared_key *prep_key);
|
||||
|
||||
extern int fscrypt_set_per_file_enc_key(struct fscrypt_info *ci,
|
||||
const u8 *raw_key);
|
||||
int fscrypt_set_per_file_enc_key(struct fscrypt_info *ci, const u8 *raw_key);
|
||||
|
||||
extern int fscrypt_derive_dirhash_key(struct fscrypt_info *ci,
|
||||
const struct fscrypt_master_key *mk);
|
||||
int fscrypt_derive_dirhash_key(struct fscrypt_info *ci,
|
||||
const struct fscrypt_master_key *mk);
|
||||
|
||||
/* keysetup_v1.c */
|
||||
|
||||
extern void fscrypt_put_direct_key(struct fscrypt_direct_key *dk);
|
||||
void fscrypt_put_direct_key(struct fscrypt_direct_key *dk);
|
||||
|
||||
extern int fscrypt_setup_v1_file_key(struct fscrypt_info *ci,
|
||||
const u8 *raw_master_key);
|
||||
int fscrypt_setup_v1_file_key(struct fscrypt_info *ci,
|
||||
const u8 *raw_master_key);
|
||||
|
||||
int fscrypt_setup_v1_file_key_via_subscribed_keyrings(struct fscrypt_info *ci);
|
||||
|
||||
extern int fscrypt_setup_v1_file_key_via_subscribed_keyrings(
|
||||
struct fscrypt_info *ci);
|
||||
/* policy.c */
|
||||
|
||||
extern bool fscrypt_policies_equal(const union fscrypt_policy *policy1,
|
||||
const union fscrypt_policy *policy2);
|
||||
extern bool fscrypt_supported_policy(const union fscrypt_policy *policy_u,
|
||||
const struct inode *inode);
|
||||
extern int fscrypt_policy_from_context(union fscrypt_policy *policy_u,
|
||||
const union fscrypt_context *ctx_u,
|
||||
int ctx_size);
|
||||
bool fscrypt_policies_equal(const union fscrypt_policy *policy1,
|
||||
const union fscrypt_policy *policy2);
|
||||
bool fscrypt_supported_policy(const union fscrypt_policy *policy_u,
|
||||
const struct inode *inode);
|
||||
int fscrypt_policy_from_context(union fscrypt_policy *policy_u,
|
||||
const union fscrypt_context *ctx_u,
|
||||
int ctx_size);
|
||||
|
||||
#endif /* _FSCRYPT_PRIVATE_H */
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
#include "fscrypt_private.h"
|
||||
|
||||
/**
|
||||
* fscrypt_file_open - prepare to open a possibly-encrypted regular file
|
||||
* fscrypt_file_open() - prepare to open a possibly-encrypted regular file
|
||||
* @inode: the inode being opened
|
||||
* @filp: the struct file being set up
|
||||
*
|
||||
|
|
@ -261,7 +261,7 @@ err_free_sd:
|
|||
EXPORT_SYMBOL_GPL(__fscrypt_encrypt_symlink);
|
||||
|
||||
/**
|
||||
* fscrypt_get_symlink - get the target of an encrypted symlink
|
||||
* fscrypt_get_symlink() - get the target of an encrypted symlink
|
||||
* @inode: the symlink inode
|
||||
* @caddr: the on-disk contents of the symlink
|
||||
* @max_size: size of @caddr buffer
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@
|
|||
|
||||
#include <crypto/skcipher.h>
|
||||
#include <linux/key-type.h>
|
||||
#include <linux/random.h>
|
||||
#include <linux/seq_file.h>
|
||||
|
||||
#include "fscrypt_private.h"
|
||||
|
|
@ -425,9 +426,9 @@ static int add_existing_master_key(struct fscrypt_master_key *mk,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int add_master_key(struct super_block *sb,
|
||||
struct fscrypt_master_key_secret *secret,
|
||||
const struct fscrypt_key_specifier *mk_spec)
|
||||
static int do_add_master_key(struct super_block *sb,
|
||||
struct fscrypt_master_key_secret *secret,
|
||||
const struct fscrypt_key_specifier *mk_spec)
|
||||
{
|
||||
static DEFINE_MUTEX(fscrypt_add_key_mutex);
|
||||
struct key *key;
|
||||
|
|
@ -466,6 +467,49 @@ out_unlock:
|
|||
return err;
|
||||
}
|
||||
|
||||
/* Size of software "secret" derived from hardware-wrapped key */
|
||||
#define RAW_SECRET_SIZE 32
|
||||
|
||||
static int add_master_key(struct super_block *sb,
|
||||
struct fscrypt_master_key_secret *secret,
|
||||
struct fscrypt_key_specifier *key_spec)
|
||||
{
|
||||
int err;
|
||||
|
||||
if (key_spec->type == FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER) {
|
||||
u8 _kdf_key[RAW_SECRET_SIZE];
|
||||
u8 *kdf_key = secret->raw;
|
||||
unsigned int kdf_key_size = secret->size;
|
||||
|
||||
if (secret->is_hw_wrapped) {
|
||||
kdf_key = _kdf_key;
|
||||
kdf_key_size = RAW_SECRET_SIZE;
|
||||
err = fscrypt_derive_raw_secret(sb, secret->raw,
|
||||
secret->size,
|
||||
kdf_key, kdf_key_size);
|
||||
if (err)
|
||||
return err;
|
||||
}
|
||||
err = fscrypt_init_hkdf(&secret->hkdf, kdf_key, kdf_key_size);
|
||||
/*
|
||||
* Now that the HKDF context is initialized, the raw HKDF key is
|
||||
* no longer needed.
|
||||
*/
|
||||
memzero_explicit(kdf_key, kdf_key_size);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/* Calculate the key identifier */
|
||||
err = fscrypt_hkdf_expand(&secret->hkdf,
|
||||
HKDF_CONTEXT_KEY_IDENTIFIER, NULL, 0,
|
||||
key_spec->u.identifier,
|
||||
FSCRYPT_KEY_IDENTIFIER_SIZE);
|
||||
if (err)
|
||||
return err;
|
||||
}
|
||||
return do_add_master_key(sb, secret, key_spec);
|
||||
}
|
||||
|
||||
static int fscrypt_provisioning_key_preparse(struct key_preparsed_payload *prep)
|
||||
{
|
||||
const struct fscrypt_provisioning_key_payload *payload = prep->data;
|
||||
|
|
@ -571,9 +615,6 @@ out_put:
|
|||
return err;
|
||||
}
|
||||
|
||||
/* Size of software "secret" derived from hardware-wrapped key */
|
||||
#define RAW_SECRET_SIZE 32
|
||||
|
||||
/*
|
||||
* Add a master encryption key to the filesystem, causing all files which were
|
||||
* encrypted with it to appear "unlocked" (decrypted) when accessed.
|
||||
|
|
@ -604,9 +645,6 @@ int fscrypt_ioctl_add_key(struct file *filp, void __user *_uarg)
|
|||
struct fscrypt_add_key_arg __user *uarg = _uarg;
|
||||
struct fscrypt_add_key_arg arg;
|
||||
struct fscrypt_master_key_secret secret;
|
||||
u8 _kdf_key[RAW_SECRET_SIZE];
|
||||
u8 *kdf_key;
|
||||
unsigned int kdf_key_size;
|
||||
int err;
|
||||
|
||||
if (copy_from_user(&arg, uarg, sizeof(arg)))
|
||||
|
|
@ -618,7 +656,25 @@ int fscrypt_ioctl_add_key(struct file *filp, void __user *_uarg)
|
|||
if (memchr_inv(arg.__reserved, 0, sizeof(arg.__reserved)))
|
||||
return -EINVAL;
|
||||
|
||||
/*
|
||||
* Only root can add keys that are identified by an arbitrary descriptor
|
||||
* rather than by a cryptographic hash --- since otherwise a malicious
|
||||
* user could add the wrong key.
|
||||
*/
|
||||
if (arg.key_spec.type == FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR &&
|
||||
!capable(CAP_SYS_ADMIN))
|
||||
return -EACCES;
|
||||
|
||||
memset(&secret, 0, sizeof(secret));
|
||||
|
||||
if (arg.__flags) {
|
||||
if (arg.__flags & ~__FSCRYPT_ADD_KEY_FLAG_HW_WRAPPED)
|
||||
return -EINVAL;
|
||||
if (arg.key_spec.type != FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER)
|
||||
return -EINVAL;
|
||||
secret.is_hw_wrapped = true;
|
||||
}
|
||||
|
||||
if (arg.key_id) {
|
||||
if (arg.raw_size != 0)
|
||||
return -EINVAL;
|
||||
|
|
@ -626,14 +682,13 @@ int fscrypt_ioctl_add_key(struct file *filp, void __user *_uarg)
|
|||
if (err)
|
||||
goto out_wipe_secret;
|
||||
err = -EINVAL;
|
||||
if (!(arg.__flags & __FSCRYPT_ADD_KEY_FLAG_HW_WRAPPED) &&
|
||||
secret.size > FSCRYPT_MAX_KEY_SIZE)
|
||||
if (secret.size > FSCRYPT_MAX_KEY_SIZE && !secret.is_hw_wrapped)
|
||||
goto out_wipe_secret;
|
||||
} else {
|
||||
if (arg.raw_size < FSCRYPT_MIN_KEY_SIZE ||
|
||||
arg.raw_size >
|
||||
((arg.__flags & __FSCRYPT_ADD_KEY_FLAG_HW_WRAPPED) ?
|
||||
FSCRYPT_MAX_HW_WRAPPED_KEY_SIZE : FSCRYPT_MAX_KEY_SIZE))
|
||||
arg.raw_size > (secret.is_hw_wrapped ?
|
||||
FSCRYPT_MAX_HW_WRAPPED_KEY_SIZE :
|
||||
FSCRYPT_MAX_KEY_SIZE))
|
||||
return -EINVAL;
|
||||
secret.size = arg.raw_size;
|
||||
err = -EFAULT;
|
||||
|
|
@ -641,73 +696,46 @@ int fscrypt_ioctl_add_key(struct file *filp, void __user *_uarg)
|
|||
goto out_wipe_secret;
|
||||
}
|
||||
|
||||
switch (arg.key_spec.type) {
|
||||
case FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR:
|
||||
/*
|
||||
* Only root can add keys that are identified by an arbitrary
|
||||
* descriptor rather than by a cryptographic hash --- since
|
||||
* otherwise a malicious user could add the wrong key.
|
||||
*/
|
||||
err = -EACCES;
|
||||
if (!capable(CAP_SYS_ADMIN))
|
||||
goto out_wipe_secret;
|
||||
|
||||
err = -EINVAL;
|
||||
if (arg.__flags)
|
||||
goto out_wipe_secret;
|
||||
break;
|
||||
case FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER:
|
||||
err = -EINVAL;
|
||||
if (arg.__flags & ~__FSCRYPT_ADD_KEY_FLAG_HW_WRAPPED)
|
||||
goto out_wipe_secret;
|
||||
if (arg.__flags & __FSCRYPT_ADD_KEY_FLAG_HW_WRAPPED) {
|
||||
kdf_key = _kdf_key;
|
||||
kdf_key_size = RAW_SECRET_SIZE;
|
||||
err = fscrypt_derive_raw_secret(sb, secret.raw,
|
||||
secret.size,
|
||||
kdf_key, kdf_key_size);
|
||||
if (err)
|
||||
goto out_wipe_secret;
|
||||
secret.is_hw_wrapped = true;
|
||||
} else {
|
||||
kdf_key = secret.raw;
|
||||
kdf_key_size = secret.size;
|
||||
}
|
||||
err = fscrypt_init_hkdf(&secret.hkdf, kdf_key, kdf_key_size);
|
||||
/*
|
||||
* Now that the HKDF context is initialized, the raw HKDF
|
||||
* key is no longer needed.
|
||||
*/
|
||||
memzero_explicit(kdf_key, kdf_key_size);
|
||||
if (err)
|
||||
goto out_wipe_secret;
|
||||
|
||||
/* Calculate the key identifier and return it to userspace. */
|
||||
err = fscrypt_hkdf_expand(&secret.hkdf,
|
||||
HKDF_CONTEXT_KEY_IDENTIFIER,
|
||||
NULL, 0, arg.key_spec.u.identifier,
|
||||
FSCRYPT_KEY_IDENTIFIER_SIZE);
|
||||
if (err)
|
||||
goto out_wipe_secret;
|
||||
err = -EFAULT;
|
||||
if (copy_to_user(uarg->key_spec.u.identifier,
|
||||
arg.key_spec.u.identifier,
|
||||
FSCRYPT_KEY_IDENTIFIER_SIZE))
|
||||
goto out_wipe_secret;
|
||||
break;
|
||||
default:
|
||||
WARN_ON(1);
|
||||
err = -EINVAL;
|
||||
goto out_wipe_secret;
|
||||
}
|
||||
|
||||
err = add_master_key(sb, &secret, &arg.key_spec);
|
||||
if (err)
|
||||
goto out_wipe_secret;
|
||||
|
||||
/* Return the key identifier to userspace, if applicable */
|
||||
err = -EFAULT;
|
||||
if (arg.key_spec.type == FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER &&
|
||||
copy_to_user(uarg->key_spec.u.identifier, arg.key_spec.u.identifier,
|
||||
FSCRYPT_KEY_IDENTIFIER_SIZE))
|
||||
goto out_wipe_secret;
|
||||
err = 0;
|
||||
out_wipe_secret:
|
||||
wipe_master_key_secret(&secret);
|
||||
return err;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(fscrypt_ioctl_add_key);
|
||||
|
||||
/*
|
||||
* Add the key for '-o test_dummy_encryption' to the filesystem keyring.
|
||||
*
|
||||
* Use a per-boot random key to prevent people from misusing this option.
|
||||
*/
|
||||
int fscrypt_add_test_dummy_key(struct super_block *sb,
|
||||
struct fscrypt_key_specifier *key_spec)
|
||||
{
|
||||
static u8 test_key[FSCRYPT_MAX_KEY_SIZE];
|
||||
struct fscrypt_master_key_secret secret;
|
||||
int err;
|
||||
|
||||
get_random_once(test_key, FSCRYPT_MAX_KEY_SIZE);
|
||||
|
||||
memset(&secret, 0, sizeof(secret));
|
||||
secret.size = FSCRYPT_MAX_KEY_SIZE;
|
||||
memcpy(secret.raw, test_key, FSCRYPT_MAX_KEY_SIZE);
|
||||
|
||||
err = add_master_key(sb, &secret, key_spec);
|
||||
wipe_master_key_secret(&secret);
|
||||
return err;
|
||||
}
|
||||
|
||||
/*
|
||||
* Verify that the current user has added a master key with the given identifier
|
||||
* (returns -ENOKEY if not). This is needed to prevent a user from encrypting
|
||||
|
|
|
|||
|
|
@ -161,7 +161,6 @@ static int setup_per_mode_enc_key(struct fscrypt_info *ci,
|
|||
struct fscrypt_prepared_key *keys,
|
||||
u8 hkdf_context, bool include_fs_uuid)
|
||||
{
|
||||
static DEFINE_MUTEX(mode_key_setup_mutex);
|
||||
const struct inode *inode = ci->ci_inode;
|
||||
const struct super_block *sb = inode->i_sb;
|
||||
struct fscrypt_mode *mode = ci->ci_mode;
|
||||
|
|
@ -230,6 +229,7 @@ static int setup_per_mode_enc_key(struct fscrypt_info *ci,
|
|||
}
|
||||
done_unlock:
|
||||
ci->ci_key = *prep_key;
|
||||
|
||||
err = 0;
|
||||
out_unlock:
|
||||
mutex_unlock(&fscrypt_mode_key_setup_mutex);
|
||||
|
|
@ -513,21 +513,18 @@ int fscrypt_get_encryption_info(struct inode *inode)
|
|||
|
||||
res = inode->i_sb->s_cop->get_context(inode, &ctx, sizeof(ctx));
|
||||
if (res < 0) {
|
||||
if (!fscrypt_dummy_context_enabled(inode) ||
|
||||
IS_ENCRYPTED(inode)) {
|
||||
const union fscrypt_context *dummy_ctx =
|
||||
fscrypt_get_dummy_context(inode->i_sb);
|
||||
|
||||
if (IS_ENCRYPTED(inode) || !dummy_ctx) {
|
||||
fscrypt_warn(inode,
|
||||
"Error %d getting encryption context",
|
||||
res);
|
||||
return res;
|
||||
}
|
||||
/* Fake up a context for an unencrypted directory */
|
||||
memset(&ctx, 0, sizeof(ctx));
|
||||
ctx.version = FSCRYPT_CONTEXT_V1;
|
||||
ctx.v1.contents_encryption_mode = FSCRYPT_MODE_AES_256_XTS;
|
||||
ctx.v1.filenames_encryption_mode = FSCRYPT_MODE_AES_256_CTS;
|
||||
memset(ctx.v1.master_key_descriptor, 0x42,
|
||||
FSCRYPT_KEY_DESCRIPTOR_SIZE);
|
||||
res = sizeof(ctx.v1);
|
||||
res = fscrypt_context_size(dummy_ctx);
|
||||
memcpy(&ctx, dummy_ctx, res);
|
||||
}
|
||||
|
||||
crypt_info = kmem_cache_zalloc(fscrypt_info_cachep, GFP_NOFS);
|
||||
|
|
@ -593,7 +590,8 @@ out:
|
|||
EXPORT_SYMBOL(fscrypt_get_encryption_info);
|
||||
|
||||
/**
|
||||
* fscrypt_put_encryption_info - free most of an inode's fscrypt data
|
||||
* fscrypt_put_encryption_info() - free most of an inode's fscrypt data
|
||||
* @inode: an inode being evicted
|
||||
*
|
||||
* Free the inode's fscrypt_info. Filesystems must call this when the inode is
|
||||
* being evicted. An RCU grace period need not have elapsed yet.
|
||||
|
|
@ -606,7 +604,8 @@ void fscrypt_put_encryption_info(struct inode *inode)
|
|||
EXPORT_SYMBOL(fscrypt_put_encryption_info);
|
||||
|
||||
/**
|
||||
* fscrypt_free_inode - free an inode's fscrypt data requiring RCU delay
|
||||
* fscrypt_free_inode() - free an inode's fscrypt data requiring RCU delay
|
||||
* @inode: an inode being freed
|
||||
*
|
||||
* Free the inode's cached decrypted symlink target, if any. Filesystems must
|
||||
* call this after an RCU grace period, just before they free the inode.
|
||||
|
|
@ -621,7 +620,8 @@ void fscrypt_free_inode(struct inode *inode)
|
|||
EXPORT_SYMBOL(fscrypt_free_inode);
|
||||
|
||||
/**
|
||||
* fscrypt_drop_inode - check whether the inode's master key has been removed
|
||||
* fscrypt_drop_inode() - check whether the inode's master key has been removed
|
||||
* @inode: an inode being considered for eviction
|
||||
*
|
||||
* Filesystems supporting fscrypt must call this from their ->drop_inode()
|
||||
* method so that encrypted inodes are evicted as soon as they're no longer in
|
||||
|
|
|
|||
|
|
@ -11,12 +11,15 @@
|
|||
*/
|
||||
|
||||
#include <linux/random.h>
|
||||
#include <linux/seq_file.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/mount.h>
|
||||
#include "fscrypt_private.h"
|
||||
|
||||
/**
|
||||
* fscrypt_policies_equal - check whether two encryption policies are the same
|
||||
* fscrypt_policies_equal() - check whether two encryption policies are the same
|
||||
* @policy1: the first policy
|
||||
* @policy2: the second policy
|
||||
*
|
||||
* Return: %true if equal, else %false
|
||||
*/
|
||||
|
|
@ -190,7 +193,9 @@ static bool fscrypt_supported_v2_policy(const struct fscrypt_policy_v2 *policy,
|
|||
}
|
||||
|
||||
/**
|
||||
* fscrypt_supported_policy - check whether an encryption policy is supported
|
||||
* fscrypt_supported_policy() - check whether an encryption policy is supported
|
||||
* @policy_u: the encryption policy
|
||||
* @inode: the inode on which the policy will be used
|
||||
*
|
||||
* Given an encryption policy, check whether all its encryption modes and other
|
||||
* settings are supported by this kernel on the given inode. (But we don't
|
||||
|
|
@ -212,7 +217,10 @@ bool fscrypt_supported_policy(const union fscrypt_policy *policy_u,
|
|||
}
|
||||
|
||||
/**
|
||||
* fscrypt_new_context_from_policy - create a new fscrypt_context from a policy
|
||||
* fscrypt_new_context_from_policy() - create a new fscrypt_context from
|
||||
* an fscrypt_policy
|
||||
* @ctx_u: output context
|
||||
* @policy_u: input policy
|
||||
*
|
||||
* Create an fscrypt_context for an inode that is being assigned the given
|
||||
* encryption policy. A new nonce is randomly generated.
|
||||
|
|
@ -262,7 +270,11 @@ static int fscrypt_new_context_from_policy(union fscrypt_context *ctx_u,
|
|||
}
|
||||
|
||||
/**
|
||||
* fscrypt_policy_from_context - convert an fscrypt_context to an fscrypt_policy
|
||||
* fscrypt_policy_from_context() - convert an fscrypt_context to
|
||||
* an fscrypt_policy
|
||||
* @policy_u: output policy
|
||||
* @ctx_u: input context
|
||||
* @ctx_size: size of input context in bytes
|
||||
*
|
||||
* Given an fscrypt_context, build the corresponding fscrypt_policy.
|
||||
*
|
||||
|
|
@ -628,3 +640,127 @@ int fscrypt_inherit_context(struct inode *parent, struct inode *child,
|
|||
return preload ? fscrypt_get_encryption_info(child): 0;
|
||||
}
|
||||
EXPORT_SYMBOL(fscrypt_inherit_context);
|
||||
|
||||
/**
|
||||
* fscrypt_set_test_dummy_encryption() - handle '-o test_dummy_encryption'
|
||||
* @sb: the filesystem on which test_dummy_encryption is being specified
|
||||
* @arg: the argument to the test_dummy_encryption option.
|
||||
* If no argument was specified, then @arg->from == NULL.
|
||||
* @dummy_ctx: the filesystem's current dummy context (input/output, see below)
|
||||
*
|
||||
* Handle the test_dummy_encryption mount option by creating a dummy encryption
|
||||
* context, saving it in @dummy_ctx, and adding the corresponding dummy
|
||||
* encryption key to the filesystem. If the @dummy_ctx is already set, then
|
||||
* instead validate that it matches @arg. Don't support changing it via
|
||||
* remount, as that is difficult to do safely.
|
||||
*
|
||||
* The reason we use an fscrypt_context rather than an fscrypt_policy is because
|
||||
* we mustn't generate a new nonce each time we access a dummy-encrypted
|
||||
* directory, as that would change the way filenames are encrypted.
|
||||
*
|
||||
* Return: 0 on success (dummy context set, or the same context is already set);
|
||||
* -EEXIST if a different dummy context is already set;
|
||||
* or another -errno value.
|
||||
*/
|
||||
int fscrypt_set_test_dummy_encryption(struct super_block *sb,
|
||||
const substring_t *arg,
|
||||
struct fscrypt_dummy_context *dummy_ctx)
|
||||
{
|
||||
const char *argstr = "v2";
|
||||
const char *argstr_to_free = NULL;
|
||||
struct fscrypt_key_specifier key_spec = { 0 };
|
||||
int version;
|
||||
union fscrypt_context *ctx = NULL;
|
||||
int err;
|
||||
|
||||
if (arg->from) {
|
||||
argstr = argstr_to_free = match_strdup(arg);
|
||||
if (!argstr)
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
if (!strcmp(argstr, "v1")) {
|
||||
version = FSCRYPT_CONTEXT_V1;
|
||||
key_spec.type = FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR;
|
||||
memset(key_spec.u.descriptor, 0x42,
|
||||
FSCRYPT_KEY_DESCRIPTOR_SIZE);
|
||||
} else if (!strcmp(argstr, "v2")) {
|
||||
version = FSCRYPT_CONTEXT_V2;
|
||||
key_spec.type = FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER;
|
||||
/* key_spec.u.identifier gets filled in when adding the key */
|
||||
} else {
|
||||
err = -EINVAL;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (dummy_ctx->ctx) {
|
||||
/*
|
||||
* Note: if we ever make test_dummy_encryption support
|
||||
* specifying other encryption settings, such as the encryption
|
||||
* modes, we'll need to compare those settings here.
|
||||
*/
|
||||
if (dummy_ctx->ctx->version == version)
|
||||
err = 0;
|
||||
else
|
||||
err = -EEXIST;
|
||||
goto out;
|
||||
}
|
||||
|
||||
ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
|
||||
if (!ctx) {
|
||||
err = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
|
||||
err = fscrypt_add_test_dummy_key(sb, &key_spec);
|
||||
if (err)
|
||||
goto out;
|
||||
|
||||
ctx->version = version;
|
||||
switch (ctx->version) {
|
||||
case FSCRYPT_CONTEXT_V1:
|
||||
ctx->v1.contents_encryption_mode = FSCRYPT_MODE_AES_256_XTS;
|
||||
ctx->v1.filenames_encryption_mode = FSCRYPT_MODE_AES_256_CTS;
|
||||
memcpy(ctx->v1.master_key_descriptor, key_spec.u.descriptor,
|
||||
FSCRYPT_KEY_DESCRIPTOR_SIZE);
|
||||
break;
|
||||
case FSCRYPT_CONTEXT_V2:
|
||||
ctx->v2.contents_encryption_mode = FSCRYPT_MODE_AES_256_XTS;
|
||||
ctx->v2.filenames_encryption_mode = FSCRYPT_MODE_AES_256_CTS;
|
||||
memcpy(ctx->v2.master_key_identifier, key_spec.u.identifier,
|
||||
FSCRYPT_KEY_IDENTIFIER_SIZE);
|
||||
break;
|
||||
default:
|
||||
WARN_ON(1);
|
||||
err = -EINVAL;
|
||||
goto out;
|
||||
}
|
||||
dummy_ctx->ctx = ctx;
|
||||
ctx = NULL;
|
||||
err = 0;
|
||||
out:
|
||||
kfree(ctx);
|
||||
kfree(argstr_to_free);
|
||||
return err;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(fscrypt_set_test_dummy_encryption);
|
||||
|
||||
/**
|
||||
* fscrypt_show_test_dummy_encryption() - show '-o test_dummy_encryption'
|
||||
* @seq: the seq_file to print the option to
|
||||
* @sep: the separator character to use
|
||||
* @sb: the filesystem whose options are being shown
|
||||
*
|
||||
* Show the test_dummy_encryption mount option, if it was specified.
|
||||
* This is mainly used for /proc/mounts.
|
||||
*/
|
||||
void fscrypt_show_test_dummy_encryption(struct seq_file *seq, char sep,
|
||||
struct super_block *sb)
|
||||
{
|
||||
const union fscrypt_context *ctx = fscrypt_get_dummy_context(sb);
|
||||
|
||||
if (!ctx)
|
||||
return;
|
||||
seq_printf(seq, "%ctest_dummy_encryption=v%d", sep, ctx->version);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(fscrypt_show_test_dummy_encryption);
|
||||
|
|
|
|||
Loading…
Reference in a new issue