Commit 5dae460c authored by Eric Biggers's avatar Eric Biggers

fscrypt: v2 encryption policy support

Add a new fscrypt policy version, "v2".  It has the following changes
from the original policy version, which we call "v1" (*):

- Master keys (the user-provided encryption keys) are only ever used as
  input to HKDF-SHA512.  This is more flexible and less error-prone, and
  it avoids the quirks and limitations of the AES-128-ECB based KDF.
  Three classes of cryptographically isolated subkeys are defined:

    - Per-file keys, like used in v1 policies except for the new KDF.

    - Per-mode keys.  These implement the semantics of the DIRECT_KEY
      flag, which for v1 policies made the master key be used directly.
      These are also planned to be used for inline encryption when
      support for it is added.

    - Key identifiers (see below).

- Each master key is identified by a 16-byte master_key_identifier,
  which is derived from the key itself using HKDF-SHA512.  This prevents
  users from associating the wrong key with an encrypted file or
  directory.  This was easily possible with v1 policies, which
  identified the key by an arbitrary 8-byte master_key_descriptor.

- The key must be provided in the filesystem-level keyring, not in a
  process-subscribed keyring.

The following UAPI additions are made:

- The existing ioctl FS_IOC_SET_ENCRYPTION_POLICY can now be passed a
  fscrypt_policy_v2 to set a v2 encryption policy.  It's disambiguated
  from fscrypt_policy/fscrypt_policy_v1 by the version code prefix.

- A new ioctl FS_IOC_GET_ENCRYPTION_POLICY_EX is added.  It allows
  getting the v1 or v2 encryption policy of an encrypted file or
  directory.  The existing FS_IOC_GET_ENCRYPTION_POLICY ioctl could not
  be used because it did not have a way for userspace to indicate which
  policy structure is expected.  The new ioctl includes a size field, so
  it is extensible to future fscrypt policy versions.

- The ioctls FS_IOC_ADD_ENCRYPTION_KEY, FS_IOC_REMOVE_ENCRYPTION_KEY,
  and FS_IOC_GET_ENCRYPTION_KEY_STATUS now support managing keys for v2
  encryption policies.  Such keys are kept logically separate from keys
  for v1 encryption policies, and are identified by 'identifier' rather
  than by 'descriptor'.  The 'identifier' need not be provided when
  adding a key, since the kernel will calculate it anyway.

This patch temporarily keeps adding/removing v2 policy keys behind the
same permission check done for adding/removing v1 policy keys:
capable(CAP_SYS_ADMIN).  However, the next patch will carefully take
advantage of the cryptographically secure master_key_identifier to allow
non-root users to add/remove v2 policy keys, thus providing a full
replacement for v1 policies.

(*) Actually, in the API fscrypt_policy::version is 0 while on-disk
    fscrypt_context::format is 1.  But I believe it makes the most sense
    to advance both to '2' to have them be in sync, and to consider the
    numbering to start at 1 except for the API quirk.
