Commit cdeb21da authored by Eric Biggers's avatar Eric Biggers
Browse files

fscrypt: add fscrypt_add_test_dummy_key() 

Currently, the test_dummy_encryption mount option (which is used for
encryption I/O testing with xfstests) uses v1 encryption policies, and
it relies on userspace inserting a test key into the session keyring.

We need test_dummy_encryption to support v2 encryption policies too.
Requiring userspace to add the test key doesn't work well with v2
policies, since v2 policies only support the filesystem keyring (not the
session keyring), and keys in the filesystem keyring are lost when the
filesystem is unmounted.  Hooking all test code that unmounts and
re-mounts the filesystem would be difficult.

Instead, let's make the filesystem automatically add the test key to its
keyring when test_dummy_encryption is enabled.

That puts the responsibility for choosing the test key on the kernel.
We could just hard-code a key.  But out of paranoia, let's first try
using a per-boot random key, to prevent this code from being misused.
A per-boot key will work as long as no one expects dummy-encrypted files
to remain accessible after a reboot.  (gce-xfstests doesn't.)

Therefore, this patch adds a function fscrypt_add_test_dummy_key() which
implements the above.  The next patch will use it.

Link: https://lore.kernel.org/r/20200512233251.118314-3-ebiggers@kernel.org


Reviewed-by: default avatarTheodore Ts'o <tytso@mit.edu>
Reviewed-by: default avatarJaegeuk Kim <jaegeuk@kernel.org>
Signed-off-by: default avatarEric Biggers <ebiggers@google.com>
parent 8b859960

fs/crypto/fscrypt_private.h

+3 −0
Original line number Diff line number Diff line
@@ -437,6 +437,9 @@ struct key * 
fscrypt_find_master_key(struct super_block *sb,

			const struct fscrypt_key_specifier *mk_spec);



int fscrypt_add_test_dummy_key(struct super_block *sb,

			       struct fscrypt_key_specifier *key_spec);



int fscrypt_verify_key_added(struct super_block *sb,

			     const u8 identifier[FSCRYPT_KEY_IDENTIFIER_SIZE]);

fs/crypto/keyring.c

+74 −43
Original line number Diff line number Diff line
@@ -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"
@@ -424,7 +425,7 @@ static int add_existing_master_key(struct fscrypt_master_key *mk, 
	return 0;

}



static int add_master_key(struct super_block *sb,

static int do_add_master_key(struct super_block *sb,

			     struct fscrypt_master_key_secret *secret,

			     const struct fscrypt_key_specifier *mk_spec)

{
@@ -465,6 +466,35 @@ out_unlock: 
	return err;

}



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) {

		err = fscrypt_init_hkdf(&secret->hkdf, secret->raw,

					secret->size);

		if (err)

			return err;



		/*

		 * Now that the HKDF context is initialized, the raw key is no

		 * longer needed.

		 */

		memzero_explicit(secret->raw, secret->size);



		/* 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;
@@ -609,6 +639,15 @@ 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.key_id) {

		if (arg.raw_size != 0)
@@ -626,54 +665,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;

		break;

	case FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER:

		err = fscrypt_init_hkdf(&secret.hkdf, secret.raw, secret.size);

	err = add_master_key(sb, &secret, &arg.key_spec);

	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;

	/* Return the key identifier to userspace, if applicable */

	err = -EFAULT;

		if (copy_to_user(uarg->key_spec.u.identifier,

				 arg.key_spec.u.identifier,

	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;

		break;

	default:

		WARN_ON(1);

		err = -EINVAL;

		goto out_wipe_secret;

	}



	err = add_master_key(sb, &secret, &arg.key_spec);

	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

CRA Git | Maintained and supported by SUSTech CRA and CCSE