Add libfsverity_enable() API
Subsystems (2)
Eric Biggers
maintainercover Add libfsverity_enable() API
This patchset adds wrappers around FS_IOC_ENABLE_VERITY to the library API, and makes the fsverity commands share code to parse the libfsverity_merkle_tree_params.
This is my proposed alternative to Luca's patch
https://lkml.kernel.org/linux-fscrypt/[email protected]
Eric Biggers (2):
lib: add libfsverity_enable() and libfsverity_enable_with_sig() programs/fsverity: share code to parse tree parameters
include/libfsverity.h | 36 ++++++++++++++++++++++++++++++++++ lib/enable.c | 45 +++++++++++++++++++++++++++++++++++++++++++ programs/cmd_digest.c | 31 ++++------------------------- programs/cmd_enable.c | 34 ++++++++------------------------ programs/cmd_sign.c | 31 ++++------------------------- programs/fsverity.c | 42 ++++++++++++++++++++++++++++++++++++---- programs/fsverity.h | 19 ++++++++++++++---- 7 files changed, 150 insertions(+), 88 deletions(-) create mode 100644 lib/enable.c
Signature · 1 line
2.29.2
Eric Biggers
maintainerPATCH 1/2 lib: add libfsverity_enable() and libfsverity_enable_with_sig()
From: Eric Biggers <[email protected]>
Add convenience functions that wrap FS_IOC_ENABLE_VERITY but take a 'struct libfsverity_merkle_tree_params' instead of 'struct fsverity_enable_arg'. This is useful because it allows libfsverity users to deal with one common struct.
--- include/libfsverity.h | 36 ++++++++++++++++++++++++++++++++++ lib/enable.c | 45 +++++++++++++++++++++++++++++++++++++++++++ programs/cmd_enable.c | 28 +++++++++++++++------------ 3 files changed, 97 insertions(+), 12 deletions(-) create mode 100644 lib/enable.c
include/libfsverity.h +36 -0
@@ -112,6 +112,42 @@ libfsverity_sign_digest(const struct libfsverity_digest *digest,const struct libfsverity_signature_params *sig_params, uint8_t **sig_ret, size_t *sig_size_ret); +/** +* libfsverity_enable() - Enable fs-verity on a file +* @fd: read-only file descriptor to the file +* @params: pointer to the Merkle tree parameters +* +* This is a simple wrapper around the FS_IOC_ENABLE_VERITY ioctl. +* +* Return: 0 on success, -EINVAL for invalid arguments, or a negative errno +* value from the FS_IOC_ENABLE_VERITY ioctl. See +* Documentation/filesystems/fsverity.rst in the kernel source tree for +* the possible error codes from FS_IOC_ENABLE_VERITY. +*/ +int +libfsverity_enable (int fd,const struct libfsverity_merkle_tree_params *params); + +/** +* libfsverity_enable_with_sig() - Enable fs-verity on a file, with a signature +* @fd: read-only file descriptor to the file +* @params: pointer to the Merkle tree parameters +* @sig: pointer to the file's signature +* @sig_size: size of the file's signature in bytes +* +* Like libfsverity_enable(), but allows specifying a built-in signature (i.e. a +* singature created with libfsverity_sign_digest()) to associate with the file. +* This is only needed if the in-kernel signature verification support is being +* used; it is not needed if signatures are being verified in userspace. +* +* If @sig is NULL and @sig_size is 0, this is the same as libfsverity_enable(). +* +* Return: See libfsverity_enable(). +*/ +int +libfsverity_enable_with_sig (int fd, +const struct libfsverity_merkle_tree_params *params, +const uint8_t *sig,size_t sig_size); +/** * libfsverity_find_hash_alg_by_name() - Find hash algorithm by name * @name: Pointer to name of hash algorithm
lib/enable.c new file +45 -0
45 lines not on this page · raw message
programs/cmd_enable.c +16 -12
@@ -68,9 +68,10 @@ static const struct option longopts[] = {int fsverity_cmd_enable (const struct fsverity_command *cmd,int argc,char *argv[]) { -struct fsverity_enable_arg arg = { .version =1 }; +struct libfsverity_merkle_tree_params tree_params = { .version =1 };u8 *salt =NULL ;u8 *sig =NULL ; +u32 sig_size =0 ;struct filedes file;int status;int c;
@@ -78,26 +79,28 @@ int fsverity_cmd_enable(const struct fsverity_command *cmd,while ((c =getopt_long (argc, argv,"" , longopts,NULL )) !=-1 ) {switch (c) {case OPT_HASH_ALG : -if (!parse_hash_alg_option (optarg, &arg.hash_algorithm)) +if (!parse_hash_alg_option (optarg, + &tree_params.hash_algorithm)) goto out_usage;break ;case OPT_BLOCK_SIZE : -if (!parse_block_size_option (optarg, &arg.block_size)) +if (!parse_block_size_option (optarg, + &tree_params.block_size)) goto out_usage;break ;case OPT_SALT : -if (!parse_salt_option (optarg, &salt, &arg.salt_size)) +if (!parse_salt_option (optarg, &salt, + &tree_params.salt_size)) goto out_usage; - arg.salt_ptr = (uintptr_t )salt; + tree_params.salt = salt;break ;case OPT_SIGNATURE :if (sig !=NULL ) {error_msg ("--signature can only be specified once" ); goto out_usage; } -if (!read_signature (optarg, &sig, &arg.sig_size)) +if (!read_signature (optarg, &sig, &sig_size)) goto out_err; - arg.sig_ptr = (uintptr_t )sig;break ;default : goto out_usage;
@@ -110,15 +113,16 @@ int fsverity_cmd_enable(const struct fsverity_command *cmd,if (argc !=1 ) goto out_usage; -if (arg.hash_algorithm ==0 ) - arg.hash_algorithm =FS_VERITY_HASH_ALG_DEFAULT ; +if (tree_params.hash_algorithm ==0 ) + tree_params.hash_algorithm =FS_VERITY_HASH_ALG_DEFAULT ; -if (arg.block_size ==0 ) - arg.block_size =get_default_block_size (); +if (tree_params.block_size ==0 ) + tree_params.block_size =get_default_block_size ();if (!open_file (&file, argv[0 ],O_RDONLY ,0 )) goto out_err; -if (ioctl (file.fd,FS_IOC_ENABLE_VERITY , &arg) !=0 ) { + +if (libfsverity_enable_with_sig (file.fd, &tree_params, sig, sig_size)) {error_msg_errno ("FS_IOC_ENABLE_VERITY failed on '%s'" , file.name);filedes_close (&file);
Signature · 1 line
2.29.2
Eric Biggers
maintainerPATCH 2/2 programs/fsverity: share code to parse tree parameters
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
The "digest", "enable", and "sign" commands all parse the --hash-alg, --block-size, and --salt options and initialize a struct libfsverity_merkle_tree_params, so share the code that does this.
--- programs/cmd_digest.c | 31 ++++--------------------------- programs/cmd_enable.c | 30 ++++-------------------------- programs/cmd_sign.c | 31 ++++--------------------------- programs/fsverity.c | 42 ++++++++++++++++++++++++++++++++++++++---- programs/fsverity.h | 19 +++++++++++++++---- 5 files changed, 65 insertions(+), 88 deletions(-)
programs/cmd_digest.c +4 -27
@@ -14,14 +14,6 @@#include <fcntl.h> #include <getopt.h> -enum { -OPT_HASH_ALG , -OPT_BLOCK_SIZE , -OPT_SALT , -OPT_COMPACT , -OPT_FOR_BUILTIN_SIG , -}; -static const struct option longopts[] = { {"hash-alg" , required_argument,NULL ,OPT_HASH_ALG }, {"block-size" , required_argument,NULL ,OPT_BLOCK_SIZE },
@@ -44,9 +36,8 @@ struct fsverity_signed_digest {int fsverity_cmd_digest (const struct fsverity_command *cmd,int argc,char *argv[]) { -u8 *salt =NULL ;struct filedes file = { .fd =-1 }; -struct libfsverity_merkle_tree_params tree_params = { .version =1 }; +struct libfsverity_merkle_tree_params tree_params = {};bool compact = false, for_builtin_sig = false;int status;int c;
@@ -54,20 +45,10 @@ int fsverity_cmd_digest(const struct fsverity_command *cmd,while ((c =getopt_long (argc, argv,"" , longopts,NULL )) !=-1 ) {switch (c) {case OPT_HASH_ALG : -if (!parse_hash_alg_option (optarg, - &tree_params.hash_algorithm)) - goto out_usage; -break ;case OPT_BLOCK_SIZE : -if (!parse_block_size_option (optarg, - &tree_params.block_size)) - goto out_usage; -break ;case OPT_SALT : -if (!parse_salt_option (optarg, &salt, - &tree_params.salt_size)) +if (!parse_tree_param (c, optarg, &tree_params)) goto out_usage; - tree_params.salt = salt;break ;case OPT_COMPACT : compact = true;
@@ -86,11 +67,7 @@ int fsverity_cmd_digest(const struct fsverity_command *cmd,if (argc <1 ) goto out_usage; -if (tree_params.hash_algorithm ==0 ) - tree_params.hash_algorithm =FS_VERITY_HASH_ALG_DEFAULT ; - -if (tree_params.block_size ==0 ) - tree_params.block_size =get_default_block_size (); +finalize_tree_params (&tree_params);for (int i =0 ; i < argc; i++) {struct fsverity_signed_digest *d =NULL ;
@@ -146,7 +123,7 @@ int fsverity_cmd_digest(const struct fsverity_command *cmd, } status =0 ; out: -free (salt); +destroy_tree_params (&tree_params);return status; out_err:
programs/cmd_enable.c +4 -26
@@ -49,13 +49,6 @@ out:return ok; } -enum { -OPT_HASH_ALG , -OPT_BLOCK_SIZE , -OPT_SALT , -OPT_SIGNATURE , -}; -static const struct option longopts[] = { {"hash-alg" , required_argument,NULL ,OPT_HASH_ALG }, {"block-size" , required_argument,NULL ,OPT_BLOCK_SIZE },
@@ -68,8 +61,7 @@ static const struct option longopts[] = {int fsverity_cmd_enable (const struct fsverity_command *cmd,int argc,char *argv[]) { -struct libfsverity_merkle_tree_params tree_params = { .version =1 }; -u8 *salt =NULL ; +struct libfsverity_merkle_tree_params tree_params = {};u8 *sig =NULL ;u32 sig_size =0 ;struct filedes file;
@@ -79,20 +71,10 @@ int fsverity_cmd_enable(const struct fsverity_command *cmd,while ((c =getopt_long (argc, argv,"" , longopts,NULL )) !=-1 ) {switch (c) {case OPT_HASH_ALG : -if (!parse_hash_alg_option (optarg, - &tree_params.hash_algorithm)) - goto out_usage; -break ;case OPT_BLOCK_SIZE : -if (!parse_block_size_option (optarg, - &tree_params.block_size)) - goto out_usage; -break ;case OPT_SALT : -if (!parse_salt_option (optarg, &salt, - &tree_params.salt_size)) +if (!parse_tree_param (c, optarg, &tree_params)) goto out_usage; - tree_params.salt = salt;break ;case OPT_SIGNATURE :if (sig !=NULL ) {
@@ -113,11 +95,7 @@ int fsverity_cmd_enable(const struct fsverity_command *cmd,if (argc !=1 ) goto out_usage; -if (tree_params.hash_algorithm ==0 ) - tree_params.hash_algorithm =FS_VERITY_HASH_ALG_DEFAULT ; - -if (tree_params.block_size ==0 ) - tree_params.block_size =get_default_block_size (); +finalize_tree_params (&tree_params);if (!open_file (&file, argv[0 ],O_RDONLY ,0 )) goto out_err;
@@ -133,7 +111,7 @@ int fsverity_cmd_enable(const struct fsverity_command *cmd, status =0 ; out: -free (salt); +destroy_tree_params (&tree_params);free (sig);return status;
programs/cmd_sign.c +4 -27
@@ -26,14 +26,6 @@ static bool write_signature(const char *filename, const u8 *sig, u32 sig_size)return ok; } -enum { -OPT_HASH_ALG , -OPT_BLOCK_SIZE , -OPT_SALT , -OPT_KEY , -OPT_CERT , -}; -static const struct option longopts[] = { {"hash-alg" , required_argument,NULL ,OPT_HASH_ALG }, {"block-size" , required_argument,NULL ,OPT_BLOCK_SIZE },
@@ -48,8 +40,7 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd, int argc, char *argv[]) { struct filedes file = { .fd = -1 }; -u8 *salt =NULL ; -struct libfsverity_merkle_tree_params tree_params = { .version =1 }; +struct libfsverity_merkle_tree_params tree_params = {};struct libfsverity_signature_params sig_params = {};struct libfsverity_digest *digest =NULL ;char digest_hex[FS_VERITY_MAX_DIGEST_SIZE *2 +1 ];
@@ -61,20 +52,10 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,while ((c =getopt_long (argc, argv,"" , longopts,NULL )) !=-1 ) {switch (c) {case OPT_HASH_ALG : -if (!parse_hash_alg_option (optarg, - &tree_params.hash_algorithm)) - goto out_usage; -break ;case OPT_BLOCK_SIZE : -if (!parse_block_size_option (optarg, - &tree_params.block_size)) - goto out_usage; -break ;case OPT_SALT : -if (!parse_salt_option (optarg, &salt, - &tree_params.salt_size)) +if (!parse_tree_param (c, optarg, &tree_params)) goto out_usage; - tree_params.salt = salt;break ;case OPT_KEY :if (sig_params.keyfile !=NULL ) {
@@ -101,11 +82,7 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,if (argc !=2 ) goto out_usage; -if (tree_params.hash_algorithm ==0 ) - tree_params.hash_algorithm =FS_VERITY_HASH_ALG_DEFAULT ; - -if (tree_params.block_size ==0 ) - tree_params.block_size =get_default_block_size (); +finalize_tree_params (&tree_params);if (sig_params.keyfile ==NULL ) {error_msg ("Missing --key argument" );
@@ -143,7 +120,7 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd, status =0 ; out:filedes_close (&file); -free (salt); +destroy_tree_params (&tree_params);free (digest);free (sig);return status;
programs/fsverity.c +38 -4
72 lines not on this page · raw message
programs/fsverity.h +15 -4
@@ -23,6 +23,17 @@*/ #define FS_VERITY_MAX_DIGEST_SIZE 64 +enum { +OPT_BLOCK_SIZE , +OPT_CERT , +OPT_COMPACT , +OPT_FOR_BUILTIN_SIG , +OPT_HASH_ALG , +OPT_KEY , +OPT_SALT , +OPT_SIGNATURE , +}; +struct fsverity_command ;/* cmd_digest.c */
@@ -43,9 +54,9 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,/* fsverity.c */ void usage (const struct fsverity_command *cmd,FILE *fp); -bool parse_hash_alg_option (const char *arg,u32 *alg_ptr); -bool parse_block_size_option (const char *arg,u32 *size_ptr); -bool parse_salt_option (const char *arg,u8 **salt_ptr,u32 *salt_size_ptr); -u32 get_default_block_size (void ); +bool parse_tree_param (int opt_char,const char *arg, +struct libfsverity_merkle_tree_params *params); +void finalize_tree_params (struct libfsverity_merkle_tree_params *params); +void destroy_tree_params (struct libfsverity_merkle_tree_params *params);#endif /* PROGRAMS_FSVERITY_H */
Signature · 1 line
2.29.2
Re: [fsverity-utils PATCH 2/2] programs/fsverity: share code to parse tree parameters
Quoted 6 lines · Eric Biggers
From: Eric Biggers <[email protected]>
The "digest", "enable", and "sign" commands all parse the --hash-alg, --block-size, and --salt options and initialize a struct
libfsverity_merkle_tree_params, so share the code that does this.
Quoted 8 lines
Signed-off-by Eric Biggers <[email protected]>--- programs/cmd_digest.c | 31 ++++--------------------------- programs/cmd_enable.c | 30 ++++-------------------------- programs/cmd_sign.c | 31 ++++--------------------------- programs/fsverity.c | 42 ++++++++++++++++++++++++++++++++++++++---- programs/fsverity.h | 19 +++++++++++++++---- 5 files changed, 65 insertions(+), 88 deletions(-)
Signature · 2 lines
Kind regards, Luca Boccassi
Re: [fsverity-utils PATCH 1/2] lib: add libfsverity_enable() and libfsverity_enable_with_sig()
In reply to Eric BiggersQuoted 49 lines · Eric Biggers
From: Eric Biggers <[email protected]>
Add convenience functions that wrap
FS_IOC_ENABLE_VERITYbut take a 'structlibfsverity_merkle_tree_params' instead of 'structfsverity_enable_arg'. This is useful because it allows libfsverity users to deal with one common struct.Signed-off-by Eric Biggers <[email protected]>--- include/libfsverity.h | 36 ++++++++++++++++++++++++++++++++++ lib/enable.c | 45 +++++++++++++++++++++++++++++++++++++++++++ programs/cmd_enable.c | 28 +++++++++++++++------------ 3 files changed, 97 insertions(+), 12 deletions(-) create mode 100644 lib/enable.cinclude/libfsverity.h +26
-0@@ -112,6 +112,42 @@ libfsverity_sign_digest(const struct libfsverity_digest *digest,const struct libfsverity_signature_params *sig_params, uint8_t **sig_ret, size_t *sig_size_ret); +/** +* libfsverity_enable() - Enable fs-verity on a file +* @fd: read-only file descriptor to the file +* @params: pointer to the Merkle tree parameters +* +* This is a simple wrapper around the FS_IOC_ENABLE_VERITY ioctl. +* +* Return: 0 on success, -EINVAL for invalid arguments, or a negative errno +* value from the FS_IOC_ENABLE_VERITY ioctl. See +* Documentation/filesystems/fsverity.rst in the kernel source tree for +* the possible error codes from FS_IOC_ENABLE_VERITY. +*/ +int +libfsverity_enable (int fd,const struct libfsverity_merkle_tree_params *params); + +/** +* libfsverity_enable_with_sig() - Enable fs-verity on a file, with a signature +* @fd: read-only file descriptor to the file +* @params: pointer to the Merkle tree parameters +* @sig: pointer to the file's signature +* @sig_size: size of the file's signature in bytes +* +* Like libfsverity_enable(), but allows specifying a built-in signature (i.e. a +* singature created with libfsverity_sign_digest()) to associate with the file. +* This is only needed if the in-kernel signature verification support is being +* used; it is not needed if signatures are being verified in userspace.
include/libfsverity.h libfsverity_sign_digest(const struct libfsverity_digest *digest, · line 150
Quoted 10 lines
include/libfsverity.h +10
-0+* +* If @sig is NULL and @sig_size is 0, this is the same as libfsverity_enable(). +* +* Return: See libfsverity_enable(). +*/ +int +libfsverity_enable_with_sig (int fd, +const struct libfsverity_merkle_tree_params *params, +const uint8_t *sig,size_t sig_size); +
I don't have a strong preference either way, but any specific reason for a separate function rather than treating sig == NULL and sig_size == 0 as a signature-less enable? For clients deploying files, it would appear easier to me to just use empty parameters to choose between signed/not signed, without having to also change which API to call. But maybe there's some use case I'm missing where it's better to be explicit.
Quoted 44 lines
include/libfsverity.h +0
-0/** * libfsverity_find_hash_alg_by_name() - Find hash algorithm by name * @name: Pointer to name of hash algorithm lib/enable.c new file +35
-0@@ -0,0 +1,45 @@ +// SPDX-License-Identifier: MIT +/* +* Implementation of libfsverity_enable() and libfsverity_enable_with_sig(). +* +* Copyright 2020 Google LLC +* +* Use of this source code is governed by an MIT-style +* license that can be found in the LICENSE file or at +* https://opensource.org/licenses/MIT. +*/ + +#include "lib_private.h" + +#include <sys/ioctl.h> + +LIBEXPORT int +libfsverity_enable (int fd,const struct libfsverity_merkle_tree_params *params) +{ +return libfsverity_enable_with_sig (fd, params,NULL ,0 ); +} + +LIBEXPORT int +libfsverity_enable_with_sig (int fd, +const struct libfsverity_merkle_tree_params *params, +const uint8_t *sig,size_t sig_size) +{ +struct fsverity_enable_arg arg = {}; + +if (!params) { +libfsverity_error_msg ("missing required parameters for enable" ); +return -EINVAL ; + } + + arg.version =1 ; + arg.hash_algorithm = params->hash_algorithm;
lib/enable.c line 45
Quoted 10 lines
lib/enable.c new file +10
-0+ arg.block_size = params->block_size; + arg.salt_size = params->salt_size; + arg.salt_ptr = (uintptr_t )params->salt; + arg.sig_size = sig_size; + arg.sig_ptr = (uintptr_t )sig; + +if (ioctl (fd,FS_IOC_ENABLE_VERITY , &arg) !=0 ) +return -errno; +return 0 ; +}
I'm ok with leaving file handling to clients - after all, depending on infrastructure/bindings/helper libs/whatnot, file handling might vary wildly.
But could we at least provide a default for block size and hash algo, if none are specified?
While file handling is a generic concept and expected to be a solved problem for most programs, figuring out what the default block size should be or what hash algorithm to use is, are fs-verity specific concepts that most clients (at least those that I deal with) wouldn't care about in any way outside of this use, and would want it to "just work".
Apart from these 2 comments, I ran a quick test of the 2 new series, and everything works as expected. Thanks!
Signature · 2 lines
Kind regards, Luca Boccassi
Eric Biggers
maintainerRe: [fsverity-utils PATCH 1/2] lib: add libfsverity_enable() and libfsverity_enable_with_sig()
Quoted 61 lines · Luca Boccassi
Quoted 49 lines · Eric Biggers
From: Eric Biggers <[email protected]>
Add convenience functions that wrap
FS_IOC_ENABLE_VERITYbut take a 'structlibfsverity_merkle_tree_params' instead of 'structfsverity_enable_arg'. This is useful because it allows libfsverity users to deal with one common struct.Signed-off-by Eric Biggers <[email protected]>--- include/libfsverity.h | 36 ++++++++++++++++++++++++++++++++++ lib/enable.c | 45 +++++++++++++++++++++++++++++++++++++++++++ programs/cmd_enable.c | 28 +++++++++++++++------------ 3 files changed, 97 insertions(+), 12 deletions(-) create mode 100644 lib/enable.cinclude/libfsverity.h +26
-0@@ -112,6 +112,42 @@ libfsverity_sign_digest(const struct libfsverity_digest *digest,const struct libfsverity_signature_params *sig_params, uint8_t **sig_ret, size_t *sig_size_ret); +/** +* libfsverity_enable() - Enable fs-verity on a file +* @fd: read-only file descriptor to the file +* @params: pointer to the Merkle tree parameters +* +* This is a simple wrapper around the FS_IOC_ENABLE_VERITY ioctl. +* +* Return: 0 on success, -EINVAL for invalid arguments, or a negative errno +* value from the FS_IOC_ENABLE_VERITY ioctl. See +* Documentation/filesystems/fsverity.rst in the kernel source tree for +* the possible error codes from FS_IOC_ENABLE_VERITY. +*/ +int +libfsverity_enable (int fd,const struct libfsverity_merkle_tree_params *params); + +/** +* libfsverity_enable_with_sig() - Enable fs-verity on a file, with a signature +* @fd: read-only file descriptor to the file +* @params: pointer to the Merkle tree parameters +* @sig: pointer to the file's signature +* @sig_size: size of the file's signature in bytes +* +* Like libfsverity_enable(), but allows specifying a built-in signature (i.e. a +* singature created with libfsverity_sign_digest()) to associate with the file. +* This is only needed if the in-kernel signature verification support is being +* used; it is not needed if signatures are being verified in userspace. include/libfsverity.h libfsverity_sign_digest(const struct libfsverity_digest *digest, · line 150
Quoted 10 lines
include/libfsverity.h +10
-0+* +* If @sig is NULL and @sig_size is 0, this is the same as libfsverity_enable(). +* +* Return: See libfsverity_enable(). +*/ +int +libfsverity_enable_with_sig (int fd, +const struct libfsverity_merkle_tree_params *params, +const uint8_t *sig,size_t sig_size); +
Quoted 7 lines
I don't have a strong preference either way, but any specific reason for a separate function rather than treating sig == NULL and
sig_size== 0 as a signature-less enable? For clients deploying files, it would appear easier to me to just use empty parameters to choose between signed/not signed, without having to also change which API to call. But maybe there's some use case I'm missing where it's better to be explicit.
libfsverity_enable_with_sig() works since that; it allows sig == NULL and sig_size == 0.
The reason I don't want the regular libfsverity_enable() to take the signature parameters is that I'd like to encourage people to do userspace signature verification instead. I want to avoid implying that the in-kernel signature verification is something that everyone should use. Same reason I didn't want 'fsverity digest' to output fsverity_formatted_digest by default.
Quoted 39 lines
Quoted 14 lines
include/libfsverity.h +14
-0+LIBEXPORT int +libfsverity_enable_with_sig (int fd, +const struct libfsverity_merkle_tree_params *params, +const uint8_t *sig,size_t sig_size) +{ +struct fsverity_enable_arg arg = {}; + +if (!params) { +libfsverity_error_msg ("missing required parameters for enable" ); +return -EINVAL ; + } + + arg.version =1 ; + arg.hash_algorithm = params->hash_algorithm;include/libfsverity.h libfsverity_sign_digest(const struct libfsverity_digest *digest,
Quoted 10 lines
include/libfsverity.h +10
-0+ arg.block_size = params->block_size; + arg.salt_size = params->salt_size; + arg.salt_ptr = (uintptr_t )params->salt; + arg.sig_size = sig_size; + arg.sig_ptr = (uintptr_t )sig; + +if (ioctl (fd,FS_IOC_ENABLE_VERITY , &arg) !=0 ) +return -errno; +return 0 ; +}I'm ok with leaving file handling to clients - after all, depending on infrastructure/bindings/helper libs/whatnot, file handling might vary wildly.
But could we at least provide a default for block size and hash algo, if none are specified?
While file handling is a generic concept and expected to be a solved problem for most programs, figuring out what the default block size should be or what hash algorithm to use is, are fs-verity specific concepts that most clients (at least those that I deal with) wouldn't care about in any way outside of this use, and would want it to "just work".
Quoted 2 lines
Apart from these 2 comments, I ran a quick test of the 2 new series, and everything works as expected. Thanks!
First, providing defaults in libfsverity_enable() doesn't make sense unless the same defaults are provided in libfsverity_compute_digest() too.
Second, PAGE_SIZE is a bad default block size. It really should be a fixed value, like 4096, so that e.g. if you sign files on both x86 and PowerPC, or sign on x86 and enable on PowerPC, you get the same results.
So at least we shouldn't provide defaults unless it's done right.
I suppose it's probably not too late to change the default for the fsverity program, though. I doubt anyone is using it with a non-4K PAGE_SIZE yet.
Would it work for you if both libfsverity_compute_digest() and libfsverity_enable() defaulted to SHA-256 and 4096?
- Eric
Re: [fsverity-utils PATCH 1/2] lib: add libfsverity_enable() and libfsverity_enable_with_sig()
Quoted 70 lines · Eric Biggers
Quoted 61 lines · Luca Boccassi
Quoted 49 lines · Eric Biggers
From: Eric Biggers <[email protected]>
Add convenience functions that wrap
FS_IOC_ENABLE_VERITYbut take a 'structlibfsverity_merkle_tree_params' instead of 'structfsverity_enable_arg'. This is useful because it allows libfsverity users to deal with one common struct.Signed-off-by Eric Biggers <[email protected]>--- include/libfsverity.h | 36 ++++++++++++++++++++++++++++++++++ lib/enable.c | 45 +++++++++++++++++++++++++++++++++++++++++++ programs/cmd_enable.c | 28 +++++++++++++++------------ 3 files changed, 97 insertions(+), 12 deletions(-) create mode 100644 lib/enable.cinclude/libfsverity.h +26
-0@@ -112,6 +112,42 @@ libfsverity_sign_digest(const struct libfsverity_digest *digest,const struct libfsverity_signature_params *sig_params, uint8_t **sig_ret, size_t *sig_size_ret); +/** +* libfsverity_enable() - Enable fs-verity on a file +* @fd: read-only file descriptor to the file +* @params: pointer to the Merkle tree parameters +* +* This is a simple wrapper around the FS_IOC_ENABLE_VERITY ioctl. +* +* Return: 0 on success, -EINVAL for invalid arguments, or a negative errno +* value from the FS_IOC_ENABLE_VERITY ioctl. See +* Documentation/filesystems/fsverity.rst in the kernel source tree for +* the possible error codes from FS_IOC_ENABLE_VERITY. +*/ +int +libfsverity_enable (int fd,const struct libfsverity_merkle_tree_params *params); + +/** +* libfsverity_enable_with_sig() - Enable fs-verity on a file, with a signature +* @fd: read-only file descriptor to the file +* @params: pointer to the Merkle tree parameters +* @sig: pointer to the file's signature +* @sig_size: size of the file's signature in bytes +* +* Like libfsverity_enable(), but allows specifying a built-in signature (i.e. a +* singature created with libfsverity_sign_digest()) to associate with the file. +* This is only needed if the in-kernel signature verification support is being +* used; it is not needed if signatures are being verified in userspace. include/libfsverity.h libfsverity_sign_digest(const struct libfsverity_digest *digest, · line 150
Quoted 10 lines
include/libfsverity.h +10
-0+* +* If @sig is NULL and @sig_size is 0, this is the same as libfsverity_enable(). +* +* Return: See libfsverity_enable(). +*/ +int +libfsverity_enable_with_sig (int fd, +const struct libfsverity_merkle_tree_params *params, +const uint8_t *sig,size_t sig_size); +Quoted 7 lines
I don't have a strong preference either way, but any specific reason for a separate function rather than treating sig == NULL and
sig_size== 0 as a signature-less enable? For clients deploying files, it would appear easier to me to just use empty parameters to choose between signed/not signed, without having to also change which API to call. But maybe there's some use case I'm missing where it's better to be explicit.
Quoted 8 lines
libfsverity_enable_with_sig()works since that; it allows sig == NULL andsig_size== 0.The reason I don't want the regular
libfsverity_enable()to take the signature parameters is that I'd like to encourage people to do userspace signature verification instead. I want to avoid implying that the in-kernel signature verification is something that everyone should use. Same reason I didn't want 'fsverity digest' to outputfsverity_formatted_digestby default.
Ok, I understand - makes sense to me, thanks.
Maybe it's worth documenting in the the header description of the API that empty/null values are accepted and will result in enabling without signature check?
Quoted 51 lines
Quoted 39 lines
Quoted 14 lines
include/libfsverity.h +14
-0+LIBEXPORT int +libfsverity_enable_with_sig (int fd, +const struct libfsverity_merkle_tree_params *params, +const uint8_t *sig,size_t sig_size) +{ +struct fsverity_enable_arg arg = {}; + +if (!params) { +libfsverity_error_msg ("missing required parameters for enable" ); +return -EINVAL ; + } + + arg.version =1 ; + arg.hash_algorithm = params->hash_algorithm;include/libfsverity.h libfsverity_sign_digest(const struct libfsverity_digest *digest,
Quoted 10 lines
include/libfsverity.h +10
-0+ arg.block_size = params->block_size; + arg.salt_size = params->salt_size; + arg.salt_ptr = (uintptr_t )params->salt; + arg.sig_size = sig_size; + arg.sig_ptr = (uintptr_t )sig; + +if (ioctl (fd,FS_IOC_ENABLE_VERITY , &arg) !=0 ) +return -errno; +return 0 ; +}I'm ok with leaving file handling to clients - after all, depending on infrastructure/bindings/helper libs/whatnot, file handling might vary wildly.
But could we at least provide a default for block size and hash algo, if none are specified?
While file handling is a generic concept and expected to be a solved problem for most programs, figuring out what the default block size should be or what hash algorithm to use is, are fs-verity specific concepts that most clients (at least those that I deal with) wouldn't care about in any way outside of this use, and would want it to "just work".
Quoted 2 lines
Apart from these 2 comments, I ran a quick test of the 2 new series, and everything works as expected. Thanks!
First, providing defaults in
libfsverity_enable()doesn't make sense unless the same defaults are provided inlibfsverity_compute_digest()too.Second,
PAGE_SIZEis a bad default block size. It really should be a fixed value, like 4096, so that e.g. if you sign files on both x86 and PowerPC, or sign on x86 and enable on PowerPC, you get the same results.So at least we shouldn't provide defaults unless it's done right.
Quoted 7 lines
I suppose it's probably not too late to change the default for the fsverity program, though. I doubt anyone is using it with a non-4K
PAGE_SIZEyet.Would it work for you if both
libfsverity_compute_digest()andlibfsverity_enable()defaulted to SHA-256 and 4096?- Eric
Yes, using those defaults in the functions would work perfectly fine for me, thank you!
Signature · 2 lines
Kind regards, Luca Boccassi
Eric Biggers
maintainerRe: [fsverity-utils PATCH 1/2] lib: add libfsverity_enable() and libfsverity_enable_with_sig()
Quoted 80 lines · Luca Boccassi
Quoted 70 lines · Eric Biggers
Quoted 61 lines · Luca Boccassi
Quoted 49 lines · Eric Biggers
From: Eric Biggers <[email protected]>
Add convenience functions that wrap
FS_IOC_ENABLE_VERITYbut take a 'structlibfsverity_merkle_tree_params' instead of 'structfsverity_enable_arg'. This is useful because it allows libfsverity users to deal with one common struct.Signed-off-by Eric Biggers <[email protected]>--- include/libfsverity.h | 36 ++++++++++++++++++++++++++++++++++ lib/enable.c | 45 +++++++++++++++++++++++++++++++++++++++++++ programs/cmd_enable.c | 28 +++++++++++++++------------ 3 files changed, 97 insertions(+), 12 deletions(-) create mode 100644 lib/enable.cinclude/libfsverity.h +26
-0@@ -112,6 +112,42 @@ libfsverity_sign_digest(const struct libfsverity_digest *digest,const struct libfsverity_signature_params *sig_params, uint8_t **sig_ret, size_t *sig_size_ret); +/** +* libfsverity_enable() - Enable fs-verity on a file +* @fd: read-only file descriptor to the file +* @params: pointer to the Merkle tree parameters +* +* This is a simple wrapper around the FS_IOC_ENABLE_VERITY ioctl. +* +* Return: 0 on success, -EINVAL for invalid arguments, or a negative errno +* value from the FS_IOC_ENABLE_VERITY ioctl. See +* Documentation/filesystems/fsverity.rst in the kernel source tree for +* the possible error codes from FS_IOC_ENABLE_VERITY. +*/ +int +libfsverity_enable (int fd,const struct libfsverity_merkle_tree_params *params); + +/** +* libfsverity_enable_with_sig() - Enable fs-verity on a file, with a signature +* @fd: read-only file descriptor to the file +* @params: pointer to the Merkle tree parameters +* @sig: pointer to the file's signature +* @sig_size: size of the file's signature in bytes +* +* Like libfsverity_enable(), but allows specifying a built-in signature (i.e. a +* singature created with libfsverity_sign_digest()) to associate with the file. +* This is only needed if the in-kernel signature verification support is being +* used; it is not needed if signatures are being verified in userspace. include/libfsverity.h libfsverity_sign_digest(const struct libfsverity_digest *digest, · line 150
Quoted 10 lines
include/libfsverity.h +10
-0+* +* If @sig is NULL and @sig_size is 0, this is the same as libfsverity_enable(). +* +* Return: See libfsverity_enable(). +*/ +int +libfsverity_enable_with_sig (int fd, +const struct libfsverity_merkle_tree_params *params, +const uint8_t *sig,size_t sig_size); +Quoted 7 lines
I don't have a strong preference either way, but any specific reason for a separate function rather than treating sig == NULL and
sig_size== 0 as a signature-less enable? For clients deploying files, it would appear easier to me to just use empty parameters to choose between signed/not signed, without having to also change which API to call. But maybe there's some use case I'm missing where it's better to be explicit.Quoted 8 lines
libfsverity_enable_with_sig()works since that; it allows sig == NULL andsig_size== 0.The reason I don't want the regular
libfsverity_enable()to take the signature parameters is that I'd like to encourage people to do userspace signature verification instead. I want to avoid implying that the in-kernel signature verification is something that everyone should use. Same reason I didn't want 'fsverity digest' to outputfsverity_formatted_digestby default.
Quoted 6 lines
Ok, I understand - makes sense to me, thanks.
Maybe it's worth documenting in the the header description of the API that empty/null values are accepted and will result in enabling without signature check?
It's already there:
* If @sig is NULL and @sig_size is 0, this is the same as libfsverity_enable().
Re: [fsverity-utils PATCH 1/2] lib: add libfsverity_enable() and libfsverity_enable_with_sig()
Quoted 83 lines · Eric Biggers
Quoted 82 lines · Luca Boccassi
Quoted 70 lines · Eric Biggers
Quoted 61 lines · Luca Boccassi
Quoted 49 lines · Eric Biggers
From: Eric Biggers <[email protected]>
Add convenience functions that wrap
FS_IOC_ENABLE_VERITYbut take a 'structlibfsverity_merkle_tree_params' instead of 'structfsverity_enable_arg'. This is useful because it allows libfsverity users to deal with one common struct.Signed-off-by Eric Biggers <[email protected]>--- include/libfsverity.h | 36 ++++++++++++++++++++++++++++++++++ lib/enable.c | 45 +++++++++++++++++++++++++++++++++++++++++++ programs/cmd_enable.c | 28 +++++++++++++++------------ 3 files changed, 97 insertions(+), 12 deletions(-) create mode 100644 lib/enable.cinclude/libfsverity.h +26
-0@@ -112,6 +112,42 @@ libfsverity_sign_digest(const struct libfsverity_digest *digest,const struct libfsverity_signature_params *sig_params, uint8_t **sig_ret, size_t *sig_size_ret); +/** +* libfsverity_enable() - Enable fs-verity on a file +* @fd: read-only file descriptor to the file +* @params: pointer to the Merkle tree parameters +* +* This is a simple wrapper around the FS_IOC_ENABLE_VERITY ioctl. +* +* Return: 0 on success, -EINVAL for invalid arguments, or a negative errno +* value from the FS_IOC_ENABLE_VERITY ioctl. See +* Documentation/filesystems/fsverity.rst in the kernel source tree for +* the possible error codes from FS_IOC_ENABLE_VERITY. +*/ +int +libfsverity_enable (int fd,const struct libfsverity_merkle_tree_params *params); + +/** +* libfsverity_enable_with_sig() - Enable fs-verity on a file, with a signature +* @fd: read-only file descriptor to the file +* @params: pointer to the Merkle tree parameters +* @sig: pointer to the file's signature +* @sig_size: size of the file's signature in bytes +* +* Like libfsverity_enable(), but allows specifying a built-in signature (i.e. a +* singature created with libfsverity_sign_digest()) to associate with the file. +* This is only needed if the in-kernel signature verification support is being +* used; it is not needed if signatures are being verified in userspace. include/libfsverity.h libfsverity_sign_digest(const struct libfsverity_digest *digest, · line 150
Quoted 10 lines
include/libfsverity.h +10
-0+* +* If @sig is NULL and @sig_size is 0, this is the same as libfsverity_enable(). +* +* Return: See libfsverity_enable(). +*/ +int +libfsverity_enable_with_sig (int fd, +const struct libfsverity_merkle_tree_params *params, +const uint8_t *sig,size_t sig_size); +Quoted 7 lines
I don't have a strong preference either way, but any specific reason for a separate function rather than treating sig == NULL and
sig_size== 0 as a signature-less enable? For clients deploying files, it would appear easier to me to just use empty parameters to choose between signed/not signed, without having to also change which API to call. But maybe there's some use case I'm missing where it's better to be explicit.Quoted 8 lines
libfsverity_enable_with_sig()works since that; it allows sig == NULL andsig_size== 0.The reason I don't want the regular
libfsverity_enable()to take the signature parameters is that I'd like to encourage people to do userspace signature verification instead. I want to avoid implying that the in-kernel signature verification is something that everyone should use. Same reason I didn't want 'fsverity digest' to outputfsverity_formatted_digestby default.Ok, I understand - makes sense to me, thanks.
Quoted 8 lines
Quoted 4 lines
Maybe it's worth documenting in the the header description of the API that empty/null values are accepted and will result in enabling without signature check?
It's already there:
* If @sig is NULL and @sig_size is 0, this is the same as
libfsverity_enable().
Ah of course, sorry, right under my nose and still missed it :-)
Signature · 2 lines
Kind regards, Luca Boccassi