Reviewed-by: default avatarPaul Crowley <paulcrowley@google.com>
Reviewed-by: default avatarTheodore Ts'o <tytso@mit.edu>
Signed-off-by: default avatarEric Biggers <ebiggers@google.com>
parent c1144c9b
...@@ -141,7 +141,7 @@ void fscrypt_generate_iv(union fscrypt_iv *iv, u64 lblk_num, ...@@ -141,7 +141,7 @@ void fscrypt_generate_iv(union fscrypt_iv *iv, u64 lblk_num,
memset(iv, 0, ci->ci_mode->ivsize); memset(iv, 0, ci->ci_mode->ivsize);
iv->lblk_num = cpu_to_le64(lblk_num); iv->lblk_num = cpu_to_le64(lblk_num);
if (ci->ci_flags & FSCRYPT_POLICY_FLAG_DIRECT_KEY) if (fscrypt_is_direct_key_policy(&ci->ci_policy))
memcpy(iv->nonce, ci->ci_nonce, FS_KEY_DERIVATION_NONCE_SIZE); memcpy(iv->nonce, ci->ci_nonce, FS_KEY_DERIVATION_NONCE_SIZE);
if (ci->ci_essiv_tfm != NULL) if (ci->ci_essiv_tfm != NULL)
......
...@@ -181,7 +181,8 @@ static int base64_decode(const char *src, int len, u8 *dst) ...@@ -181,7 +181,8 @@ static int base64_decode(const char *src, int len, u8 *dst)
bool fscrypt_fname_encrypted_size(const struct inode *inode, u32 orig_len, bool fscrypt_fname_encrypted_size(const struct inode *inode, u32 orig_len,
u32 max_len, u32 *encrypted_len_ret) u32 max_len, u32 *encrypted_len_ret)
{ {
int padding = 4 << (inode->i_crypt_info->ci_flags & const struct fscrypt_info *ci = inode->i_crypt_info;
int padding = 4 << (fscrypt_policy_flags(&ci->ci_policy) &
FSCRYPT_POLICY_FLAGS_PAD_MASK); FSCRYPT_POLICY_FLAGS_PAD_MASK);
u32 encrypted_len; u32 encrypted_len;
......
...@@ -20,27 +20,127 @@ ...@@ -20,27 +20,127 @@
#define FSCRYPT_MIN_KEY_SIZE 16 #define FSCRYPT_MIN_KEY_SIZE 16
/** #define FSCRYPT_CONTEXT_V1 1
* Encryption context for inode #define FSCRYPT_CONTEXT_V2 2
*
* Protector format: struct fscrypt_context_v1 {
* 1 byte: Protector format (1 = this version) u8 version; /* FSCRYPT_CONTEXT_V1 */
* 1 byte: File contents encryption mode
* 1 byte: File names encryption mode
* 1 byte: Flags
* 8 bytes: Master Key descriptor
* 16 bytes: Encryption Key derivation nonce
*/
struct fscrypt_context {
u8 format;
u8 contents_encryption_mode; u8 contents_encryption_mode;
u8 filenames_encryption_mode; u8 filenames_encryption_mode;
u8 flags; u8 flags;
u8 master_key_descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE]; u8 master_key_descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE];
u8 nonce[FS_KEY_DERIVATION_NONCE_SIZE]; u8 nonce[FS_KEY_DERIVATION_NONCE_SIZE];
} __packed; };
#define FS_ENCRYPTION_CONTEXT_FORMAT_V1 1 struct fscrypt_context_v2 {
u8 version; /* FSCRYPT_CONTEXT_V2 */
u8 contents_encryption_mode;
u8 filenames_encryption_mode;
u8 flags;
u8 __reserved[4];
u8 master_key_identifier[FSCRYPT_KEY_IDENTIFIER_SIZE];
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
* encrypted file usually in a hidden extended attribute. It contains the
* fields from the fscrypt_policy, in order to identify the encryption algorithm
* and key with which the file is encrypted. It also contains a nonce that was
* randomly generated by fscrypt itself; this is used as KDF input or as a tweak
* to cause different files to be encrypted differently.
*/
union fscrypt_context {
u8 version;
struct fscrypt_context_v1 v1;
struct fscrypt_context_v2 v2;
};
/*
* Return the size expected for the given fscrypt_context based on its version
* number, or 0 if the context version is unrecognized.
*/
static inline int fscrypt_context_size(const union fscrypt_context *ctx)
{
switch (ctx->version) {
case FSCRYPT_CONTEXT_V1:
BUILD_BUG_ON(sizeof(ctx->v1) != 28);
return sizeof(ctx->v1);
case FSCRYPT_CONTEXT_V2:
BUILD_BUG_ON(sizeof(ctx->v2) != 40);
return sizeof(ctx->v2);
}
return 0;
}
#undef fscrypt_policy
union fscrypt_policy {
u8 version;
struct fscrypt_policy_v1 v1;
struct fscrypt_policy_v2 v2;
};
/*
* Return the size expected for the given fscrypt_policy based on its version
* number, or 0 if the policy version is unrecognized.
*/
static inline int fscrypt_policy_size(const union fscrypt_policy *policy)
{
switch (policy->version) {
case FSCRYPT_POLICY_V1:
return sizeof(policy->v1);
case FSCRYPT_POLICY_V2:
return sizeof(policy->v2);
}
return 0;
}
/* Return the contents encryption mode of a valid encryption policy */
static inline u8
fscrypt_policy_contents_mode(const union fscrypt_policy *policy)
{
switch (policy->version) {
case FSCRYPT_POLICY_V1:
return policy->v1.contents_encryption_mode;
case FSCRYPT_POLICY_V2:
return policy->v2.contents_encryption_mode;
}
BUG();
}
/* Return the filenames encryption mode of a valid encryption policy */
static inline u8
fscrypt_policy_fnames_mode(const union fscrypt_policy *policy)
{
switch (policy->version) {
case FSCRYPT_POLICY_V1:
return policy->v1.filenames_encryption_mode;
case FSCRYPT_POLICY_V2:
return policy->v2.filenames_encryption_mode;
}
BUG();
}
/* Return the flags (FSCRYPT_POLICY_FLAG*) of a valid encryption policy */
static inline u8
fscrypt_policy_flags(const union fscrypt_policy *policy)
{
switch (policy->version) {
case FSCRYPT_POLICY_V1:
return policy->v1.flags;
case FSCRYPT_POLICY_V2:
return policy->v2.flags;
}
BUG();
}
static inline bool
fscrypt_is_direct_key_policy(const union fscrypt_policy *policy)
{
return fscrypt_policy_flags(policy) & FSCRYPT_POLICY_FLAG_DIRECT_KEY;
}
/** /**
* For encrypted symlinks, the ciphertext length is stored at the beginning * For encrypted symlinks, the ciphertext length is stored at the beginning
...@@ -70,8 +170,8 @@ struct fscrypt_info { ...@@ -70,8 +170,8 @@ struct fscrypt_info {
struct crypto_cipher *ci_essiv_tfm; struct crypto_cipher *ci_essiv_tfm;
/* /*
* Encryption mode used for this inode. It corresponds to either * Encryption mode used for this inode. It corresponds to either the
* ci_data_mode or ci_filename_mode, depending on the inode type. * contents or filenames encryption mode, depending on the inode type.
*/ */
struct fscrypt_mode *ci_mode; struct fscrypt_mode *ci_mode;
...@@ -97,11 +197,10 @@ struct fscrypt_info { ...@@ -97,11 +197,10 @@ struct fscrypt_info {
*/ */
struct fscrypt_direct_key *ci_direct_key; struct fscrypt_direct_key *ci_direct_key;
/* fields from the fscrypt_context */ /* The encryption policy used by this inode */
u8 ci_data_mode; union fscrypt_policy ci_policy;
u8 ci_filename_mode;
u8 ci_flags; /* This inode's nonce, copied from the fscrypt_context */
u8 ci_master_key_descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE];
u8 ci_nonce[FS_KEY_DERIVATION_NONCE_SIZE]; u8 ci_nonce[FS_KEY_DERIVATION_NONCE_SIZE];
}; };
...@@ -181,6 +280,17 @@ struct fscrypt_hkdf { ...@@ -181,6 +280,17 @@ struct fscrypt_hkdf {
extern int fscrypt_init_hkdf(struct fscrypt_hkdf *hkdf, const u8 *master_key, extern int fscrypt_init_hkdf(struct fscrypt_hkdf *hkdf, const u8 *master_key,
unsigned int master_key_size); unsigned int master_key_size);
/*
* The list of contexts in which fscrypt uses HKDF. These values are used as
* the first byte of the HKDF application-specific info string to guarantee that
* info strings are never repeated between contexts. This ensures that all HKDF
* outputs are unique and cryptographically isolated, i.e. knowledge of one
* output doesn't reveal another.
*/
#define HKDF_CONTEXT_KEY_IDENTIFIER 1
#define HKDF_CONTEXT_PER_FILE_KEY 2
#define HKDF_CONTEXT_PER_MODE_KEY 3
extern int fscrypt_hkdf_expand(struct fscrypt_hkdf *hkdf, u8 context, extern int fscrypt_hkdf_expand(struct fscrypt_hkdf *hkdf, u8 context,
const u8 *info, unsigned int infolen, const u8 *info, unsigned int infolen,
u8 *okm, unsigned int okmlen); u8 *okm, unsigned int okmlen);
...@@ -194,10 +304,16 @@ extern void fscrypt_destroy_hkdf(struct fscrypt_hkdf *hkdf); ...@@ -194,10 +304,16 @@ extern void fscrypt_destroy_hkdf(struct fscrypt_hkdf *hkdf);
*/ */
struct fscrypt_master_key_secret { struct fscrypt_master_key_secret {
/* Size of the raw key in bytes */ /*
* For v2 policy keys: HKDF context keyed by this master key.
* For v1 policy keys: not set (hkdf.hmac_tfm == NULL).
*/
struct fscrypt_hkdf hkdf;
/* Size of the raw key in bytes. Set even if ->raw isn't set. */
u32 size; u32 size;
/* The raw key */ /* For v1 policy keys: the raw key. Wiped for v2 policy keys. */
u8 raw[FSCRYPT_MAX_KEY_SIZE]; u8 raw[FSCRYPT_MAX_KEY_SIZE];
} __randomize_layout; } __randomize_layout;
...@@ -223,7 +339,12 @@ struct fscrypt_master_key { ...@@ -223,7 +339,12 @@ struct fscrypt_master_key {
*/ */
struct fscrypt_master_key_secret mk_secret; struct fscrypt_master_key_secret mk_secret;
/* Arbitrary key descriptor which was assigned by userspace */ /*
* For v1 policy keys: an arbitrary key descriptor which was assigned by
* userspace (->descriptor).
*
* For v2 policy keys: a cryptographic hash of this key (->identifier).
*/
struct fscrypt_key_specifier mk_spec; struct fscrypt_key_specifier mk_spec;
/* /*
...@@ -242,6 +363,9 @@ struct fscrypt_master_key { ...@@ -242,6 +363,9 @@ struct fscrypt_master_key {
struct list_head mk_decrypted_inodes; struct list_head mk_decrypted_inodes;
spinlock_t mk_decrypted_inodes_lock; spinlock_t mk_decrypted_inodes_lock;
/* Per-mode tfms for DIRECT_KEY policies, allocated on-demand */
struct crypto_skcipher *mk_mode_keys[__FSCRYPT_MODE_MAX + 1];
} __randomize_layout; } __randomize_layout;
static inline bool static inline bool
...@@ -263,6 +387,8 @@ static inline const char *master_key_spec_type( ...@@ -263,6 +387,8 @@ static inline const char *master_key_spec_type(
switch (spec->type) { switch (spec->type) {
case FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR: case FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR:
return "descriptor"; return "descriptor";
case FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER:
return "identifier";
} }
return "[unknown]"; return "[unknown]";
} }
...@@ -272,6 +398,8 @@ static inline int master_key_spec_len(const struct fscrypt_key_specifier *spec) ...@@ -272,6 +398,8 @@ static inline int master_key_spec_len(const struct fscrypt_key_specifier *spec)
switch (spec->type) { switch (spec->type) {
case FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR: case FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR:
return FSCRYPT_KEY_DESCRIPTOR_SIZE; return FSCRYPT_KEY_DESCRIPTOR_SIZE;
case FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER:
return FSCRYPT_KEY_IDENTIFIER_SIZE;
} }
return 0; return 0;
} }
...@@ -315,5 +443,14 @@ extern int fscrypt_setup_v1_file_key(struct fscrypt_info *ci, ...@@ -315,5 +443,14 @@ extern int fscrypt_setup_v1_file_key(struct fscrypt_info *ci,
extern int fscrypt_setup_v1_file_key_via_subscribed_keyrings( extern int fscrypt_setup_v1_file_key_via_subscribed_keyrings(
struct fscrypt_info *ci); 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);
#endif /* _FSCRYPT_PRIVATE_H */ #endif /* _FSCRYPT_PRIVATE_H */
...@@ -17,6 +17,7 @@ ...@@ -17,6 +17,7 @@
* information about these ioctls. * information about these ioctls.
*/ */
#include <crypto/skcipher.h>
#include <linux/key-type.h> #include <linux/key-type.h>
#include <linux/seq_file.h> #include <linux/seq_file.h>
...@@ -24,6 +25,7 @@ ...@@ -24,6 +25,7 @@
static void wipe_master_key_secret(struct fscrypt_master_key_secret *secret) static void wipe_master_key_secret(struct fscrypt_master_key_secret *secret)
{ {
fscrypt_destroy_hkdf(&secret->hkdf);
memzero_explicit(secret, sizeof(*secret)); memzero_explicit(secret, sizeof(*secret));
} }
...@@ -36,7 +38,13 @@ static void move_master_key_secret(struct fscrypt_master_key_secret *dst, ...@@ -36,7 +38,13 @@ static void move_master_key_secret(struct fscrypt_master_key_secret *dst,
static void free_master_key(struct fscrypt_master_key *mk) static void free_master_key(struct fscrypt_master_key *mk)
{ {
size_t i;
wipe_master_key_secret(&mk->mk_secret); wipe_master_key_secret(&mk->mk_secret);
for (i = 0; i < ARRAY_SIZE(mk->mk_mode_keys); i++)
crypto_free_skcipher(mk->mk_mode_keys[i]);
kzfree(mk); kzfree(mk);
} }
...@@ -109,7 +117,7 @@ static struct key *search_fscrypt_keyring(struct key *keyring, ...@@ -109,7 +117,7 @@ static struct key *search_fscrypt_keyring(struct key *keyring,
#define FSCRYPT_FS_KEYRING_DESCRIPTION_SIZE \ #define FSCRYPT_FS_KEYRING_DESCRIPTION_SIZE \
(CONST_STRLEN("fscrypt-") + FIELD_SIZEOF(struct super_block, s_id)) (CONST_STRLEN("fscrypt-") + FIELD_SIZEOF(struct super_block, s_id))
#define FSCRYPT_MK_DESCRIPTION_SIZE (2 * FSCRYPT_KEY_DESCRIPTOR_SIZE + 1) #define FSCRYPT_MK_DESCRIPTION_SIZE (2 * FSCRYPT_KEY_IDENTIFIER_SIZE + 1)
static void format_fs_keyring_description( static void format_fs_keyring_description(
char description[FSCRYPT_FS_KEYRING_DESCRIPTION_SIZE], char description[FSCRYPT_FS_KEYRING_DESCRIPTION_SIZE],
...@@ -314,6 +322,31 @@ int fscrypt_ioctl_add_key(struct file *filp, void __user *_uarg) ...@@ -314,6 +322,31 @@ int fscrypt_ioctl_add_key(struct file *filp, void __user *_uarg)
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
goto out_wipe_secret; goto out_wipe_secret;
if (arg.key_spec.type == FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER) {
err = fscrypt_init_hkdf(&secret.hkdf, secret.raw, secret.size);
if (err)
goto out_wipe_secret;
/*
* Now that the HKDF context is initialized, the raw key is no
* longer needed.
*/
memzero_explicit(secret.raw, secret.size);
/* 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;
}
err = add_master_key(sb, &secret, &arg.key_spec); err = add_master_key(sb, &secret, &arg.key_spec);
out_wipe_secret: out_wipe_secret:
wipe_master_key_secret(&secret); wipe_master_key_secret(&secret);
......
...@@ -52,20 +52,14 @@ static struct fscrypt_mode available_modes[] = { ...@@ -52,20 +52,14 @@ static struct fscrypt_mode available_modes[] = {
}; };
static struct fscrypt_mode * static struct fscrypt_mode *
select_encryption_mode(const struct fscrypt_info *ci, const struct inode *inode) select_encryption_mode(const union fscrypt_policy *policy,
const struct inode *inode)
{ {
if (!fscrypt_valid_enc_modes(ci->ci_data_mode, ci->ci_filename_mode)) {
fscrypt_warn(inode,
"Unsupported encryption modes (contents mode %d, filenames mode %d)",
ci->ci_data_mode, ci->ci_filename_mode);
return ERR_PTR(-EINVAL);
}
if (S_ISREG(inode->i_mode)) if (S_ISREG(inode->i_mode))
return &available_modes[ci->ci_data_mode]; return &available_modes[fscrypt_policy_contents_mode(policy)];
if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
return &available_modes[ci->ci_filename_mode]; return &available_modes[fscrypt_policy_fnames_mode(policy)];
WARN_ONCE(1, "fscrypt: filesystem tried to load encryption info for inode %lu, which is not encryptable (file type %d)\n", WARN_ONCE(1, "fscrypt: filesystem tried to load encryption info for inode %lu, which is not encryptable (file type %d)\n",
inode->i_ino, (inode->i_mode & S_IFMT)); inode->i_ino, (inode->i_mode & S_IFMT));
...@@ -211,6 +205,82 @@ int fscrypt_set_derived_key(struct fscrypt_info *ci, const u8 *derived_key) ...@@ -211,6 +205,82 @@ int fscrypt_set_derived_key(struct fscrypt_info *ci, const u8 *derived_key)
return 0; return 0;
} }
static int setup_per_mode_key(struct fscrypt_info *ci,
struct fscrypt_master_key *mk)
{
struct fscrypt_mode *mode = ci->ci_mode;
u8 mode_num = mode - available_modes;
struct crypto_skcipher *tfm, *prev_tfm;
u8 mode_key[FSCRYPT_MAX_KEY_SIZE];
int err;
if (WARN_ON(mode_num >= ARRAY_SIZE(mk->mk_mode_keys)))
return -EINVAL;
/* pairs with cmpxchg() below */
tfm = READ_ONCE(mk->mk_mode_keys[mode_num]);
if (likely(tfm != NULL))
goto done;
BUILD_BUG_ON(sizeof(mode_num) != 1);
err = fscrypt_hkdf_expand(&mk->mk_secret.hkdf,
HKDF_CONTEXT_PER_MODE_KEY,
&mode_num, sizeof(mode_num),
mode_key, mode->keysize);
if (err)
return err;
tfm = fscrypt_allocate_skcipher(mode, mode_key, ci->ci_inode);
memzero_explicit(mode_key, mode->keysize);
if (IS_ERR(tfm))
return PTR_ERR(tfm);
/* pairs with READ_ONCE() above */
prev_tfm = cmpxchg(&mk->mk_mode_keys[mode_num], NULL, tfm);
if (prev_tfm != NULL) {
crypto_free_skcipher(tfm);
tfm = prev_tfm;
}
done:
ci->ci_ctfm = tfm;
return 0;
}
static int fscrypt_setup_v2_file_key(struct fscrypt_info *ci,
struct fscrypt_master_key *mk)
{
u8 derived_key[FSCRYPT_MAX_KEY_SIZE];
int err;
if (ci->ci_policy.v2.flags & FSCRYPT_POLICY_FLAG_DIRECT_KEY) {
/*
* DIRECT_KEY: instead of deriving per-file keys, the per-file
* nonce will be included in all the IVs. But unlike v1
* policies, for v2 policies in this case we don't encrypt with
* the master key directly but rather derive a per-mode key.
* This ensures that the master key is consistently used only
* for HKDF, avoiding key reuse issues.
*/
if (!fscrypt_mode_supports_direct_key(ci->ci_mode)) {
fscrypt_warn(ci->ci_inode,
"Direct key flag not allowed with %s",
ci->ci_mode->friendly_name);
return -EINVAL;
}
return setup_per_mode_key(ci, mk);
}
err = fscrypt_hkdf_expand(&mk->mk_secret.hkdf,
HKDF_CONTEXT_PER_FILE_KEY,
ci->ci_nonce, FS_KEY_DERIVATION_NONCE_SIZE,
derived_key, ci->ci_mode->keysize);
if (err)
return err;
err = fscrypt_set_derived_key(ci, derived_key);
memzero_explicit(derived_key, ci->ci_mode->keysize);
return err;
}
/* /*
* Find the master key, then set up the inode's actual encryption key. * Find the master key, then set up the inode's actual encryption key.
* *
...@@ -229,15 +299,36 @@ static int setup_file_encryption_key(struct fscrypt_info *ci, ...@@ -229,15 +299,36 @@ static int setup_file_encryption_key(struct fscrypt_info *ci,
struct fscrypt_key_specifier mk_spec; struct fscrypt_key_specifier mk_spec;
int err; int err;
mk_spec.type = FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR; switch (ci->ci_policy.version) {
memcpy(mk_spec.u.descriptor, ci->ci_master_key_descriptor, case FSCRYPT_POLICY_V1:
FSCRYPT_KEY_DESCRIPTOR_SIZE); mk_spec.type = FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR;
memcpy(mk_spec.u.descriptor,
ci->ci_policy.v1.master_key_descriptor,
FSCRYPT_KEY_DESCRIPTOR_SIZE);
break;
case FSCRYPT_POLICY_V2:
mk_spec.type = FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER;
memcpy(mk_spec.u.identifier,
ci->ci_policy.v2.master_key_identifier,
FSCRYPT_KEY_IDENTIFIER_SIZE);
break;
default:
WARN_ON(1);
return -EINVAL;
}
key = fscrypt_find_master_key(ci->ci_inode->i_sb, &mk_spec); key = fscrypt_find_master_key(ci->ci_inode->i_sb, &mk_spec);
if (IS_ERR(key)) { if (IS_ERR(key)) {
if (key != ERR_PTR(-ENOKEY)) if (key != ERR_PTR(-ENOKEY) ||
ci->ci_policy.version != FSCRYPT_POLICY_V1)
return PTR_ERR(key); return PTR_ERR(key);
/*
* As a legacy fallback for v1 policies, search for the key in
* the current task's subscribed keyrings too. Don't move this
* to before the search of ->s_master_keys, since users
* shouldn't be able to override filesystem-level keys.
*/
return fscrypt_setup_v1_file_key_via_subscribed_keyrings(ci); return fscrypt_setup_v1_file_key_via_subscribed_keyrings(ci);
} }
...@@ -250,6 +341,12 @@ static int setup_file_encryption_key(struct fscrypt_info *ci, ...@@ -250,6 +341,12 @@ static int setup_file_encryption_key(struct fscrypt_info *ci,
goto out_release_key; goto out_release_key;
} }
/*
* Require that the master key be at least as long as the derived key.
* Otherwise, the derived key cannot possibly contain as much entropy as
* that required by the encryption mode it will be used for. For v1
* policies it's also required for the KDF to work at all.
*/
if (mk->mk_secret.size < ci->ci_mode->keysize) { if (mk->mk_secret.size < ci->ci_mode->keysize) {
fscrypt_warn(NULL, fscrypt_warn(NULL,
"key with %s %*phN is too short (got %u bytes, need %u+ bytes)", "key with %s %*phN is too short (got %u bytes, need %u+ bytes)",
...@@ -260,7 +357,18 @@ static int setup_file_encryption_key(struct fscrypt_info *ci, ...@@ -260,7 +357,18 @@ static int setup_file_encryption_key(struct fscrypt_info *ci,
goto out_release_key; goto out_release_key;
} }
err = fscrypt_setup_v1_file_key(ci, mk->mk_secret.raw); switch (ci->ci_policy.version) {
case FSCRYPT_POLICY_V1:
err = fscrypt_setup_v1_file_key(ci, mk->mk_secret.raw);
break;
case FSCRYPT_POLICY_V2:
err = fscrypt_setup_v2_file_key(ci, mk);
break;
default:
WARN_ON(1);
err = -EINVAL;
break;
}
if (err) if (err)
goto out_release_key; goto out_release_key;
...@@ -282,7 +390,8 @@ static void put_crypt_info(struct fscrypt_info *ci) ...@@ -282,7 +390,8 @@ static void put_crypt_info(struct fscrypt_info *ci)
if (ci->ci_direct_key) { if (ci->ci_direct_key) {
fscrypt_put_direct_key(ci->ci_direct_key); fscrypt_put_direct_key(ci->ci_direct_key);
} else { } else if ((ci->ci_ctfm != NULL || ci->ci_essiv_tfm != NULL) &&
!fscrypt_is_direct_key_policy(&ci->ci_policy)) {
crypto_free_skcipher(ci->ci_ctfm); crypto_free_skcipher(ci->ci_ctfm);
crypto_free_cipher(ci->ci_essiv_tfm); crypto_free_cipher(ci->ci_essiv_tfm);
} }
...@@ -312,7 +421,7 @@ static void put_crypt_info(struct fscrypt_info *ci) ...@@ -312,7 +421,7 @@ static void put_crypt_info(struct fscrypt_info *ci)
int fscrypt_get_encryption_info(struct inode *inode) int fscrypt_get_encryption_info(struct inode *inode)
{ {
struct fscrypt_info *crypt_info; struct fscrypt_info *crypt_info;
struct fscrypt_context ctx; union fscrypt_context ctx;
struct fscrypt_mode *mode; struct fscrypt_mode *mode;
struct key *master_key = NULL; struct key *master_key = NULL;
int res; int res;
...@@ -335,27 +444,12 @@ int fscrypt_get_encryption_info(struct inode *inode) ...@@ -335,27 +444,12 @@ int fscrypt_get_encryption_info(struct inode *inode)
} }
/* Fake up a context for an unencrypted directory */ /* Fake up a context for an unencrypted directory */
memset(&ctx, 0, sizeof(ctx)); memset(&ctx, 0, sizeof(ctx));
ctx.format = FS_ENCRYPTION_CONTEXT_FORMAT_V1; ctx.version = FSCRYPT_CONTEXT_V1;
ctx.contents_encryption_mode = FSCRYPT_MODE_AES_256_XTS; ctx.v1.contents_encryption_mode = FSCRYPT_MODE_AES_256_XTS;
ctx.filenames_encryption_mode = FSCRYPT_MODE_AES_256_CTS; ctx.v1.filenames_encryption_mode = FSCRYPT_MODE_AES_256_CTS;
memset(ctx.master_key_descriptor, 0x42, memset(ctx.v1.master_key_descriptor, 0x42,
FSCRYPT_KEY_DESCRIPTOR_SIZE); FSCRYPT_KEY_DESCRIPTOR_SIZE);
} else if (res != sizeof(ctx)) { res = sizeof(ctx.v1);
fscrypt_warn(inode,
"Unknown encryption context size (%d bytes)", res);
return -EINVAL;
}
if (ctx.format != FS_ENCRYPTION_CONTEXT_FORMAT_V1) {
fscrypt_warn(inode, "Unknown encryption context version (%d)",
ctx.format);
return -EINVAL;
}
if (ctx.flags & ~FSCRYPT_POLICY_FLAGS_VALID) {
fscrypt_warn(inode, "Unknown encryption context flags (0x%02x)",
ctx.flags);
return -EINVAL;
} }
crypt_info = kmem_cache_zalloc(fscrypt_info_cachep, GFP_NOFS); crypt_info = kmem_cache_zalloc(fscrypt_info_cachep, GFP_NOFS);
...@@ -364,14 +458,34 @@ int fscrypt_get_encryption_info(struct inode *inode) ...@@ -364,14 +458,34 @@ int fscrypt_get_encryption_info(struct inode *inode)
crypt_info->ci_inode = inode; crypt_info->ci_inode = inode;
crypt_info->ci_flags = ctx.flags; res = fscrypt_policy_from_context(&crypt_info->ci_policy, &ctx, res);
crypt_info->ci_data_mode = ctx.contents_encryption_mode; if (res) {
crypt_info->ci_filename_mode = ctx.filenames_encryption_mode; fscrypt_warn(inode,
memcpy(crypt_info->ci_master_key_descriptor, ctx.master_key_descriptor, "Unrecognized or corrupt encryption context");
FSCRYPT_KEY_DESCRIPTOR_SIZE); goto out;
memcpy(crypt_info->ci_nonce, ctx.nonce, FS_KEY_DERIVATION_NONCE_SIZE); }
switch (ctx.version) {
case FSCRYPT_CONTEXT_V1:
memcpy(crypt_info->ci_nonce, ctx.v1.nonce,
FS_KEY_DERIVATION_NONCE_SIZE);
break;
case FSCRYPT_CONTEXT_V2:
memcpy(crypt_info->ci_nonce, ctx.v2.nonce,
FS_KEY_DERIVATION_NONCE_SIZE);
break;
default:
WARN_ON(1);
res = -EINVAL;
goto out;
}
if (!fscrypt_supported_policy(&crypt_info->ci_policy, inode)) {
res = -EINVAL;
goto out;
}
mode = select_encryption_mode(crypt_info, inode); mode = select_encryption_mode(&crypt_info->ci_policy, inode);
if (IS_ERR(mode)) { if (IS_ERR(mode)) {
res = PTR_ERR(mode); res = PTR_ERR(mode);
goto out; goto out;
......
...@@ -189,12 +189,13 @@ find_or_insert_direct_key(struct fscrypt_direct_key *to_insert, ...@@ -189,12 +189,13 @@ find_or_insert_direct_key(struct fscrypt_direct_key *to_insert,
*/ */
BUILD_BUG_ON(sizeof(hash_key) > FSCRYPT_KEY_DESCRIPTOR_SIZE); BUILD_BUG_ON(sizeof(hash_key) > FSCRYPT_KEY_DESCRIPTOR_SIZE);
memcpy(&hash_key, ci->ci_master_key_descriptor, sizeof(hash_key)); memcpy(&hash_key, ci->ci_policy.v1.master_key_descriptor,
sizeof(hash_key));
spin_lock(&fscrypt_direct_keys_lock); spin_lock(&fscrypt_direct_keys_lock);
hash_for_each_possible(fscrypt_direct_keys, dk, dk_node, hash_key) { hash_for_each_possible(fscrypt_direct_keys, dk, dk_node, hash_key) {
if (memcmp(ci->ci_master_key_descriptor, dk->dk_descriptor, if (memcmp(ci->ci_policy.v1.master_key_descriptor,
FSCRYPT_KEY_DESCRIPTOR_SIZE) != 0) dk->dk_descriptor, FSCRYPT_KEY_DESCRIPTOR_SIZE) != 0)
continue; continue;
if (ci->ci_mode != dk->dk_mode) if (ci->ci_mode != dk->dk_mode)
continue; continue;
...@@ -237,7 +238,7 @@ fscrypt_get_direct_key(const struct fscrypt_info *ci, const u8 *raw_key) ...@@ -237,7 +238,7 @@ fscrypt_get_direct_key(const struct fscrypt_info *ci, const u8 *raw_key)
dk->dk_ctfm = NULL; dk->dk_ctfm = NULL;
goto err_free_dk; goto err_free_dk;
} }
memcpy(dk->dk_descriptor, ci->ci_master_key_descriptor, memcpy(dk->dk_descriptor, ci->ci_policy.v1.master_key_descriptor,
FSCRYPT_KEY_DESCRIPTOR_SIZE); FSCRYPT_KEY_DESCRIPTOR_SIZE);
memcpy(dk->dk_raw, raw_key, ci->ci_mode->keysize); memcpy(dk->dk_raw, raw_key, ci->ci_mode->keysize);
...@@ -262,7 +263,8 @@ static int setup_v1_file_key_direct(struct fscrypt_info *ci, ...@@ -262,7 +263,8 @@ static int setup_v1_file_key_direct(struct fscrypt_info *ci,
return -EINVAL; return -EINVAL;
} }
if (ci->ci_data_mode != ci->ci_filename_mode) { if (ci->ci_policy.v1.contents_encryption_mode !=
ci->ci_policy.v1.filenames_encryption_mode) {
fscrypt_warn(ci->ci_inode, fscrypt_warn(ci->ci_inode,
"Direct key mode not allowed with different contents and filenames modes"); "Direct key mode not allowed with different contents and filenames modes");
return -EINVAL; return -EINVAL;
...@@ -308,7 +310,7 @@ static int setup_v1_file_key_derived(struct fscrypt_info *ci, ...@@ -308,7 +310,7 @@ static int setup_v1_file_key_derived(struct fscrypt_info *ci,
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)
{ {
if (ci->ci_flags & FSCRYPT_POLICY_FLAG_DIRECT_KEY) if (ci->ci_policy.v1.flags & FSCRYPT_POLICY_FLAG_DIRECT_KEY)
return setup_v1_file_key_direct(ci, raw_master_key); return setup_v1_file_key_direct(ci, raw_master_key);
else else
return setup_v1_file_key_derived(ci, raw_master_key); return setup_v1_file_key_derived(ci, raw_master_key);
...@@ -321,11 +323,11 @@ int fscrypt_setup_v1_file_key_via_subscribed_keyrings(struct fscrypt_info *ci) ...@@ -321,11 +323,11 @@ int fscrypt_setup_v1_file_key_via_subscribed_keyrings(struct fscrypt_info *ci)
int err; int err;
key = find_and_lock_process_key(FSCRYPT_KEY_DESC_PREFIX, key = find_and_lock_process_key(FSCRYPT_KEY_DESC_PREFIX,
ci->ci_master_key_descriptor, ci->ci_policy.v1.master_key_descriptor,
ci->ci_mode->keysize, &payload); ci->ci_mode->keysize, &payload);
if (key == ERR_PTR(-ENOKEY) && ci->ci_inode->i_sb->s_cop->key_prefix) { if (key == ERR_PTR(-ENOKEY) && ci->ci_inode->i_sb->s_cop->key_prefix) {
key = find_and_lock_process_key(ci->ci_inode->i_sb->s_cop->key_prefix, key = find_and_lock_process_key(ci->ci_inode->i_sb->s_cop->key_prefix,
ci->ci_master_key_descriptor, ci->ci_policy.v1.master_key_descriptor,
ci->ci_mode->keysize, &payload); ci->ci_mode->keysize, &payload);
} }
if (IS_ERR(key)) if (IS_ERR(key))
......
This diff is collapsed.
...@@ -43,7 +43,7 @@ struct fscrypt_name { ...@@ -43,7 +43,7 @@ struct fscrypt_name {
#define fname_len(p) ((p)->disk_name.len) #define fname_len(p) ((p)->disk_name.len)
/* Maximum value for the third parameter of fscrypt_operations.set_context(). */ /* Maximum value for the third parameter of fscrypt_operations.set_context(). */
#define FSCRYPT_SET_CONTEXT_MAX_SIZE 28 #define FSCRYPT_SET_CONTEXT_MAX_SIZE 40
#ifdef CONFIG_FS_ENCRYPTION #ifdef CONFIG_FS_ENCRYPTION
/* /*
...@@ -135,6 +135,7 @@ extern void fscrypt_free_bounce_page(struct page *bounce_page); ...@@ -135,6 +135,7 @@ extern void fscrypt_free_bounce_page(struct page *bounce_page);
/* policy.c */ /* policy.c */
extern int fscrypt_ioctl_set_policy(struct file *, const void __user *); extern int fscrypt_ioctl_set_policy(struct file *, const void __user *);
extern int fscrypt_ioctl_get_policy(struct file *, void __user *); extern int fscrypt_ioctl_get_policy(struct file *, void __user *);
extern int fscrypt_ioctl_get_policy_ex(struct file *, void __user *);
extern int fscrypt_has_permitted_context(struct inode *, struct inode *); extern int fscrypt_has_permitted_context(struct inode *, struct inode *);
extern int fscrypt_inherit_context(struct inode *, struct inode *, extern int fscrypt_inherit_context(struct inode *, struct inode *,
void *, bool); void *, bool);
...@@ -361,6 +362,12 @@ static inline int fscrypt_ioctl_get_policy(struct file *filp, void __user *arg) ...@@ -361,6 +362,12 @@ static inline int fscrypt_ioctl_get_policy(struct file *filp, void __user *arg)
return -EOPNOTSUPP; return -EOPNOTSUPP;
} }
static inline int fscrypt_ioctl_get_policy_ex(struct file *filp,
void __user *arg)
{
return -EOPNOTSUPP;
}
static inline int fscrypt_has_permitted_context(struct inode *parent, static inline int fscrypt_has_permitted_context(struct inode *parent,
struct inode *child) struct inode *child)
{ {
......
...@@ -10,15 +10,13 @@ ...@@ -10,15 +10,13 @@
#include <linux/types.h> #include <linux/types.h>
#define FSCRYPT_KEY_DESCRIPTOR_SIZE 8
/* Encryption policy flags */ /* Encryption policy flags */
#define FSCRYPT_POLICY_FLAGS_PAD_4 0x00 #define FSCRYPT_POLICY_FLAGS_PAD_4 0x00
#define FSCRYPT_POLICY_FLAGS_PAD_8 0x01 #define FSCRYPT_POLICY_FLAGS_PAD_8 0x01
#define FSCRYPT_POLICY_FLAGS_PAD_16 0x02 #define FSCRYPT_POLICY_FLAGS_PAD_16 0x02
#define FSCRYPT_POLICY_FLAGS_PAD_32 0x03 #define FSCRYPT_POLICY_FLAGS_PAD_32 0x03
#define FSCRYPT_POLICY_FLAGS_PAD_MASK 0x03 #define FSCRYPT_POLICY_FLAGS_PAD_MASK 0x03
#define FSCRYPT_POLICY_FLAG_DIRECT_KEY 0x04 /* use master key directly */ #define FSCRYPT_POLICY_FLAG_DIRECT_KEY 0x04
#define FSCRYPT_POLICY_FLAGS_VALID 0x07 #define FSCRYPT_POLICY_FLAGS_VALID 0x07
/* Encryption algorithms */ /* Encryption algorithms */
...@@ -27,14 +25,24 @@ ...@@ -27,14 +25,24 @@
#define FSCRYPT_MODE_AES_128_CBC 5 #define FSCRYPT_MODE_AES_128_CBC 5
#define FSCRYPT_MODE_AES_128_CTS 6 #define FSCRYPT_MODE_AES_128_CTS 6
#define FSCRYPT_MODE_ADIANTUM 9 #define FSCRYPT_MODE_ADIANTUM 9
#define __FSCRYPT_MODE_MAX 9
struct fscrypt_policy { /*
* Legacy policy version; ad-hoc KDF and no key verification.
* For new encrypted directories, use fscrypt_policy_v2 instead.
*
* Careful: the .version field for this is actually 0, not 1.
*/
#define FSCRYPT_POLICY_V1 0
#define FSCRYPT_KEY_DESCRIPTOR_SIZE 8
struct fscrypt_policy_v1 {
__u8 version; __u8 version;
__u8 contents_encryption_mode; __u8 contents_encryption_mode;
__u8 filenames_encryption_mode; __u8 filenames_encryption_mode;
__u8 flags; __u8 flags;
__u8 master_key_descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE]; __u8 master_key_descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE];
}; };
#define fscrypt_policy fscrypt_policy_v1
/* /*
* Process-subscribed "logon" key description prefix and payload format. * Process-subscribed "logon" key description prefix and payload format.
...@@ -50,14 +58,45 @@ struct fscrypt_key { ...@@ -50,14 +58,45 @@ struct fscrypt_key {
}; };
/* /*
* Keys are specified by an arbitrary 8-byte key "descriptor", * New policy version with HKDF and key verification (recommended).
* matching fscrypt_policy::master_key_descriptor. */
#define FSCRYPT_POLICY_V2 2
#define FSCRYPT_KEY_IDENTIFIER_SIZE 16
struct fscrypt_policy_v2 {
__u8 version;
__u8 contents_encryption_mode;
__u8 filenames_encryption_mode;
__u8 flags;
__u8 __reserved[4];
__u8 master_key_identifier[FSCRYPT_KEY_IDENTIFIER_SIZE];
};
/* Struct passed to FS_IOC_GET_ENCRYPTION_POLICY_EX */
struct fscrypt_get_policy_ex_arg {
__u64 policy_size; /* input/output */
union {
__u8 version;
struct fscrypt_policy_v1 v1;
struct fscrypt_policy_v2 v2;
} policy; /* output */
};
/*
* v1 policy keys are specified by an arbitrary 8-byte key "descriptor",
* matching fscrypt_policy_v1::master_key_descriptor.
*/ */
#define FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR 1 #define FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR 1
/* /*
* Specifies a key. This doesn't contain the actual key itself; this is just * v2 policy keys are specified by a 16-byte key "identifier" which the kernel
* the "name" of the key. * calculates as a cryptographic hash of the key itself,
* matching fscrypt_policy_v2::master_key_identifier.
*/
#define FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER 2
/*
* Specifies a key, either for v1 or v2 policies. This doesn't contain the
* actual key itself; this is just the "name" of the key.
*/ */
struct fscrypt_key_specifier { struct fscrypt_key_specifier {
__u32 type; /* one of FSCRYPT_KEY_SPEC_TYPE_* */ __u32 type; /* one of FSCRYPT_KEY_SPEC_TYPE_* */
...@@ -65,6 +104,7 @@ struct fscrypt_key_specifier { ...@@ -65,6 +104,7 @@ struct fscrypt_key_specifier {
union { union {
__u8 __reserved[32]; /* reserve some extra space */ __u8 __reserved[32]; /* reserve some extra space */
__u8 descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE]; __u8 descriptor[FSCRYPT_KEY_DESCRIPTOR_SIZE];
__u8 identifier[FSCRYPT_KEY_IDENTIFIER_SIZE];
} u; } u;
}; };
...@@ -101,6 +141,7 @@ struct fscrypt_get_key_status_arg { ...@@ -101,6 +141,7 @@ struct fscrypt_get_key_status_arg {
#define FS_IOC_SET_ENCRYPTION_POLICY _IOR('f', 19, struct fscrypt_policy) #define FS_IOC_SET_ENCRYPTION_POLICY _IOR('f', 19, struct fscrypt_policy)
#define FS_IOC_GET_ENCRYPTION_PWSALT _IOW('f', 20, __u8[16]) #define FS_IOC_GET_ENCRYPTION_PWSALT _IOW('f', 20, __u8[16])
#define FS_IOC_GET_ENCRYPTION_POLICY _IOW('f', 21, struct fscrypt_policy) #define FS_IOC_GET_ENCRYPTION_POLICY _IOW('f', 21, struct fscrypt_policy)
#define FS_IOC_GET_ENCRYPTION_POLICY_EX _IOWR('f', 22, __u8[9]) /* size + version */
#define FS_IOC_ADD_ENCRYPTION_KEY _IOWR('f', 23, struct fscrypt_add_key_arg) #define FS_IOC_ADD_ENCRYPTION_KEY _IOWR('f', 23, struct fscrypt_add_key_arg)
#define FS_IOC_REMOVE_ENCRYPTION_KEY _IOWR('f', 24, struct fscrypt_remove_key_arg) #define FS_IOC_REMOVE_ENCRYPTION_KEY _IOWR('f', 24, struct fscrypt_remove_key_arg)
#define FS_IOC_GET_ENCRYPTION_KEY_STATUS _IOWR('f', 26, struct fscrypt_get_key_status_arg) #define FS_IOC_GET_ENCRYPTION_KEY_STATUS _IOWR('f', 26, struct fscrypt_get_key_status_arg)
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment