xfstests: test adding filesystem-level fscrypt key via key_id
Subsystems (2)
Eric Biggers
maintainercover xfstests: test adding filesystem-level fscrypt key via key_id
This series adds a test which tests adding a key to a filesystem's fscrypt keyring via an "fscrypt-provisioning" keyring key. This is an alternative to the normal method where the raw key is given directly.
I'm sending this out for comment, but it shouldn't be merged until the corresponding kernel patch has reached mainline. For more details, see the kernel patch:
https://lkml.kernel.org/linux-fscrypt/[email protected]/T/#u
This test depends on an xfs_io patch which adds the '-k' option to the 'add_enckey' command, e.g.:
xfs_io -c "add_enckey -k KEY_ID" MOUNTPOINT
This test is skipped if the needed kernel or xfs_io support is absent.
This has been tested on ext4, f2fs, and ubifs.
To apply cleanly, my other xfstests patch series
"[RFC PATCH 0/5] xfstests: verify ciphertext of IV_INO_LBLK_64 encryption policies" must be applied first.
This series can also be retrieved from
https://git.kernel.org/pub/scm/linux/kernel/git/ebiggers/xfstests-dev.git
tag "fscrypt-provisioning_2019-11-19".
Eric Biggers (3):
common/rc: handle option with argument in _require_xfs_io_command() common/encrypt: move constant test key to common code
generic: test adding filesystem-level fscrypt key via key_id
common/encrypt | 95 +++++++++++++++++++++---- common/rc | 2 +- tests/generic/580 | 17 ++--- tests/generic/806 | 156 ++++++++++++++++++++++++++++++++++++++++++ tests/generic/806.out | 73 ++++++++++++++++++++ tests/generic/group | 1 + 6 files changed, 316 insertions(+), 28 deletions(-) create mode 100644 tests/generic/806 create mode 100644 tests/generic/806.out
Signature · 1 line
2.24.0.432.g9d3f5f5b63-goog
Eric Biggers
maintainerRFC PATCH 1/3 common/rc: handle option with argument in _require_xfs_io_command()
From: Eric Biggers <[email protected]>
Fix _require_xfs_io_command() to handle options that take arguments when the argument is shown in the help text. E.g., it didn't work to run:
_require_xfs_io_command "add_enckey" "-k"
because the relevant line of the help text is:
-k KEY_ID -- ID of fscrypt-provisioning key containing the raw key
... but the grep command only matched "-k --", not "-k KEY_ID --".
--- common/rc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
common/rc +1 -1
@@ -2216,7 +2216,7 @@ _require_xfs_io_command() [ -n "$param" ] || return if [ -z "$param_checked" ]; then - $XFS_IO_PROG -c "help $command" | grep -q "^ $param --" || \ + $XFS_IO_PROG -c "help $command" | grep -E -q "^ $param ([a-zA-Z_]+ )?--" || \ _notrun "xfs_io $command doesn't support $param" else # xfs_io could result in "command %c not supported" if it was
Signature · 1 line
2.24.0.432.g9d3f5f5b63-goog
Eric Biggers
maintainerRFC PATCH 2/3 common/encrypt: move constant test key to common code
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
For some encryption tests it's helpful to always use the same key so that the test's output is always the same.
generic/580 already defines such a key, so move it into common/encrypt so that other tests can use it too.
--- common/encrypt | 11 +++++++++++ tests/generic/580 | 17 ++++------------- 2 files changed, 15 insertions(+), 13 deletions(-)
common/encrypt +10 -0
@@ -187,6 +187,17 @@ _scratch_mkfs_stable_inodes_encrypted() esac } +# For some tests it's helpful to always use the same key so that the test's +# output is always the same. For this purpose the following key can be used: +TEST_RAW_KEY+for i in {1..64}; do + TEST_RAW_KEY+="\\x$(printf "%02x" $i)" +done +# Key descriptor: arbitrary value +TEST_KEY_DESCRIPTOR="0000111122223333" +# Key identifier: HKDF-SHA512(key=$TEST_RAW_KEY, salt="", info="fscrypt\0\x01") +TEST_KEY_IDENTIFIER="69b2f6edeee720cce0577937eb8a6751" + # Give the invoking shell a new session keyring. This makes any keys we add to # the session keyring scoped to the lifetime of the test script. _new_session_keyring()
tests/generic/580 +4 -13
@@ -43,21 +43,12 @@ _scratch_mount test_with_policy_version() { local vers=$1 - local raw_key="" - local i - - for i in {1..64}; do - raw_key+="\\x$(printf "%02x" $i)" - done if (( vers = 1 )); then - # Key descriptor: arbitrary value - local keyspec="0000111122223333" + local keyspec=$TEST_KEY_DESCRIPTOR local add_enckey_args="-d $keyspec" else - # Key identifier: - # HKDF-SHA512(key=raw_key, salt="", info="fscrypt\0\x01") - local keyspec="69b2f6edeee720cce0577937eb8a6751" + local keyspec=$TEST_KEY_IDENTIFIER local add_enckey_args="" fi
@@ -75,7 +66,7 @@ test_with_policy_version() echo "# Getting encryption key status" _enckey_status $SCRATCH_MNT $keyspec echo "# Adding encryption key" - _add_enckey $SCRATCH_MNT "$raw_key" $add_enckey_args + _add_enckey $SCRATCH_MNT "$TEST_RAW_KEY" $add_enckey_args echo "# Creating encrypted file" echo contents > $dir/file echo "# Getting encryption key status"
@@ -90,7 +81,7 @@ test_with_policy_version() # Test removing key with a file open. echo "# Re-adding encryption key" - _add_enckey $SCRATCH_MNT "$raw_key" $add_enckey_args + _add_enckey $SCRATCH_MNT "$TEST_RAW_KEY" $add_enckey_args echo "# Creating another encrypted file" echo foo > $dir/file2 echo "# Removing key while an encrypted file is open"
Signature · 1 line
2.24.0.432.g9d3f5f5b63-goog
Eric Biggers
maintainerRFC PATCH 3/3 generic: test adding filesystem-level fscrypt key via key_id
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
Add a test which tests adding a key to a filesystem's fscrypt keyring via an "fscrypt-provisioning" keyring key. This is an alternative to the normal method where the raw key is given directly.
For more details, see the corresponding kernel patch:
https://lkml.kernel.org/linux-fscrypt/[email protected]/T/#u
This test depends on an xfs_io patch which adds the '-k' option to the 'add_enckey' command, e.g.:
xfs_io -c "add_enckey -k KEY_ID" MOUNTPOINT
This test is skipped if the needed kernel or xfs_io support is absent.
This has been tested on ext4, f2fs, and ubifs.
--- common/encrypt | 84 +++++++++++++++++++---- tests/generic/806 | 156 ++++++++++++++++++++++++++++++++++++++++++ tests/generic/806.out | 73 ++++++++++++++++++++ tests/generic/group | 1 + 4 files changed, 300 insertions(+), 14 deletions(-) create mode 100644 tests/generic/806 create mode 100644 tests/generic/806.out
common/encrypt +70 -14
@@ -227,6 +227,28 @@ _generate_raw_encryption_key() echo $raw } +# Serialize an integer into a CPU-endian bytestring of the given length, and +# print it as a string where each byte is hex-escaped. For example, +# `_num_to_hex 1000 4` = "\xe8\x03\x00\x00" if the CPU is little endian. +_num_to_hex() +{ + local value=$1 + local nbytes=$2 + local i + local big_endian=$(echo -ne '\x11' | od -tx2 | head -1 | \ + cut -f2 -d' ' | cut -c1) + + if (( big_endian )); then + for (( i = 0; i < nbytes; i++ )); do + printf '\\x%02x' $(((value >> (8*(nbytes-1-i))) & 0xff)) + done + else + for (( i = 0; i < nbytes; i++ )); do + printf '\\x%02x' $(((value >> (8*i)) & 0xff)) + done + fi +} + # Add the specified raw encryption key to the session keyring, using the # specified key descriptor. _add_session_encryption_key()
@@ -237,12 +259,12 @@ _add_session_encryption_key() # # Add the key to the session keyring. The required structure is: # - # #define FS_MAX_KEY_SIZE 64 + # #define FSCRYPT_MAX_KEY_SIZE 64 # struct fscrypt_key { - # u32 mode; - # u8 raw[FS_MAX_KEY_SIZE]; - # u32 size; - # } __packed; + # __u32 mode; + # __u8 raw[FSCRYPT_MAX_KEY_SIZE]; + # __u32 size; + # }; # # The kernel ignores 'mode' but requires that 'size' be 64. #
@@ -253,15 +275,8 @@ _add_session_encryption_key() # nice to use the common key prefix, but for now use the filesystem- # specific prefix to make it possible to test older kernels... # - local big_endian=$(echo -ne '\x11' | od -tx2 | head -1 | \ - cut -f2 -d' ' | cut -c1 ) - if (( big_endian )); then - local mode='\x00\x00\x00\x00' - local size='\x00\x00\x00\x40' - else - local mode='\x00\x00\x00\x00' - local size='\x40\x00\x00\x00' - fi + local mode=$(_num_to_hex 0 4) + local size=$(_num_to_hex 64 4) echo -n -e "${mode}${raw}${size}" | $KEYCTL_PROG padd logon $FSTYP:$keydesc @s >>$seqres.full }
@@ -389,6 +404,44 @@ _user_do_enckey_status() _user_do "$XFS_IO_PROG -c \"enckey_status $* $keyspec\" \"$mnt\"" } +# Require support for adding a key to a filesystem's fscrypt keyring via an +# "fscrypt-provisioning" keyring key. +_require_add_enckey_by_key_id() +{ + local mnt=$1 + + # Userspace support + _require_xfs_io_command "add_enckey" "-k" + + # Kernel support + if $XFS_IO_PROG -c "$add_enckey -k 12345 $mnt" \ + |& grep -q 'Invalid argument'; then + _notrun "Kernel doesn't support key_id parameter to FS_IOC_ADD_ENCRYPTION_KEY" + fi +} + +# Add a key of type "fscrypt-provisioning" to the session keyring and print the +# resulting key ID. +_add_fscrypt_provisioning_key() +{ + local desc=$1 + local type=$2 + local raw=$3 + + # The format of the key payload must be: + # + # struct fscrypt_provisioning_key_payload { + # __u32 type; + # __u32 __reserved; + # __u8 raw[]; + # }; + # + local type_hex=$(_num_to_hex $type 4) + local reserved=$(_num_to_hex 0 4) + echo -n -e "${type_hex}${reserved}${raw}" | + $KEYCTL_PROG padd fscrypt-provisioning "$desc" @s +} + # Retrieve the encryption nonce of the given inode as a hex string. The nonce # was randomly generated by the filesystem and isn't exposed directly to # userspace. But it can be read using the filesystem's debugging tools.
@@ -717,6 +770,9 @@ FSCRYPT_MODE_ADIANTUM=9 FSCRYPT_POLICY_FLAG_DIRECT_KEY=0x04 FSCRYPT_POLICY_FLAG_IV_INO_LBLK_64=0x08 +FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR=1 +FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER=2 + _fscrypt_mode_name_to_num() { local name=$1
tests/generic/806 new file +156 -0
156 lines not on this page · raw message
tests/generic/806.out new file +73 -0
73 lines not on this page · raw message
tests/generic/group +1 -0
@@ -589,3 +589,4 @@ 584 auto quick encrypt 585 auto rename 805 auto quick encrypt +806 auto quick encrypt
Signature · 1 line
2.24.0.432.g9d3f5f5b63-goog
Eric Biggers
maintainerRe: [RFC PATCH 3/3] generic: test adding filesystem-level fscrypt key via key_id
Quoted 5 lines · Eric Biggers
common/encrypt +5
-0+# Require support for adding a key to a filesystem's fscrypt keyring via an +# "fscrypt-provisioning" keyring key. +_require_add_enckey_by_key_id() +{ + local mnt=$1
common/encrypt _user_do_enckey_status() · line 421
Quoted 10 lines
common/encrypt +10
-0+ + # Userspace support + _require_xfs_io_command "add_enckey" "-k" + + # Kernel support + if $XFS_IO_PROG -c "$add_enckey -k 12345 $mnt" \ + |& grep -q 'Invalid argument'; then + _notrun "Kernel doesn't support key_id parameter to FS_IOC_ADD_ENCRYPTION_KEY" + fi +}
There's a bug here that makes the test not be skipped when it should. It should say:
if $XFS_IO_PROG -c "add_enckey -k 12345" "$mnt" \
I'll fix this in the next version.
- Eric
Quoted 31 lines · Eric Biggers
This series adds a test which tests adding a key to a filesystem's fscrypt keyring via an "fscrypt-provisioning" keyring key. This is an alternative to the normal method where the raw key is given directly.
I'm sending this out for comment, but it shouldn't be merged until the corresponding kernel patch has reached mainline. For more details, see the kernel patch:
https://lkml.kernel.org/linux-fscrypt/[email protected]/T/#uThis test depends on an
xfs_iopatch which adds the '-k' option to the 'add_enckey' command, e.g.:
xfs_io-c "add_enckey-kKEY_ID" MOUNTPOINTThis test is skipped if the needed kernel or
xfs_iosupport is absent.This has been tested on ext4, f2fs, and ubifs.
To apply cleanly, my other xfstests patch series
"[RFC PATCH 0/5] xfstests: verify ciphertext ofIV_INO_LBLK_64encryption policies" must be applied first.This series can also be retrieved from
https://git.kernel.org/pub/scm/linux/kernel/git/ebiggers/xfstests-dev.git
tag "fscrypt-provisioning_2019-11-19".Eric Biggers (3):
common/rc: handle option with argument in_require_xfs_io_command()common/encrypt: move constant test key to common code
generic: test adding filesystem-level fscrypt key viakey_id
Quoted 13 lines
common/encrypt | 95 +++++++++++++++++++++---- common/rc | 2 +- tests/generic/580 | 17 ++--- tests/generic/806 | 156 ++++++++++++++++++++++++++++++++++++++++++ tests/generic/806.out | 73 ++++++++++++++++++++ tests/generic/group | 1 + 6 files changed, 316 insertions(+), 28 deletions(-) create mode 100644 tests/generic/806 create mode 100644 tests/generic/806.outSignature · 1 line
2.24.0.432.g9d3f5f5b63-goog
I'm newbie with fscrypt so I started by encrypting a directory without the new feature
sudo tune2fs -O encrypt /dev/sda2
sudo fscrypt setup /
fscrypt encrypt foo
Worked.
Generally speaking I'd appreciate a usage example like here to the commit message:
https://lwn.net/Articles/692514/
Is this doable?
I might consider trying out the XFS test suite some day but right now it would be first nice to smoke test the feature quickly.
I think for this patch that would actually be mostly sufficient testing.
/Jarkko
Quoted 58 lines · Jarkko Sakkinen
Quoted 31 lines · Eric Biggers
This series adds a test which tests adding a key to a filesystem's fscrypt keyring via an "fscrypt-provisioning" keyring key. This is an alternative to the normal method where the raw key is given directly.
I'm sending this out for comment, but it shouldn't be merged until the corresponding kernel patch has reached mainline. For more details, see the kernel patch:
https://lkml.kernel.org/linux-fscrypt/[email protected]/T/#uThis test depends on an
xfs_iopatch which adds the '-k' option to the 'add_enckey' command, e.g.:
xfs_io-c "add_enckey-kKEY_ID" MOUNTPOINTThis test is skipped if the needed kernel or
xfs_iosupport is absent.This has been tested on ext4, f2fs, and ubifs.
To apply cleanly, my other xfstests patch series
"[RFC PATCH 0/5] xfstests: verify ciphertext ofIV_INO_LBLK_64encryption policies" must be applied first.This series can also be retrieved from
https://git.kernel.org/pub/scm/linux/kernel/git/ebiggers/xfstests-dev.git
tag "fscrypt-provisioning_2019-11-19".Eric Biggers (3):
common/rc: handle option with argument in_require_xfs_io_command()common/encrypt: move constant test key to common code
generic: test adding filesystem-level fscrypt key viakey_idQuoted 13 lines
common/encrypt | 95 +++++++++++++++++++++---- common/rc | 2 +- tests/generic/580 | 17 ++--- tests/generic/806 | 156 ++++++++++++++++++++++++++++++++++++++++++ tests/generic/806.out | 73 ++++++++++++++++++++ tests/generic/group | 1 + 6 files changed, 316 insertions(+), 28 deletions(-) create mode 100644 tests/generic/806 create mode 100644 tests/generic/806.outSignature · 1 line
2.24.0.432.g9d3f5f5b63-googI'm newbie with fscrypt so I started by encrypting a directory without the new feature
sudo tune2fs -O encrypt
/dev/sda2
sudo fscrypt setup /
fscrypt encrypt fooWorked.
Generally speaking I'd appreciate a usage example like here to the commit message:
Quoted 8 lines
https://lwn.net/Articles/692514/
Is this doable?
I might consider trying out the XFS test suite some day but right now it would be first nice to smoke test the feature quickly.
I think for this patch that would actually be mostly sufficient testing.
Sorry, this was meant for the kernel patch :-/
/Jarkko
Eric Biggers
maintainerQuoted 58 lines · Jarkko Sakkinen
Quoted 31 lines · Eric Biggers
This series adds a test which tests adding a key to a filesystem's fscrypt keyring via an "fscrypt-provisioning" keyring key. This is an alternative to the normal method where the raw key is given directly.
I'm sending this out for comment, but it shouldn't be merged until the corresponding kernel patch has reached mainline. For more details, see the kernel patch:
https://lkml.kernel.org/linux-fscrypt/[email protected]/T/#uThis test depends on an
xfs_iopatch which adds the '-k' option to the 'add_enckey' command, e.g.:
xfs_io-c "add_enckey-kKEY_ID" MOUNTPOINTThis test is skipped if the needed kernel or
xfs_iosupport is absent.This has been tested on ext4, f2fs, and ubifs.
To apply cleanly, my other xfstests patch series
"[RFC PATCH 0/5] xfstests: verify ciphertext ofIV_INO_LBLK_64encryption policies" must be applied first.This series can also be retrieved from
https://git.kernel.org/pub/scm/linux/kernel/git/ebiggers/xfstests-dev.git
tag "fscrypt-provisioning_2019-11-19".Eric Biggers (3):
common/rc: handle option with argument in_require_xfs_io_command()common/encrypt: move constant test key to common code
generic: test adding filesystem-level fscrypt key viakey_idQuoted 13 lines
common/encrypt | 95 +++++++++++++++++++++---- common/rc | 2 +- tests/generic/580 | 17 ++--- tests/generic/806 | 156 ++++++++++++++++++++++++++++++++++++++++++ tests/generic/806.out | 73 ++++++++++++++++++++ tests/generic/group | 1 + 6 files changed, 316 insertions(+), 28 deletions(-) create mode 100644 tests/generic/806 create mode 100644 tests/generic/806.outSignature · 1 line
2.24.0.432.g9d3f5f5b63-googI'm newbie with fscrypt so I started by encrypting a directory without the new feature
sudo tune2fs -O encrypt
/dev/sda2
sudo fscrypt setup /
fscrypt encrypt fooWorked.
Generally speaking I'd appreciate a usage example like here to the commit message:
Quoted 9 lines
https://lwn.net/Articles/692514/
Is this doable?
I might consider trying out the XFS test suite some day but right now it would be first nice to smoke test the feature quickly.
I think for this patch that would actually be mostly sufficient testing.
You could manually do what the xfstest does, which is more or less the following (requires xfs_io patched with https://patchwork.kernel.org/patch/11252795/):
mkfs.ext4 -O encrypt /dev/vdc
mount /dev/vdc /vdc
keyctl new_session
payload='\x02\x00\x00\x00\x00\x00\x00\x00'
for i in {1..64}; do
payload+="\\x$(printf "%02x" $i)"
done
keyid=$(echo -ne "$payload" | keyctl padd fscrypt-provisioning desc @s)
keyspec=$(xfs_io -c "add_enckey -k $keyid" /vdc | awk '{print $NF}')
mkdir /vdc/edir
xfs_io -c "set_encpolicy $keyspec" /vdc/edir
echo contents > /vdc/edir/fileI'm not yet planning to use this feature in the 'fscrypt' userspace tool
https://github.com/google/fscrypt. The user who actually wants this feature (Android) isn't using the 'fscrypt' tool, but rather is using custom code.
Also, the 'fscrypt' tool isn't meant for testing or exposing every corner of the fscrypt kernel API. Rather, it's meant to be a user-friendly tool for creating encrypted directories on "regular" Linux distros, supporting lots of higher level userspace features like passphrase hashing with Argon2, multiple protectors, and auto-unlocking directories with PAM.
So for now, the important thing is to have an xfstest that fully tests this new API. For that, like the other fscrypt tests, I'm using keyctl and xfs_io to access the kernel API directly.
Later, if people really need the 'fscrypt' tool to do something that requires this feature, we can add it. This would likely take the form of a user-friendly option to 'fscrypt unlock' rather than a direct translation of the kernel API.
- Eric
Quoted 2 lines · Eric Biggers
You could manually do what the xfstest does, which is more or less the following (requires
xfs_iopatched with https://patchwork.kernel.org/patch/11252795/):
I postpone testing/reviewing this patch up until its depedencies are in the mainline.
I'll add these to my tree as soon as we have addressed a critical bug in tpm_tis:
1. KEYS: remove CONFIG_KEYS_COMPAT
2. KEYS: asymmetric: return ENOMEM if akcipher_request_alloc() fails
Just mentioning that I haven't forgotten them.
/Jarkko
Eric Biggers
maintainerHi Jarkko,
Quoted 7 lines · Jarkko Sakkinen
Quoted 2 lines · Eric Biggers
You could manually do what the xfstest does, which is more or less the following (requires
xfs_iopatched with https://patchwork.kernel.org/patch/11252795/):I postpone testing/reviewing this patch up until its depedencies are in the mainline.
Quoted 8 lines
I'll add these to my tree as soon as we have addressed a critical bug in
tpm_tis:1. KEYS: remove
CONFIG_KEYS_COMPAT
2. KEYS: asymmetric: return ENOMEM ifakcipher_request_alloc()failsJust mentioning that I haven't forgotten them.
xfstests and xfsprogs are developed separately from the kernel, and their maintainers don't apply patches that depend on non-mainlined features. So unless there are objections to the kernel patch [1], in a couple weeks I'll apply it to the fscrypt tree for 5.6, and then once it's in mainline I'll resend the patches for the test. I've simply sent the test out early as an RFC, in case it helps reviewing the kernel patch or in case there are early comments.
Again, while you're certainly welcome to manually test the kernel patch, it's more important that we have test coverage of it in xfstests.
[1] https://lkml.kernel.org/linux-fscrypt/[email protected]/
- Eric