Split fsverity-utils into a shared library
Subsystems (2)
v4 cover Split fsverity-utils into a shared library
From: Jes Sorensen <[email protected]>
Hi
This is an update to the libfsverity patches I posted about a month ago, which I believe address all the issues in the feedback I received.
I have a version of rpm that requires this library which is able to sign files and a plugin which will install fsverity signatures when the rpm is installed. The code for rpm can be found on github - note that I do rebase the repo as I fix bugs:
https://github.com/jessorensen/rpm/tree/rpm-fsverity
A git tree with these patches can also be found here:
https://git.kernel.org/pub/scm/linux/kernel/git/jes/fsverity-utils.git
This update changes a number of issues:
- Change the API for libfsverity_compute_digest() to take a callback read function, which is needed to deal with the internal cpio processing of rpm.
- Provides the option to build fsverity linked statically against libfsverity
- Makefile support to install libfsverity.so, libfsverity.h and sets the soname
- Make struct fsverity_descriptor and struct fsverity_hash_alg internal to the library
- Improved documentation of the API in libfsverity.h
I have a .spec file for it that packages this into an rpm for Fedora, as well as a packaged version of rpm with fsverity support in it, which I am happy to share.
Let me know what you think!
Thanks,
Jes
Jes Sorensen (20):
Build basic shared library framework
Change compute_file_measurement() to take a file descriptor as
argument
Move fsverity_descriptor definition to libfsverity.h
Move hash algorithm code to shared library
Create libfsverity_compute_digest() and adapt cmd_sign to use it Introduce libfsverity_sign_digest()
Validate input arguments to libfsverity_compute_digest() Validate input parameters for libfsverity_sign_digest() Document API of libfsverity
Change libfsverity_compute_digest() to take a read function Make full_{read,write}() return proper error codes instead of bool
libfsverity: Remove dependencies on util.c
Update Makefile to install libfsverity and fsverity.h Change libfsverity_find_hash_alg_by_name() to return the alg number Make libfsverity_find_hash_alg_by_name() private to the shared library libfsverity_sign_digest() use ARRAY_SIZE() fsverity_cmd_sign() use sizeof() input argument instead of struct fsverity_cmd_sign() don't exit on error without closing file
descriptor
Improve documentation of libfsverity.h API
Fixup Makefile
Makefile | 49 +++- cmd_enable.c | 19 +- cmd_measure.c | 19 +- cmd_sign.c | 565 +++++------------------------------------ fsverity.c | 17 +- hash_algs.c | 95 ++++--- hash_algs.h | 36 +-- helpers.h | 43 ++++ libfsverity.h | 138 ++++++++++ libfsverity_private.h | 52 ++++ libverity.c | 572 ++++++++++++++++++++++++++++++++++++++++++ util.c | 15 +- util.h | 62 +---- 13 files changed, 1029 insertions(+), 653 deletions(-) create mode 100644 helpers.h create mode 100644 libfsverity.h create mode 100644 libfsverity_private.h create mode 100644 libverity.c
Signature · 1 line
2.25.3
PATCH v4 1/20 Build basic shared library framework
From: Jes Sorensen <[email protected]>
This introduces a dummy shared library to start moving things into.
--- Makefile | 18 +++++++++++++++--- libverity.c | 10 ++++++++++ 2 files changed, 25 insertions(+), 3 deletions(-) create mode 100644 libverity.c
Makefile +15 -3
@@ -1,20 +1,32 @@ EXE := fsverity +LIB := libfsverity.so CFLAGS := -O2 -Wall CPPFLAGS := -D_FILE_OFFSET_BITS=64 LDLIBS := -lcrypto DESTDIR := /usr/local +LIBDIR := /usr/lib64 SRC := $(wildcard *.c) -OBJ := $(SRC:.c=.o) +OBJ := fsverity.o hash_algs.o cmd_enable.o cmd_measure.o cmd_sign.o util.o +SSRC := libverity.c +SOBJ := libverity.so HDRS := $(wildcard *.h) all:$(EXE) -$(EXE):$(OBJ) +$(EXE):$(OBJ) $(LIB) + $(CC) -o $@ $(OBJ) $(LDLIBS) -L . -l fsverity $(OBJ): %.o: %.c $(HDRS) + $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@ + +$(SOBJ): %.so: %.c $(HDRS) + $(CC) -c -fPIC $(CFLAGS) $(CPPFLAGS) $< -o $@ + +libfsverity.so: $(SOBJ) + $(CC) $(LDLIBS) -shared -o libfsverity.so $(SOBJ) clean: - rm -f $(EXE) $(OBJ) + rm -f $(EXE) $(OBJ) $(SOBJ) $(LIB) install:all install -Dm755 -t $(DESTDIR)/bin $(EXE)
libverity.c new file +10 -0
@@ -0,0 +1,10 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* +* The 'fsverity library' +* +* Copyright (C) 2018 Google LLC +* Copyright (C) 2020 Facebook +* +* Written by Eric Biggers and Jes Sorensen. +*/ +
Signature · 1 line
2.25.3
PATCH v4 2/20 Change compute_file_measurement() to take a file descriptor as argument
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
This preps the code for splitting the signing into the shared library
--- cmd_sign.c | 48 +++++++++++++++++++++++++++++++++++++----------- fsverity.c | 1 + libfsverity.h | 41 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 79 insertions(+), 11 deletions(-) create mode 100644 libfsverity.h
cmd_sign.c +37 -11
@@ -16,6 +16,8 @@#include <openssl/pkcs7.h> #include <stdlib.h> #include <string.h> +#include <sys/stat.h> +#include <unistd.h> #include "commands.h" #include "fsverity_uapi.h"
@@ -382,11 +384,30 @@ static bool hash_one_block(struct hash_ctx *hash, struct block_buffer *cur,return next->filled + hash->alg->digest_size > block_size; } +static int full_read_fd (int fd,void *buf,size_t count) +{ +while (count) { +int n =read (fd, buf,min (count,INT_MAX )); + +if (n <0 ) { +error_msg_errno ("reading from file" ); +return n; + } +if (n ==0 ) { +error_msg ("unexpected end-of-file" ); +return -ENODATA ; + } + buf += n; + count -= n; + } +return 0 ; +} +/* * Compute the file's Merkle tree root hash using the given hash algorithm, * block size, and salt. */ -static bool compute_root_hash (struct filedes *file,u64 file_size, +static bool compute_root_hash (int fd,u64 file_size,struct hash_ctx *hash,u32 block_size,const u8 *salt,u32 salt_size,u8 *root_hash) {
@@ -424,7 +445,7 @@ static bool compute_root_hash(struct filedes *file, u64 file_size,for (offset =0 ; offset < file_size; offset += block_size) { buffers[-1 ].filled =min (block_size, file_size - offset); -if (!full_read (file, buffers[-1 ].data, buffers[-1 ].filled)) +if (full_read_fd (fd, buffers[-1 ].data, buffers[-1 ].filled)) goto out; level =-1 ;
@@ -457,22 +478,22 @@ out:* The fs-verity measurement is the hash of the fsverity_descriptor, which * contains the Merkle tree properties including the root hash. */ -static bool compute_file_measurement (const char *filename, +static bool compute_file_measurement (int fd,const struct fsverity_hash_alg *hash_alg,u32 block_size,const u8 *salt,u32 salt_size,u8 *measurement) { -struct filedes file = { .fd =-1 };struct hash_ctx *hash =hash_create (hash_alg);u64 file_size;struct fsverity_descriptor desc; +struct stat stbuf;bool ok = false; -if (!open_file (&file, filename,O_RDONLY ,0 )) - goto out; - -if (!get_file_size (&file, &file_size)) +if (fstat (fd, &stbuf) !=0 ) { +error_msg_errno ("can't stat input file" ); goto out; + } + file_size = stbuf.st_size;memset (&desc,0 ,sizeof (desc)); desc.version =1 ;
@@ -495,14 +516,13 @@ static bool compute_file_measurement(const char *filename,/* Root hash of empty file is all 0's */ if (file_size !=0 && - !compute_root_hash (&file, file_size, hash, block_size, salt, + !compute_root_hash (fd, file_size, hash, block_size, salt, salt_size, desc.root_hash)) goto out;hash_full (hash, &desc,sizeof (desc), measurement); ok = true; out: -filedes_close (&file);hash_free (hash);return ok; }
@@ -529,6 +549,7 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd, int argc, char *argv[]) {const struct fsverity_hash_alg *hash_alg =NULL ; +struct filedes file = { .fd =-1 };u32 block_size =0 ;u8 *salt =NULL ;u32 salt_size =0 ;
@@ -603,10 +624,15 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd, digest->digest_algorithm =cpu_to_le16 (hash_alg - fsverity_hash_algs); digest->digest_size =cpu_to_le16 (hash_alg->digest_size); -if (!compute_file_measurement (argv[0 ], hash_alg, block_size, +if (!open_file (&file, argv[0 ],O_RDONLY ,0 )) + goto out_err; + +if (!compute_file_measurement (file.fd, hash_alg, block_size, salt, salt_size, digest->digest)) goto out_err; +filedes_close (&file); +if (!sign_data (digest,sizeof (*digest) + hash_alg->digest_size, keyfile, certfile, hash_alg, &sig, &sig_size)) goto out_err;
fsverity.c +1 -0
@@ -14,6 +14,7 @@#include "commands.h" #include "hash_algs.h" +#include "libfsverity.h" static const struct fsverity_command { const char *name;
libfsverity.h new file +41 -0
41 lines not on this page · raw message
Signature · 1 line
2.25.3
PATCH v4 3/20 Move fsverity_descriptor definition to libfsverity.h
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
--- cmd_sign.c | 19 +------------------ libfsverity.h | 26 +++++++++++++++++++++++++- 2 files changed, 26 insertions(+), 19 deletions(-)
cmd_sign.c +1 -18
@@ -20,26 +20,9 @@#include <unistd.h> #include "commands.h" -#include "fsverity_uapi.h" +#include "libfsverity.h" #include "hash_algs.h" -/* -* Merkle tree properties. The file measurement is the hash of this structure -* excluding the signature and with the sig_size field set to 0. -*/ -struct fsverity_descriptor { -__u8 version;/* must be 1 */ -__u8 hash_algorithm;/* Merkle tree hash algorithm */ -__u8 log_blocksize;/* log2 of size of data and tree blocks */ -__u8 salt_size;/* size of salt in bytes; 0 if none */ -__le32 sig_size;/* size of signature in bytes; 0 if none */ -__le64 data_size;/* size of file the Merkle tree is built over */ -__u8 root_hash[64 ];/* Merkle tree root hash */ -__u8 salt[32 ];/* salt prepended to each hashed block */ -__u8 __reserved[144 ];/* must be 0's */ -__u8 signature[];/* optional PKCS#7 signature */ -}; -/* * Format in which verity file measurements are signed. This is the same as * 'struct fsverity_digest', except here some magic bytes are prepended to
libfsverity.h +25 -1
@@ -13,13 +13,14 @@#include <stddef.h> #include <stdint.h> +#include <linux/types.h> #define FS_VERITY_HASH_ALG_SHA256 1#define FS_VERITY_HASH_ALG_SHA512 2struct libfsverity_merkle_tree_params {uint16_t version; -uint16_t hash_algorithm; +uint16_t hash_algorithm;/* Matches the digest_algorithm type */ uint32_t block_size;uint32_t salt_size;const uint8_t *salt;
@@ -27,6 +28,7 @@ struct libfsverity_merkle_tree_params { };struct libfsverity_digest { +char magic[8 ];/* must be "FSVerity" */ uint16_t digest_algorithm;uint16_t digest_size;uint8_t digest[];
@@ -38,4 +40,26 @@ struct libfsverity_signature_params { uint64_t reserved[11]; }; +/* +* Merkle tree properties. The file measurement is the hash of this structure +* excluding the signature and with the sig_size field set to 0. +*/ +struct fsverity_descriptor { +uint8_t version;/* must be 1 */ +uint8_t hash_algorithm;/* Merkle tree hash algorithm */ +uint8_t log_blocksize;/* log2 of size of data and tree blocks */ +uint8_t salt_size;/* size of salt in bytes; 0 if none */ +__le32 sig_size;/* size of signature in bytes; 0 if none */ +__le64 data_size;/* size of file the Merkle tree is built over */ +uint8_t root_hash[64 ];/* Merkle tree root hash */ +uint8_t salt[32 ];/* salt prepended to each hashed block */ +uint8_t __reserved[144 ];/* must be 0's */ +uint8_t signature[];/* optional PKCS#7 signature */ +}; + +int +libfsverity_compute_digest (int fd, +const struct libfsverity_merkle_tree_params *params, +struct libfsverity_digest **digest_ret); +#endif
Signature · 1 line
2.25.3
PATCH v4 4/20 Move hash algorithm code to shared library
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
Reimplement show_all_hash_algs() to not rely on direct access to the list, and add the algorithm number to the struct, so the user can find it easily.
--- Makefile | 6 +++--- cmd_enable.c | 11 ++++++++--- cmd_measure.c | 4 ++-- cmd_sign.c | 18 ++++++++++++------ fsverity.c | 15 ++++++++++++++- hash_algs.c | 26 +++++++------------------- hash_algs.h | 27 --------------------------- libfsverity.h | 22 ++++++++++++++++++++++ util.h | 2 ++ 9 files changed, 70 insertions(+), 61 deletions(-)
Makefile +3 -3
@@ -6,9 +6,9 @@ LDLIBS := -lcrypto DESTDIR := /usr/local LIBDIR := /usr/lib64 SRC := $(wildcard *.c) -OBJ := fsverity.o hash_algs.o cmd_enable.o cmd_measure.o cmd_sign.o util.o -SSRC := libverity.c -SOBJ := libverity.so +OBJ := fsverity.o cmd_enable.o cmd_measure.o cmd_sign.o util.o +SSRC := libverity.c hash_algs.c +SOBJ := libverity.so hash_algs.so HDRS := $(wildcard *.h) all:$(EXE)
cmd_enable.c +8 -3
@@ -16,7 +16,7 @@#include "commands.h" #include "fsverity_uapi.h" -#include "hash_algs.h" +#include "libfsverity.h" static bool parse_hash_alg_option (const char *arg,u32 *alg_ptr) {
@@ -36,11 +36,16 @@ static bool parse_hash_alg_option(const char *arg, u32 *alg_ptr) }/* Specified by name? */ - alg =find_hash_alg_by_name (arg); + alg =libfsverity_find_hash_alg_by_name (arg);if (alg !=NULL ) { - *alg_ptr = alg - fsverity_hash_algs; + *alg_ptr = alg->hash_num;return true; } +error_msg ("unknown hash algorithm: '%s'" , arg); +fputs ("Available hash algorithms: " , stderr); +show_all_hash_algs (stderr); +putc ('\n' , stderr); +return false; }
cmd_measure.c +2 -2
@@ -13,7 +13,7 @@#include "commands.h" #include "fsverity_uapi.h" -#include "hash_algs.h" +#include "libfsverity.h" /* Display the measurement of the given verity file(s). */ int fsverity_cmd_measure(const struct fsverity_command *cmd,
@@ -48,7 +48,7 @@ int fsverity_cmd_measure(const struct fsverity_command *cmd,ASSERT (d->digest_size <=FS_VERITY_MAX_DIGEST_SIZE );bin2hex (d->digest, d->digest_size, digest_hex); - hash_alg =find_hash_alg_by_num (d->digest_algorithm); + hash_alg =libfsverity_find_hash_alg_by_num (d->digest_algorithm);if (hash_alg) { hash_alg_name = hash_alg->name; }else {
cmd_sign.c +12 -6
@@ -466,7 +466,7 @@ static bool compute_file_measurement(int fd, u32 block_size, const u8 *salt, u32 salt_size, u8 *measurement) { - struct hash_ctx *hash = hash_create(hash_alg); + struct hash_ctx *hash = hash_alg->create_ctx(hash_alg);u64 file_size;struct fsverity_descriptor desc;struct stat stbuf;
@@ -480,7 +480,7 @@ static bool compute_file_measurement(int fd,memset (&desc,0 ,sizeof (desc)); desc.version =1 ; - desc.hash_algorithm = hash_alg - fsverity_hash_algs; + desc.hash_algorithm = hash_alg->hash_num;ASSERT (is_power_of_2 (block_size)); desc.log_blocksize =ilog2 (block_size);
@@ -552,9 +552,15 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,error_msg ("--hash-alg can only be specified once" ); goto out_usage; } - hash_alg =find_hash_alg_by_name (optarg); -if (hash_alg ==NULL ) + hash_alg =libfsverity_find_hash_alg_by_name (optarg); +if (hash_alg ==NULL ) { +error_msg ("unknown hash algorithm: '%s'" , + optarg); +fputs ("Available hash algorithms: " , stderr); +show_all_hash_algs (stderr); +putc ('\n' , stderr); goto out_usage; + }break ;case OPT_BLOCK_SIZE :if (!parse_block_size_option (optarg, &block_size))
@@ -590,7 +596,7 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd, goto out_usage;if (hash_alg ==NULL ) - hash_alg = &fsverity_hash_algs[FS_VERITY_HASH_ALG_DEFAULT ]; + hash_alg =libfsverity_find_hash_alg_by_num (FS_VERITY_HASH_ALG_DEFAULT );if (block_size ==0 ) block_size =get_default_block_size ();
@@ -604,7 +610,7 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd, digest =xzalloc (sizeof (*digest) + hash_alg->digest_size);memcpy (digest->magic,"FSVerity" ,8 ); - digest->digest_algorithm =cpu_to_le16 (hash_alg - fsverity_hash_algs); + digest->digest_algorithm =cpu_to_le16 (hash_alg->hash_num); digest->digest_size =cpu_to_le16 (hash_alg->digest_size);if (!open_file (&file, argv[0 ],O_RDONLY ,0 ))
fsverity.c +14 -1
@@ -13,7 +13,6 @@#include <unistd.h> #include "commands.h" -#include "hash_algs.h" #include "libfsverity.h" static const struct fsverity_command {
@@ -48,6 +47,20 @@ static const struct fsverity_command { } }; +void show_all_hash_algs (FILE *fp) +{ +int i =1 ; +const char *sep ="" ; +const struct fsverity_hash_alg *alg; + +while ((alg =libfsverity_find_hash_alg_by_num (i++))) { +if (alg && alg->name) { +fprintf (fp,"%s%s" , sep, alg->name); + sep =", " ; + } + } +} +static void usage_all (FILE *fp) {int i;
hash_algs.c +7 -19
@@ -12,6 +12,7 @@#include <string.h> #include "fsverity_uapi.h" +#include "libfsverity.h" #include "hash_algs.h" /* ========== libcrypto (OpenSSL) wrappers ========== */
@@ -106,17 +107,20 @@ const struct fsverity_hash_alg fsverity_hash_algs[] = { .name = "sha256", .digest_size = 32, .block_size = 64, + .hash_num = FS_VERITY_HASH_ALG_SHA256, .create_ctx = create_sha256_ctx, }, [FS_VERITY_HASH_ALG_SHA512] = { .name = "sha512", .digest_size = 64, .block_size = 128, + .hash_num = FS_VERITY_HASH_ALG_SHA512, .create_ctx = create_sha512_ctx, }, }; -const struct fsverity_hash_alg *find_hash_alg_by_name (const char *name) +const struct fsverity_hash_alg * +libfsverity_find_hash_alg_by_name (const char *name) {int i;
@@ -125,14 +129,11 @@ const struct fsverity_hash_alg *find_hash_alg_by_name(const char *name) !strcmp(name, fsverity_hash_algs[i].name)) return &fsverity_hash_algs[i]; } -error_msg ("unknown hash algorithm: '%s'" , name); -fputs ("Available hash algorithms: " , stderr); -show_all_hash_algs (stderr); -putc ('\n' , stderr);return NULL ; } -const struct fsverity_hash_alg *find_hash_alg_by_num (unsigned int num) +const struct fsverity_hash_alg * +libfsverity_find_hash_alg_by_num (unsigned int num) {if (num <ARRAY_SIZE (fsverity_hash_algs) && fsverity_hash_algs[num].name)
@@ -141,19 +142,6 @@ const struct fsverity_hash_alg *find_hash_alg_by_num(unsigned int num)return NULL ; } -void show_all_hash_algs (FILE *fp) -{ -int i; -const char *sep ="" ; - -for (i =0 ; i <ARRAY_SIZE (fsverity_hash_algs); i++) { -if (fsverity_hash_algs[i].name) { -fprintf (fp,"%s%s" , sep, fsverity_hash_algs[i].name); - sep =", " ; - } - } -} -/* ->init(), ->update(), and ->final() all in one step */ void hash_full (struct hash_ctx *ctx,const void *data,size_t size,u8 *digest) {
hash_algs.h +0 -27
@@ -6,15 +6,6 @@#include "util.h" -struct fsverity_hash_alg { -const char *name; -unsigned int digest_size; -unsigned int block_size; -struct hash_ctx *(*create_ctx)(const struct fsverity_hash_alg *alg); -}; - -extern const struct fsverity_hash_alg fsverity_hash_algs[]; -struct hash_ctx {const struct fsverity_hash_alg *alg;void (*init)(struct hash_ctx *ctx);
@@ -23,24 +14,6 @@ struct hash_ctx {void (*free)(struct hash_ctx *ctx); }; -const struct fsverity_hash_alg *find_hash_alg_by_name (const char *name); -const struct fsverity_hash_alg *find_hash_alg_by_num (unsigned int num); -void show_all_hash_algs (FILE *fp); - -/* The hash algorithm that fsverity-utils assumes when none is specified */ -#define FS_VERITY_HASH_ALG_DEFAULT FS_VERITY_HASH_ALG_SHA256 - -/* -* Largest digest size among all hash algorithms supported by fs-verity. -* This can be increased if needed. -*/ -#define FS_VERITY_MAX_DIGEST_SIZE 64 - -static inline struct hash_ctx *hash_create (const struct fsverity_hash_alg *alg) -{ -return alg->create_ctx (alg); -} -static inline void hash_init (struct hash_ctx *ctx) { ctx->init (ctx);
libfsverity.h +22 -0
@@ -18,6 +18,9 @@#define FS_VERITY_HASH_ALG_SHA256 1#define FS_VERITY_HASH_ALG_SHA512 2 +/* The hash algorithm that fsverity-utils assumes when none is specified */ +#define FS_VERITY_HASH_ALG_DEFAULT FS_VERITY_HASH_ALG_SHA256 +struct libfsverity_merkle_tree_params {uint16_t version;uint16_t hash_algorithm;/* Matches the digest_algorithm type */
@@ -27,6 +30,12 @@ struct libfsverity_merkle_tree_params {uint64_t reserved[11 ]; }; +/* +* Largest digest size among all hash algorithms supported by fs-verity. +* This can be increased if needed. +*/ +#define FS_VERITY_MAX_DIGEST_SIZE 64 +struct libfsverity_digest {char magic[8 ];/* must be "FSVerity" */ uint16_t digest_algorithm;
@@ -57,9 +66,22 @@ struct fsverity_descriptor { uint8_t signature[]; /* optional PKCS#7 signature */ }; +struct fsverity_hash_alg { +const char *name; +unsigned int digest_size; +unsigned int block_size; +uint16_t hash_num; +struct hash_ctx *(*create_ctx)(const struct fsverity_hash_alg *alg); +}; +int libfsverity_compute_digest (int fd,const struct libfsverity_merkle_tree_params *params,struct libfsverity_digest **digest_ret); +const struct fsverity_hash_alg * +libfsverity_find_hash_alg_by_name (const char *name); +const struct fsverity_hash_alg * +libfsverity_find_hash_alg_by_num (unsigned int num); +#endif
util.h +2 -0
@@ -122,4 +122,6 @@ bool filedes_close(struct filedes *file);bool hex2bin (const char *hex,u8 *bin,size_t bin_len);void bin2hex (const u8 *bin,size_t bin_len,char *hex); +void show_all_hash_algs (); +#endif /* UTIL_H */
Signature · 1 line
2.25.3
PATCH v4 5/20 Create libfsverity_compute_digest() and adapt cmd_sign to use it
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
This reorganizes the digest signing code and moves it to the shared library. In addition libfsverity_private.h is created for library internal data structures, in particular struct fsverity_decriptor.
--- cmd_sign.c | 194 ++------------------------------------- libfsverity.h | 17 ---- libfsverity_private.h | 33 +++++++ libverity.c | 207 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 250 insertions(+), 201 deletions(-) create mode 100644 libfsverity_private.h
cmd_sign.c +10 -184
@@ -16,12 +16,9 @@#include <openssl/pkcs7.h> #include <stdlib.h> #include <string.h> -#include <sys/stat.h> -#include <unistd.h> #include "commands.h" #include "libfsverity.h" -#include "hash_algs.h" /* * Format in which verity file measurements are signed. This is the same as
@@ -337,179 +334,6 @@ static bool write_signature(const char *filename, const u8 *sig, u32 sig_size)return ok; } -#define FS_VERITY_MAX_LEVELS 64 - -struct block_buffer { -u32 filled; -u8 *data; -}; - -/* -* Hash a block, writing the result to the next level's pending block buffer. -* Returns true if the next level's block became full, else false. -*/ -static bool hash_one_block (struct hash_ctx *hash,struct block_buffer *cur, -u32 block_size,const u8 *salt,u32 salt_size) -{ -struct block_buffer *next = cur +1 ; - -/* Zero-pad the block if it's shorter than block_size. */ -memset (&cur->data[cur->filled],0 , block_size - cur->filled); - -hash_init (hash); -hash_update (hash, salt, salt_size); -hash_update (hash, cur->data, block_size); -hash_final (hash, &next->data[next->filled]); - - next->filled += hash->alg->digest_size; - cur->filled =0 ; - -return next->filled + hash->alg->digest_size > block_size; -} - -static int full_read_fd (int fd,void *buf,size_t count) -{ -while (count) { -int n =read (fd, buf,min (count,INT_MAX )); - -if (n <0 ) { -error_msg_errno ("reading from file" ); -return n; - } -if (n ==0 ) { -error_msg ("unexpected end-of-file" ); -return -ENODATA ; - } - buf += n; - count -= n; - } -return 0 ; -} - -/* -* Compute the file's Merkle tree root hash using the given hash algorithm, -* block size, and salt. -*/ -static bool compute_root_hash (int fd,u64 file_size, -struct hash_ctx *hash,u32 block_size, -const u8 *salt,u32 salt_size,u8 *root_hash) -{ -const u32 hashes_per_block = block_size / hash->alg->digest_size; -const u32 padded_salt_size =roundup (salt_size, hash->alg->block_size); -u8 *padded_salt =xzalloc (padded_salt_size); -u64 blocks; -int num_levels =0 ; -int level; -struct block_buffer _buffers[1 +FS_VERITY_MAX_LEVELS +1 ] = {}; -struct block_buffer *buffers = &_buffers[1 ]; -u64 offset; -bool ok = false; - -if (salt_size !=0 ) -memcpy (padded_salt, salt, salt_size); - -/* Compute number of levels */ -for (blocks =DIV_ROUND_UP (file_size, block_size); blocks >1 ; - blocks =DIV_ROUND_UP (blocks, hashes_per_block)) { -ASSERT (num_levels <FS_VERITY_MAX_LEVELS ); - num_levels++; - } - -/* -* Allocate the block buffers. Buffer "-1" is for data blocks. -* Buffers 0 <= level < num_levels are for the actual tree levels. -* Buffer 'num_levels' is for the root hash. -*/ -for (level =-1 ; level < num_levels; level++) - buffers[level].data =xmalloc (block_size); - buffers[num_levels].data = root_hash; - -/* Hash each data block, also hashing the tree blocks as they fill up */ -for (offset =0 ; offset < file_size; offset += block_size) { - buffers[-1 ].filled =min (block_size, file_size - offset); - -if (full_read_fd (fd, buffers[-1 ].data, buffers[-1 ].filled)) - goto out; - - level =-1 ; -while (hash_one_block (hash, &buffers[level], block_size, - padded_salt, padded_salt_size)) { - level++; -ASSERT (level < num_levels); - } - } -/* Finish all nonempty pending tree blocks */ -for (level =0 ; level < num_levels; level++) { -if (buffers[level].filled !=0 ) -hash_one_block (hash, &buffers[level], block_size, - padded_salt, padded_salt_size); - } - -/* Root hash was filled by the last call to hash_one_block() */ -ASSERT (buffers[num_levels].filled == hash->alg->digest_size); - ok = true; -out: -for (level =-1 ; level < num_levels; level++) -free (buffers[level].data); -free (padded_salt); -return ok; -} - -/* -* Compute the fs-verity measurement of the given file. -* -* The fs-verity measurement is the hash of the fsverity_descriptor, which -* contains the Merkle tree properties including the root hash. -*/ -static bool compute_file_measurement (int fd, -const struct fsverity_hash_alg *hash_alg, -u32 block_size,const u8 *salt, -u32 salt_size,u8 *measurement) -{ -struct hash_ctx *hash = hash_alg->create_ctx (hash_alg); -u64 file_size; -struct fsverity_descriptor desc; -struct stat stbuf; -bool ok = false; - -if (fstat (fd, &stbuf) !=0 ) { -error_msg_errno ("can't stat input file" ); - goto out; - } - file_size = stbuf.st_size; - -memset (&desc,0 ,sizeof (desc)); - desc.version =1 ; - desc.hash_algorithm = hash_alg->hash_num; - -ASSERT (is_power_of_2 (block_size)); - desc.log_blocksize =ilog2 (block_size); - -if (salt_size !=0 ) { -if (salt_size >sizeof (desc.salt)) { -error_msg ("Salt too long (got %u bytes; max is %zu bytes)" , - salt_size,sizeof (desc.salt)); - goto out; - } -memcpy (desc.salt, salt, salt_size); - desc.salt_size = salt_size; - } - - desc.data_size =cpu_to_le64 (file_size); - -/* Root hash of empty file is all 0's */ -if (file_size !=0 && - !compute_root_hash (fd, file_size, hash, block_size, salt, - salt_size, desc.root_hash)) - goto out; - -hash_full (hash, &desc,sizeof (desc), measurement); - ok = true; -out: -hash_free (hash); -return ok; -} -enum {OPT_HASH_ALG ,OPT_BLOCK_SIZE ,
@@ -538,7 +362,8 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,u32 salt_size =0 ;const char *keyfile =NULL ;const char *certfile =NULL ; -struct fsverity_signed_digest *digest =NULL ; +struct libfsverity_digest *digest =NULL ; +struct libfsverity_merkle_tree_params params;char digest_hex[FS_VERITY_MAX_DIGEST_SIZE *2 +1 ];u8 *sig =NULL ;u32 sig_size;
@@ -608,16 +433,17 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,if (certfile ==NULL ) certfile = keyfile; - digest =xzalloc (sizeof (*digest) + hash_alg->digest_size); -memcpy (digest->magic,"FSVerity" ,8 ); - digest->digest_algorithm =cpu_to_le16 (hash_alg->hash_num); - digest->digest_size =cpu_to_le16 (hash_alg->digest_size); -if (!open_file (&file, argv[0 ],O_RDONLY ,0 )) goto out_err; -if (!compute_file_measurement (file.fd, hash_alg, block_size, - salt, salt_size, digest->digest)) +memset (¶ms,0 ,sizeof (struct libfsverity_merkle_tree_params )); + params.version =1 ; + params.hash_algorithm = hash_alg->hash_num; + params.block_size = block_size; + params.salt_size = salt_size; + params.salt = salt; + +if (libfsverity_compute_digest (file.fd, ¶ms, &digest)) goto out_err;filedes_close (&file);
libfsverity.h +0 -17
@@ -49,23 +49,6 @@ struct libfsverity_signature_params {uint64_t reserved[11 ]; }; -/* -* Merkle tree properties. The file measurement is the hash of this structure -* excluding the signature and with the sig_size field set to 0. -*/ -struct fsverity_descriptor { -uint8_t version;/* must be 1 */ -uint8_t hash_algorithm;/* Merkle tree hash algorithm */ -uint8_t log_blocksize;/* log2 of size of data and tree blocks */ -uint8_t salt_size;/* size of salt in bytes; 0 if none */ -__le32 sig_size;/* size of signature in bytes; 0 if none */ -__le64 data_size;/* size of file the Merkle tree is built over */ -uint8_t root_hash[64 ];/* Merkle tree root hash */ -uint8_t salt[32 ];/* salt prepended to each hashed block */ -uint8_t __reserved[144 ];/* must be 0's */ -uint8_t signature[];/* optional PKCS#7 signature */ -}; -struct fsverity_hash_alg {const char *name;unsigned int digest_size;
libfsverity_private.h new file +33 -0
@@ -0,0 +1,33 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* +* libfsverity private interfaces +* +* Copyright (C) 2018 Google LLC +* Copyright (C) 2020 Facebook +* +* Written by Eric Biggers and modified by Jes Sorensen. +*/ +#ifndef _LIBFSVERITY_PRIVATE_H +#define _LIBFSVERITY_PRIVATE_H + +#include <stdint.h> +#include <linux/types.h> + +/* +* Merkle tree properties. The file measurement is the hash of this structure +* excluding the signature and with the sig_size field set to 0. +*/ +struct fsverity_descriptor { +uint8_t version;/* must be 1 */ +uint8_t hash_algorithm;/* Merkle tree hash algorithm */ +uint8_t log_blocksize;/* log2 of size of data and tree blocks */ +uint8_t salt_size;/* size of salt in bytes; 0 if none */ +__le32 sig_size;/* size of signature in bytes; 0 if none */ +__le64 data_size;/* size of file the Merkle tree is built over */ +uint8_t root_hash[64 ];/* Merkle tree root hash */ +uint8_t salt[32 ];/* salt prepended to each hashed block */ +uint8_t __reserved[144 ];/* must be 0's */ +uint8_t signature[];/* optional PKCS#7 signature */ +}; + +#endif
libverity.c +207 -0
210 lines not on this page · raw message
Signature · 1 line
2.25.3
PATCH v4 6/20 Introduce libfsverity_sign_digest()
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
This moves the signing code into libfsverity and switches cmd_sign to use it.
--- cmd_sign.c | 317 ++------------------------------------------------ libfsverity.h | 12 ++ libverity.c | 309 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 329 insertions(+), 309 deletions(-)
cmd_sign.c +8 -309
@@ -10,318 +10,12 @@#include <fcntl.h> #include <getopt.h> #include <limits.h> -#include <openssl/bio.h> -#include <openssl/err.h> -#include <openssl/pem.h> -#include <openssl/pkcs7.h> #include <stdlib.h> #include <string.h> #include "commands.h" #include "libfsverity.h" -/* -* Format in which verity file measurements are signed. This is the same as -* 'struct fsverity_digest', except here some magic bytes are prepended to -* provide some context about what is being signed in case the same key is used -* for non-fsverity purposes, and here the fields have fixed endianness. -*/ -struct fsverity_signed_digest { -char magic[8 ];/* must be "FSVerity" */ -__le16 digest_algorithm; -__le16 digest_size; -__u8 digest[]; -}; - -static void __printf(1, 2) __cold -error_msg_openssl(const char *format, ...) -{ - va_list va; - - va_start(va, format); - do_error_msg(format, va, 0); -va_end (va); - - if (ERR_peek_error() == 0) - return; - - fprintf(stderr, "OpenSSL library errors:\n"); - ERR_print_errors_fp(stderr); -} - -/* Read a PEM PKCS#8 formatted private key */ -static EVP_PKEY *read_private_key(const char *keyfile) -{ - BIO *bio; -EVP_PKEY *pkey; - - bio = BIO_new_file(keyfile, "r"); - if (!bio) { -error_msg_openssl ("can't open '%s' for reading" , keyfile); -return NULL ; - } - - pkey =PEM_read_bio_PrivateKey (bio,NULL ,NULL ,NULL ); -if (!pkey) { -error_msg_openssl ("Failed to parse private key file '%s'.\n" -" Note: it must be in PEM PKCS#8 format." , - keyfile); - } -BIO_free (bio); -return pkey; -} - -/* Read a PEM X.509 formatted certificate */ -static X509 *read_certificate (const char *certfile) -{ -BIO *bio; -X509 *cert; - - bio =BIO_new_file (certfile,"r" ); -if (!bio) { -error_msg_openssl ("can't open '%s' for reading" , certfile); -return NULL ; - } - cert =PEM_read_bio_X509 (bio,NULL ,NULL ,NULL ); -if (!cert) { -error_msg_openssl ("Failed to parse X.509 certificate file '%s'.\n" -" Note: it must be in PEM format." , - certfile); - } -BIO_free (bio); -return cert; -} - -#ifdef OPENSSL_IS_BORINGSSL - -static bool sign_pkcs7 (const void *data_to_sign,size_t data_size, -EVP_PKEY *pkey,X509 *cert,const EVP_MD *md, -u8 **sig_ret,u32 *sig_size_ret) -{ -CBB out, outer_seq, wrapped_seq, seq, digest_algos_set, digest_algo, - null, content_info, issuer_and_serial, signer_infos, - signer_info, sign_algo, signature; -EVP_MD_CTX md_ctx; -u8 *name_der =NULL , *sig =NULL , *pkcs7_data =NULL ; -size_t pkcs7_data_len, sig_len; -int name_der_len, sig_nid; -bool ok = false; - -EVP_MD_CTX_init (&md_ctx); -BIGNUM *serial =ASN1_INTEGER_to_BN (X509_get_serialNumber (cert),NULL ); - -if (!CBB_init (&out,1024 )) { -error_msg ("out of memory" ); - goto out; - } - - name_der_len =i2d_X509_NAME (X509_get_subject_name (cert), &name_der); -if (name_der_len <0 ) { -error_msg_openssl ("i2d_X509_NAME failed" ); - goto out; - } - -if (!EVP_DigestSignInit (&md_ctx,NULL , md,NULL , pkey)) { -error_msg_openssl ("EVP_DigestSignInit failed" ); - goto out; - } - - sig_len =EVP_PKEY_size (pkey); - sig =xmalloc (sig_len); -if (!EVP_DigestSign (&md_ctx, sig, &sig_len, data_to_sign, data_size)) { -error_msg_openssl ("EVP_DigestSign failed" ); - goto out; - } - - sig_nid =EVP_PKEY_id (pkey); -/* To mirror OpenSSL behaviour, always use |NID_rsaEncryption| with RSA -* rather than the combined hash+pkey NID. */ -if (sig_nid != NID_rsaEncryption) { -OBJ_find_sigid_by_algs (&sig_nid,EVP_MD_type (md), -EVP_PKEY_id (pkey)); - } - -// See https://tools.ietf.org/html/rfc2315#section-7 -if (!CBB_add_asn1 (&out, &outer_seq,CBS_ASN1_SEQUENCE ) || - !OBJ_nid2cbb (&outer_seq, NID_pkcs7_signed) || - !CBB_add_asn1 (&outer_seq, &wrapped_seq,CBS_ASN1_CONTEXT_SPECIFIC | -CBS_ASN1_CONSTRUCTED |0 ) || -// See https://tools.ietf.org/html/rfc2315#section-9.1 - !CBB_add_asn1 (&wrapped_seq, &seq,CBS_ASN1_SEQUENCE ) || - !CBB_add_asn1_uint64 (&seq,1 /* version */ ) || - !CBB_add_asn1 (&seq, &digest_algos_set,CBS_ASN1_SET ) || - !CBB_add_asn1 (&digest_algos_set, &digest_algo,CBS_ASN1_SEQUENCE ) || - !OBJ_nid2cbb (&digest_algo,EVP_MD_type (md)) || - !CBB_add_asn1 (&digest_algo, &null,CBS_ASN1_NULL ) || - !CBB_add_asn1 (&seq, &content_info,CBS_ASN1_SEQUENCE ) || - !OBJ_nid2cbb (&content_info, NID_pkcs7_data) || - !CBB_add_asn1 (&seq, &signer_infos,CBS_ASN1_SET ) || - !CBB_add_asn1 (&signer_infos, &signer_info,CBS_ASN1_SEQUENCE ) || - !CBB_add_asn1_uint64 (&signer_info,1 /* version */ ) || - !CBB_add_asn1 (&signer_info, &issuer_and_serial, -CBS_ASN1_SEQUENCE ) || - !CBB_add_bytes (&issuer_and_serial, name_der, name_der_len) || - !BN_marshal_asn1 (&issuer_and_serial, serial) || - !CBB_add_asn1 (&signer_info, &digest_algo,CBS_ASN1_SEQUENCE ) || - !OBJ_nid2cbb (&digest_algo,EVP_MD_type (md)) || - !CBB_add_asn1 (&digest_algo, &null,CBS_ASN1_NULL ) || - !CBB_add_asn1 (&signer_info, &sign_algo,CBS_ASN1_SEQUENCE ) || - !OBJ_nid2cbb (&sign_algo, sig_nid) || - !CBB_add_asn1 (&sign_algo, &null,CBS_ASN1_NULL ) || - !CBB_add_asn1 (&signer_info, &signature,CBS_ASN1_OCTETSTRING ) || - !CBB_add_bytes (&signature, sig, sig_len) || - !CBB_finish (&out, &pkcs7_data, &pkcs7_data_len)) { -error_msg_openssl ("failed to construct PKCS#7 data" ); - goto out; - } - - *sig_ret =xmemdup (pkcs7_data, pkcs7_data_len); - *sig_size_ret = pkcs7_data_len; - ok = true; -out: -BN_free (serial); -EVP_MD_CTX_cleanup (&md_ctx); -CBB_cleanup (&out); -free (sig); -OPENSSL_free (name_der); -OPENSSL_free (pkcs7_data); -return ok; -} - -#else /* OPENSSL_IS_BORINGSSL */ - -static BIO *new_mem_buf (const void *buf,size_t size) -{ -BIO *bio; - -ASSERT (size <=INT_MAX ); -/* -* Prior to OpenSSL 1.1.0, BIO_new_mem_buf() took a non-const pointer, -* despite still marking the resulting bio as read-only. So cast away -* the const to avoid a compiler warning with older OpenSSL versions. -*/ - bio =BIO_new_mem_buf ((void *)buf, size); -if (!bio) -error_msg_openssl ("out of memory" ); -return bio; -} - -static bool sign_pkcs7 (const void *data_to_sign,size_t data_size, -EVP_PKEY *pkey,X509 *cert,const EVP_MD *md, -u8 **sig_ret,u32 *sig_size_ret) -{ -/* -* PKCS#7 signing flags: -* -* - PKCS7_BINARY signing binary data, so skip MIME translation -* -* - PKCS7_DETACHED omit the signed data (include signature only) -* -* - PKCS7_NOATTR omit extra authenticated attributes, such as -* SMIMECapabilities -* -* - PKCS7_NOCERTS omit the signer's certificate -* -* - PKCS7_PARTIAL PKCS7_sign() creates a handle only, then -* PKCS7_sign_add_signer() can add a signer later. -* This is necessary to change the message digest -* algorithm from the default of SHA-1. Requires -* OpenSSL 1.0.0 or later. -*/ -int pkcs7_flags =PKCS7_BINARY |PKCS7_DETACHED |PKCS7_NOATTR | -PKCS7_NOCERTS |PKCS7_PARTIAL ; -u8 *sig; -u32 sig_size; -BIO *bio =NULL ; -PKCS7 *p7 =NULL ; -bool ok = false; - - bio =new_mem_buf (data_to_sign, data_size); -if (!bio) - goto out; - - p7 =PKCS7_sign (NULL ,NULL ,NULL , bio, pkcs7_flags); -if (!p7) { -error_msg_openssl ("failed to initialize PKCS#7 signature object" ); - goto out; - } - -if (!PKCS7_sign_add_signer (p7, cert, pkey, md, pkcs7_flags)) { -error_msg_openssl ("failed to add signer to PKCS#7 signature object" ); - goto out; - } - -if (PKCS7_final (p7, bio, pkcs7_flags) !=1 ) { -error_msg_openssl ("failed to finalize PKCS#7 signature" ); - goto out; - } - -BIO_free (bio); - bio =BIO_new (BIO_s_mem ()); -if (!bio) { -error_msg_openssl ("out of memory" ); - goto out; - } - -if (i2d_PKCS7_bio (bio, p7) !=1 ) { -error_msg_openssl ("failed to DER-encode PKCS#7 signature object" ); - goto out; - } - - sig_size =BIO_get_mem_data (bio, &sig); - *sig_ret =xmemdup (sig, sig_size); - *sig_size_ret = sig_size; - ok = true; -out: -PKCS7_free (p7); -BIO_free (bio); -return ok; -} - -#endif /* !OPENSSL_IS_BORINGSSL */ - -/* -* Sign the specified @data_to_sign of length @data_size bytes using the private -* key in @keyfile, the certificate in @certfile, and the hash algorithm -* @hash_alg. Returns the DER-formatted PKCS#7 signature in @sig_ret and -* @sig_size_ret. -*/ -static bool sign_data (const void *data_to_sign,size_t data_size, -const char *keyfile,const char *certfile, -const struct fsverity_hash_alg *hash_alg, -u8 **sig_ret,u32 *sig_size_ret) -{ -EVP_PKEY *pkey =NULL ; -X509 *cert =NULL ; -const EVP_MD *md; -bool ok = false; - - pkey =read_private_key (keyfile); -if (!pkey) - goto out; - - cert =read_certificate (certfile); -if (!cert) - goto out; - -OpenSSL_add_all_digests (); - md =EVP_get_digestbyname (hash_alg->name); -if (!md) { -fprintf (stderr, -"Warning: '%s' algorithm not found in OpenSSL library.\n" -" Falling back to SHA-256 signature.\n" , - hash_alg->name); - md =EVP_sha256 (); - } - - ok =sign_pkcs7 (data_to_sign, data_size, pkey, cert, md, - sig_ret, sig_size_ret); -out: -EVP_PKEY_free (pkey); -X509_free (cert); -return ok; -} -static bool write_signature (const char *filename,const u8 *sig,u32 sig_size) {struct filedes file;
@@ -364,9 +58,10 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,const char *certfile =NULL ;struct libfsverity_digest *digest =NULL ;struct libfsverity_merkle_tree_params params; +struct libfsverity_signature_params sig_params;char digest_hex[FS_VERITY_MAX_DIGEST_SIZE *2 +1 ];u8 *sig =NULL ; -u32 sig_size; +size_t sig_size;int status;int c;
@@ -448,9 +143,13 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,filedes_close (&file); -if (!sign_data (digest,sizeof (*digest) + hash_alg->digest_size, - keyfile, certfile, hash_alg, &sig, &sig_size)) +memset (&sig_params,0 ,sizeof (struct libfsverity_signature_params )); + sig_params.keyfile = keyfile; + sig_params.certfile = certfile; +if (libfsverity_sign_digest (digest, &sig_params, &sig, &sig_size)) { +error_msg ("Failed to sign digest" ); goto out_err; + }if (!write_signature (argv[1 ], sig, sig_size)) goto out_err;
libfsverity.h +12 -0
@@ -36,6 +36,13 @@ struct libfsverity_merkle_tree_params {*/ #define FS_VERITY_MAX_DIGEST_SIZE 64 +/* +* Format in which verity file measurements are signed. This is the same as +* 'struct fsverity_digest', except here some magic bytes are prepended to +* provide some context about what is being signed in case the same key is used +* for non-fsverity purposes, and here the fields have fixed endianness. +*/ +struct libfsverity_digest {char magic[8 ];/* must be "FSVerity" */ uint16_t digest_algorithm;
@@ -62,6 +69,11 @@ libfsverity_compute_digest(int fd,const struct libfsverity_merkle_tree_params *params, struct libfsverity_digest **digest_ret); +int +libfsverity_sign_digest (const struct libfsverity_digest *digest, +const struct libfsverity_signature_params *sig_params, +uint8_t **sig_ret,size_t *sig_size_ret); +const struct fsverity_hash_alg *libfsverity_find_hash_alg_by_name (const char *name); const struct fsverity_hash_alg *
libverity.c +309 -0
312 lines not on this page · raw message
Signature · 1 line
2.25.3
PATCH v4 7/20 Validate input arguments to libfsverity_compute_digest()
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
If any argument is invalid, return -EINVAL. Similarly if any of the reserved fields in the params struct are set, return -EINVAL;
--- libverity.c | 31 +++++++++++++++++++++++-------- 1 file changed, 23 insertions(+), 8 deletions(-)
libverity.c +23 -8
@@ -155,9 +155,31 @@ libfsverity_compute_digest(int fd,struct fsverity_descriptor desc;struct stat stbuf;u64 file_size; -int retval = -EINVAL ; +int i, retval = -EINVAL ; + +if (!digest_ret) +return -EINVAL ; +if (params->version !=1 ) +return -EINVAL ; +if (!is_power_of_2 (params->block_size)) +return -EINVAL ; +if (params->salt_size >sizeof (desc.salt)) { +error_msg ("Salt too long (got %u bytes; max is %zu bytes)" , + params->salt_size,sizeof (desc.salt)); +return -EINVAL ; + } +if (params->salt_size && !params->salt) +return -EINVAL ; +for (i =0 ; + i <sizeof (params->reserved) /sizeof (params->reserved[0 ]); i++) { +if (params->reserved[i]) +return -EINVAL ; + } hash_alg =libfsverity_find_hash_alg_by_num (params->hash_algorithm); +if (!hash_alg) +return -EINVAL ; + hash = hash_alg->create_ctx (hash_alg); digest = malloc(sizeof(struct libfsverity_digest) +
@@ -180,16 +202,9 @@ libfsverity_compute_digest(int fd, desc.version =1 ; desc.hash_algorithm = params->hash_algorithm; -ASSERT (is_power_of_2 (params->block_size)); desc.log_blocksize =ilog2 (params->block_size);if (params->salt_size !=0 ) { -if (params->salt_size >sizeof (desc.salt)) { -error_msg ("Salt too long (got %u bytes; max is %zu bytes)" , - params->salt_size,sizeof (desc.salt)); - retval =EINVAL ; - goto error_out; - }memcpy (desc.salt, params->salt, params->salt_size); desc.salt_size = params->salt_size; }
Signature · 1 line
2.25.3
PATCH v4 8/20 Validate input parameters for libfsverity_sign_digest()
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
Return -EINVAL on any invalid input argument, as well as if any of the reserved fields are set in struct libfsverity_signature_digest
--- libverity.c | 34 ++++++++++++++++++++++++++-------- 1 file changed, 26 insertions(+), 8 deletions(-)
libverity.c +26 -8
@@ -494,18 +494,36 @@ libfsverity_sign_digest(const struct libfsverity_digest *digest,X509 *cert =NULL ;const EVP_MD *md;size_t data_size; -uint16_t alg_nr; -int retval = -EAGAIN ; +uint16_t alg_nr, digest_size; +int i, retval = -EAGAIN ; +const char magic[8 ] ="FSVerity" ; + +if (!digest || !sig_params || !sig_ret || !sig_size_ret) +return -EINVAL ; + +if (strncmp (digest->magic, magic,sizeof (magic))) +return -EINVAL ; + +if (!sig_params->keyfile || !sig_params->certfile) +return -EINVAL ; + +for (i =0 ; i <sizeof (sig_params->reserved) / +sizeof (sig_params->reserved[0 ]); i++) { +if (sig_params->reserved[i]) +return -EINVAL ; + } + + digest_size =le16_to_cpu (digest->digest_size); + data_size =sizeof (struct libfsverity_digest ) + digest_size; - data_size =sizeof (struct libfsverity_digest ) + -le16_to_cpu (digest->digest_size); alg_nr =le16_to_cpu (digest->digest_algorithm); hash_alg =libfsverity_find_hash_alg_by_num (alg_nr); -if (!hash_alg) { - retval = -EINVAL ; - goto out; - } +if (!hash_alg) +return -EINVAL ; + +if (digest_size != hash_alg->digest_size) +return -EINVAL ; pkey =read_private_key (sig_params->keyfile);if (!pkey) {
Signature · 1 line
2.25.3
PATCH v4 9/20 Document API of libfsverity
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
--- libfsverity.h | 45 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+)
libfsverity.h +45 -0
@@ -64,18 +64,63 @@ struct fsverity_hash_alg {struct hash_ctx *(*create_ctx)(const struct fsverity_hash_alg *alg); }; +/* +* libfsverity_compute_digest - Compute digest of a file +* @fd: open file descriptor of file to compute digest for +* @params: struct libfsverity_merkle_tree_params specifying hash algorithm, +* block size, version, and optional salt parameters. +* reserved parameters must be zero. +* @digest_ret: Pointer to pointer for computed digest +* +* Returns: +* * 0 for success, -EINVAL for invalid input arguments, -ENOMEM if failed +* to allocate memory, -EBADF if fd is invalid, and -EAGAIN if root hash +* fails to compute. +* * digest_ret returns a pointer to the digest on success. +*/ int libfsverity_compute_digest (int fd,const struct libfsverity_merkle_tree_params *params,struct libfsverity_digest **digest_ret); +/* +* libfsverity_sign_digest - Sign previously computed digest of a file +* @digest: pointer to previously computed digest +* @sig_params: struct libfsverity_signature_params providing filenames of +* the keyfile and certificate file. Reserved parameters must be zero. +* @sig_ret: Pointer to pointer for signed digest +* @sig_size_ret: Pointer to size of signed return digest +* +* Returns: +* * 0 for success, -EINVAL for invalid input arguments, -EAGAIN if key or +* certificate files fail to read, or if signing the digest fails. +* * sig_ret returns a pointer to the signed digest on success. +* * sig_size_ret returns the size of the signed digest on success. +*/ int 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_find_hash_alg_by_name - Find hash algorithm by name +* @name: Pointer to name of hash algorithm +* +* Returns: +* struct fsverity_hash_alg success +* NULL on error +*/ const struct fsverity_hash_alg *libfsverity_find_hash_alg_by_name (const char *name); + +/* +* libfsverity_find_hash_alg_by_num - Find hash algorithm by number +* @name: Number of hash algorithm +* +* Returns: +* struct fsverity_hash_alg success +* NULL on error +*/ const struct fsverity_hash_alg *libfsverity_find_hash_alg_by_num (unsigned int num);
Signature · 1 line
2.25.3
PATCH v4 10/20 Change libfsverity_compute_digest() to take a read function
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
This changes the library to take a read_fn as callback and a pointer to an opaque file descriptor. This allows us to provide a custome read function for things like rpm which reads from an cpio archive instead of a file on disk.
--- cmd_sign.c | 20 +++++++++++++++++++- libfsverity.h | 3 ++- libverity.c | 39 +++++++-------------------------------- 3 files changed, 28 insertions(+), 34 deletions(-)
cmd_sign.c +19 -1
@@ -12,6 +12,7 @@#include <limits.h> #include <stdlib.h> #include <string.h> +#include <errno.h> #include "commands.h" #include "libfsverity.h"
@@ -45,6 +46,16 @@ static const struct option longopts[] = { {NULL, 0, NULL, 0} }; +static int read_callback (void *opague,void *buf,size_t count) +{ +int retval = -EBADF ; + +if (full_read (opague, buf, count)) + retval =0 ; + +return retval; +} +/* Sign a file for fs-verity by computing its measurement, then signing it. */ int fsverity_cmd_sign (const struct fsverity_command *cmd,int argc,char *argv[])
@@ -59,6 +70,7 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,struct libfsverity_digest *digest =NULL ;struct libfsverity_merkle_tree_params params;struct libfsverity_signature_params sig_params; +u64 file_size;char digest_hex[FS_VERITY_MAX_DIGEST_SIZE *2 +1 ];u8 *sig =NULL ;size_t sig_size;
@@ -131,6 +143,11 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,if (!open_file (&file, argv[0 ],O_RDONLY ,0 )) goto out_err; +if (!get_file_size (&file, &file_size)) { +error_msg_errno ("unable to get file size" ); + goto out_err; + } +memset (¶ms,0 ,sizeof (struct libfsverity_merkle_tree_params )); params.version =1 ; params.hash_algorithm = hash_alg->hash_num;
@@ -138,7 +155,8 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd, params.salt_size = salt_size; params.salt = salt; -if (libfsverity_compute_digest (file.fd, ¶ms, &digest)) +if (libfsverity_compute_digest (&file, file_size, read_callback, + ¶ms, &digest)) goto out_err;filedes_close (&file);
libfsverity.h +2 -1
@@ -79,7 +79,8 @@ struct fsverity_hash_alg {* * digest_ret returns a pointer to the digest on success. */ int -libfsverity_compute_digest (int fd, +libfsverity_compute_digest (void *fd,size_t file_size, +int (*read_fn)(void *,void *buf,size_t count),const struct libfsverity_merkle_tree_params *params,struct libfsverity_digest **digest_ret);
libverity.c +7 -32
@@ -50,30 +50,13 @@ static bool hash_one_block(struct hash_ctx *hash, struct block_buffer *cur,return next->filled + hash->alg->digest_size > block_size; } -static int full_read_fd (int fd,void *buf,size_t count) -{ -while (count) { -int n =read (fd, buf,min (count,INT_MAX )); - -if (n <0 ) { -error_msg_errno ("reading from file" ); -return n; - } -if (n ==0 ) { -error_msg ("unexpected end-of-file" ); -return -ENODATA ; - } - buf += n; - count -= n; - } -return 0 ; -} -/* * Compute the file's Merkle tree root hash using the given hash algorithm, * block size, and salt. */ -static bool compute_root_hash (int fd,u64 file_size, +static bool compute_root_hash (void *fd, +int (*read_fn)(void *,void *buf,size_t count), +u64 file_size,struct hash_ctx *hash,u32 block_size,const u8 *salt,u32 salt_size,u8 *root_hash) {
@@ -111,7 +94,7 @@ static bool compute_root_hash(int fd, u64 file_size,for (offset =0 ; offset < file_size; offset += block_size) { buffers[-1 ].filled =min (block_size, file_size - offset); -if (full_read_fd (fd, buffers[-1 ].data, buffers[-1 ].filled)) +if (read_fn (fd, buffers[-1 ].data, buffers[-1 ].filled)) goto out; level =-1 ;
@@ -145,7 +128,8 @@ out:* contains the Merkle tree properties including the root hash. */ int -libfsverity_compute_digest (int fd, +libfsverity_compute_digest (void *fd,size_t file_size, +int (*read_fn)(void *,void *buf,size_t count),const struct libfsverity_merkle_tree_params *params,struct libfsverity_digest **digest_ret) {
@@ -153,8 +137,6 @@ libfsverity_compute_digest(int fd,struct libfsverity_digest *digest;struct hash_ctx *hash;struct fsverity_descriptor desc; -struct stat stbuf; -u64 file_size;int i, retval = -EINVAL ;if (!digest_ret)
@@ -191,13 +173,6 @@ libfsverity_compute_digest(int fd, digest->digest_size =cpu_to_le16 (hash_alg->digest_size);memset (digest->digest,0 , hash_alg->digest_size); -if (fstat (fd, &stbuf) !=0 ) { -error_msg_errno ("can't stat input file" ); - retval = -EBADF ; - goto error_out; - } - file_size = stbuf.st_size; -memset (&desc,0 ,sizeof (desc)); desc.version =1 ; desc.hash_algorithm = params->hash_algorithm;
@@ -213,7 +188,7 @@ libfsverity_compute_digest(int fd,/* Root hash of empty file is all 0's */ if (file_size !=0 && - !compute_root_hash (fd, file_size, hash, params->block_size, + !compute_root_hash (fd, read_fn, file_size, hash, params->block_size, params->salt, params->salt_size, desc.root_hash)) { retval = -EAGAIN ;
Signature · 1 line
2.25.3
PATCH v4 11/20 Make full_{read,write}() return proper error codes instead of bool
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
This allows for better error reporting, and simplifies the read callback handler.
--- cmd_enable.c | 4 +++- cmd_sign.c | 13 +++++-------- util.c | 14 +++++++------- util.h | 4 ++-- 4 files changed, 17 insertions(+), 18 deletions(-)
cmd_enable.c +3 -1
@@ -56,6 +56,7 @@ static bool read_signature(const char *filename, u8 **sig_ret,u64 file_size;u8 *sig =NULL ;bool ok = false; +int status;if (!open_file (&file, filename,O_RDONLY ,0 )) goto out;
@@ -70,7 +71,8 @@ static bool read_signature(const char *filename, u8 **sig_ret, goto out; } sig =xmalloc (file_size); -if (!full_read (&file, sig, file_size)) + status =full_read (&file, sig, file_size); +if (status <0 ) goto out; *sig_ret = sig; *sig_size_ret = file_size;
cmd_sign.c +5 -8
@@ -13,6 +13,7 @@#include <stdlib.h> #include <string.h> #include <errno.h> +#include <unistd.h> #include "commands.h" #include "libfsverity.h"
@@ -20,12 +21,13 @@static bool write_signature (const char *filename,const u8 *sig,u32 sig_size) {struct filedes file; +int status;bool ok;if (!open_file (&file, filename,O_WRONLY |O_CREAT |O_TRUNC ,0644 ))return false; - ok =full_write (&file, sig, sig_size); - ok &=filedes_close (&file); + status =full_write (&file, sig, sig_size); + ok = (!status &&filedes_close (&file));return ok; }
@@ -48,12 +50,7 @@ static const struct option longopts[] = {static int read_callback (void *opague,void *buf,size_t count) { -int retval = -EBADF ; - -if (full_read (opague, buf, count)) - retval =0 ; - -return retval; +return full_read (opague, buf, count); }/* Sign a file for fs-verity by computing its measurement, then signing it. */
util.c +7 -7
@@ -117,38 +117,38 @@ bool get_file_size(struct filedes *file, u64 *size_ret)return true; } -bool full_read (struct filedes *file,void *buf,size_t count) +int full_read (struct filedes *file,void *buf,size_t count) {while (count) {int n =read (file->fd, buf,min (count,INT_MAX ));if (n <0 ) {error_msg_errno ("reading from '%s'" , file->name); -return false; +return n; }if (n ==0 ) {error_msg ("unexpected end-of-file on '%s'" , file->name); -return false; +return -EBADFD ; } buf += n; count -= n; } -return true; +return 0 ; } -bool full_write (struct filedes *file,const void *buf,size_t count) +int full_write (struct filedes *file,const void *buf,size_t count) {while (count) {int n =write (file->fd, buf,min (count,INT_MAX ));if (n <0 ) {error_msg_errno ("writing to '%s'" , file->name); -return false; +return n; } buf += n; count -= n; } -return true; +return 0 ; }bool filedes_close (struct filedes *file)
util.h +2 -2
@@ -113,8 +113,8 @@ struct filedes {bool open_file (struct filedes *file,const char *filename,int flags,int mode);bool get_file_size (struct filedes *file,u64 *size_ret); -bool full_read (struct filedes *file,void *buf,size_t count); -bool full_write (struct filedes *file,const void *buf,size_t count); +int full_read (struct filedes *file,void *buf,size_t count); +int full_write (struct filedes *file,const void *buf,size_t count);bool filedes_close (struct filedes *file);/* ========== String utilities ========== */
Signature · 1 line
2.25.3
PATCH v4 12/20 libfsverity: Remove dependencies on util.c
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
There were a ton of cross dependencies to util.c. This gets rid of all the use of string function wrappers, u<x> data types, and various debug functions. Useful independent macros and inline functions are moved to helpers.h which may be included by both libfsverity and the fsverity application.
--- fsverity.c | 1 + hash_algs.c | 47 ++++++++++----- hash_algs.h | 9 ++- helpers.h | 43 ++++++++++++++ libverity.c | 165 ++++++++++++++++++++++++++++++++-------------------- util.c | 1 + util.h | 56 ------------------ 7 files changed, 184 insertions(+), 138 deletions(-) create mode 100644 helpers.h
fsverity.c +1 -0
@@ -13,6 +13,7 @@#include <unistd.h> #include "commands.h" +#include "helpers.h" #include "libfsverity.h" static const struct fsverity_command {
hash_algs.c +33 -14
93 lines not on this page · raw message
hash_algs.h +4 -5
@@ -4,13 +4,11 @@#include <stdio.h> -#include "util.h" -struct hash_ctx {const struct fsverity_hash_alg *alg;void (*init)(struct hash_ctx *ctx);void (*update)(struct hash_ctx *ctx,const void *data,size_t size); -void (*final)(struct hash_ctx *ctx,u8 *out); +void (*final)(struct hash_ctx *ctx,uint8_t *out);void (*free)(struct hash_ctx *ctx); };
@@ -25,7 +23,7 @@ static inline void hash_update(struct hash_ctx *ctx, ctx->update (ctx, data, size); } -static inline void hash_final (struct hash_ctx *ctx,u8 *digest) +static inline void hash_final (struct hash_ctx *ctx,uint8_t *digest) { ctx->final (ctx, digest); }
@@ -36,6 +34,7 @@ static inline void hash_free(struct hash_ctx *ctx) ctx->free(ctx); } -void hash_full (struct hash_ctx *ctx,const void *data,size_t size,u8 *digest); +void hash_full (struct hash_ctx *ctx,const void *data,size_t size, +uint8_t *digest);#endif /* HASH_ALGS_H */
helpers.h new file +43 -0
43 lines not on this page · raw message
libverity.c +102 -63
340 lines not on this page · raw message
util.c +1 -0
@@ -18,6 +18,7 @@#include <unistd.h> #include "util.h" +#include "helpers.h" /* ========== Memory allocation ========== */
util.h +0 -56
68 lines not on this page · raw message
Signature · 1 line
2.25.3
PATCH v4 13/20 Update Makefile to install libfsverity and fsverity.h
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
In addition this adds a 'static' build target, which links in libfsverity statically rather than relying on the shared library.
This also honors PREFIX for installation location.
--- Makefile | 34 ++++++++++++++++++++++++++-------- 1 file changed, 26 insertions(+), 8 deletions(-)
Makefile +26 -8
@@ -1,34 +1,52 @@ EXE := fsverity +STATIC := fsverity-static LIB := libfsverity.so +INC := libfsverity.h CFLAGS := -O2 -Wall CPPFLAGS := -D_FILE_OFFSET_BITS=64 LDLIBS := -lcrypto -DESTDIR := /usr/local -LIBDIR := /usr/lib64 +PREFIX = /usr +BINDIR := $(PREFIX)/bin +LIBDIR := $(PREFIX)/lib64 +INCDIR := $(PREFIX)/include SRC := $(wildcard *.c) OBJ := fsverity.o cmd_enable.o cmd_measure.o cmd_sign.o util.o SSRC := libverity.c hash_algs.c -SOBJ := libverity.so hash_algs.so +SHOBJ := libverity.so hash_algs.so +STOBJ := libverity.o hash_algs.o HDRS := $(wildcard *.h) all:$(EXE) +static:$(STATIC) + $(EXE):$(OBJ) $(LIB) $(CC) -o $@ $(OBJ) $(LDLIBS) -L . -l fsverity +$(STATIC):$(OBJ) $(STOBJ) + $(CC) -o $@ $(OBJ) $(STOBJ) $(LDLIBS) + $(OBJ): %.o: %.c $(HDRS) $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@ -$(SOBJ): %.so: %.c $(HDRS) +$(STOBJ): %.o: %.c $(HDRS) + $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@ + +$(SHOBJ): %.so: %.c $(HDRS) $(CC) -c -fPIC $(CFLAGS) $(CPPFLAGS) $< -o $@ -libfsverity.so: $(SOBJ) - $(CC) $(LDLIBS) -shared -o libfsverity.so $(SOBJ) +libfsverity.so: $(SHOBJ) + $(CC) $(LDLIBS) -shared -o $@ $(SHOBJ) clean: - rm -f $(EXE) $(OBJ) $(SOBJ) $(LIB) + rm -f $(EXE) $(OBJ) $(SHOBJ) $(LIB) $(STOBJ) $(STATIC) install:all - install -Dm755 -t $(DESTDIR)/bin $(EXE) + install -Dm755 -t $(BINDIR) $(EXE) + install -Dm755 -t $(LIBDIR) $(LIB) + install -Dm644 -t $(INCDIR) $(INC) + +install-static:static + install -Dm755 -t $(BINDIR) $(STATIC) .PHONY: all clean install
Signature · 1 line
2.25.3
PATCH v4 14/20 Change libfsverity_find_hash_alg_by_name() to return the alg number
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
This elimnates the need for struct fsverity_hash_alg in the use case of libfsverity_find_hash_alg_by_name(). In addition this introduces a libfsverity_digest_size() which returns the size of the digest for the given algorithm, and libfsverity_hash_name() which returns a string with the name of the algorithm. Note the returned string must be freed by the caller.
--- cmd_enable.c | 6 +++--- cmd_sign.c | 25 +++++++++++++++---------- hash_algs.c | 35 ++++++++++++++++++++++++++++++----- libfsverity.h | 28 +++++++++++++++++++++++----- 4 files changed, 71 insertions(+), 23 deletions(-)
cmd_enable.c +3 -3
@@ -22,7 +22,7 @@ static bool parse_hash_alg_option(const char *arg, u32 *alg_ptr) {char *end;unsigned long n =strtoul (arg, &end,10 ); -const struct fsverity_hash_alg *alg; +uint16_t alg;if (*alg_ptr !=0 ) {error_msg ("--hash-alg can only be specified once" );
@@ -37,8 +37,8 @@ static bool parse_hash_alg_option(const char *arg, u32 *alg_ptr)/* Specified by name? */ alg =libfsverity_find_hash_alg_by_name (arg); -if (alg !=NULL ) { - *alg_ptr = alg->hash_num; +if (alg) { + *alg_ptr = alg;return true; }error_msg ("unknown hash algorithm: '%s'" , arg);
cmd_sign.c +15 -10
@@ -57,7 +57,6 @@ static int read_callback(void *opague, void *buf, size_t count)int fsverity_cmd_sign (const struct fsverity_command *cmd,int argc,char *argv[]) { -const struct fsverity_hash_alg *hash_alg =NULL ;struct filedes file = { .fd =-1 };u32 block_size =0 ;u8 *salt =NULL ;
@@ -69,7 +68,10 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,struct libfsverity_signature_params sig_params;u64 file_size;char digest_hex[FS_VERITY_MAX_DIGEST_SIZE *2 +1 ]; +char *hash_name =NULL ;u8 *sig =NULL ; +u16 alg_nr =0 ; +int digest_size;size_t sig_size;int status;int c;
@@ -77,12 +79,12 @@ 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 (hash_alg !=NULL ) { +if (alg_nr) {error_msg ("--hash-alg can only be specified once" ); goto out_usage; } - hash_alg =libfsverity_find_hash_alg_by_name (optarg); -if (hash_alg ==NULL ) { + alg_nr =libfsverity_find_hash_alg_by_name (optarg); +if (!alg_nr) {error_msg ("unknown hash algorithm: '%s'" , optarg);fputs ("Available hash algorithms: " , stderr);
@@ -124,8 +126,8 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,if (argc !=2 ) goto out_usage; -if (hash_alg ==NULL ) - hash_alg =libfsverity_find_hash_alg_by_num (FS_VERITY_HASH_ALG_DEFAULT ); +if (!alg_nr) + alg_nr =FS_VERITY_HASH_ALG_DEFAULT ;if (block_size ==0 ) block_size =get_default_block_size ();
@@ -147,7 +149,7 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,memset (¶ms,0 ,sizeof (struct libfsverity_merkle_tree_params )); params.version =1 ; - params.hash_algorithm = hash_alg->hash_num; + params.hash_algorithm = alg_nr; params.block_size = block_size; params.salt_size = salt_size; params.salt = salt;
@@ -158,6 +160,8 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,filedes_close (&file); + digest_size =libfsverity_digest_size (alg_nr); +memset (&sig_params,0 ,sizeof (struct libfsverity_signature_params )); sig_params.keyfile = keyfile; sig_params.certfile = certfile;
@@ -169,9 +173,10 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,if (!write_signature (argv[1 ], sig, sig_size)) goto out_err; -bin2hex (digest->digest, hash_alg->digest_size, digest_hex); -printf ("Signed file '%s' (%s:%s)\n" , argv[0 ], hash_alg->name, - digest_hex); + hash_name =libfsverity_hash_name (alg_nr); +bin2hex (digest->digest, digest_size, digest_hex); +printf ("Signed file '%s' (%s:%s)\n" , argv[0 ], hash_name, digest_hex); +free (hash_name); status =0 ; out:free (salt);
hash_algs.c +30 -5
@@ -137,17 +137,17 @@ const struct fsverity_hash_alg fsverity_hash_algs[] = { }, }; -const struct fsverity_hash_alg * -libfsverity_find_hash_alg_by_name (const char *name) +uint16_t libfsverity_find_hash_alg_by_name (const char *name) {int i;for (i =0 ; i <ARRAY_SIZE (fsverity_hash_algs); i++) {if (fsverity_hash_algs[i].name && - !strcmp (name, fsverity_hash_algs[i].name)) -return &fsverity_hash_algs[i]; + !strcmp (name, fsverity_hash_algs[i].name)) { +return fsverity_hash_algs[i].hash_num; + } } -return NULL ; +return 0 ; } const struct fsverity_hash_alg *
@@ -160,6 +160,31 @@ libfsverity_find_hash_alg_by_num(unsigned int num)return NULL ; } +int libfsverity_digest_size (uint16_t alg_nr) +{ +if (alg_nr <ARRAY_SIZE (fsverity_hash_algs) && + fsverity_hash_algs[alg_nr].name) +return fsverity_hash_algs[alg_nr].digest_size; + +return -1 ; +} + +char *libfsverity_hash_name (uint16_t alg_nr) +{ +int namelen; +char *hash_name =NULL ; + +if (alg_nr <ARRAY_SIZE (fsverity_hash_algs) && + fsverity_hash_algs[alg_nr].name) { + namelen =strlen (fsverity_hash_algs[alg_nr].name); + hash_name =malloc (namelen +1 ); +if (hash_name) +strcpy (hash_name, fsverity_hash_algs[alg_nr].name); + } + +return hash_name; +} +/* ->init(), ->update(), and ->final() all in one step */ void hash_full (struct hash_ctx *ctx,const void *data,size_t size,uint8_t *digest)
libfsverity.h +23 -5
@@ -58,7 +58,7 @@ struct libfsverity_signature_params {struct fsverity_hash_alg {const char *name; -unsigned int digest_size; +int digest_size;unsigned int block_size;uint16_t hash_num;struct hash_ctx *(*create_ctx)(const struct fsverity_hash_alg *alg);
@@ -108,11 +108,9 @@ libfsverity_sign_digest(const struct libfsverity_digest *digest,* @name: Pointer to name of hash algorithm * * Returns: -* struct fsverity_hash_alg success -* NULL on error +* uint16_t containing hash algorithm number, zero on error. */ -const struct fsverity_hash_alg * -libfsverity_find_hash_alg_by_name (const char *name); +uint16_t libfsverity_find_hash_alg_by_name (const char *name);/* * libfsverity_find_hash_alg_by_num - Find hash algorithm by number
@@ -125,4 +123,24 @@ libfsverity_find_hash_alg_by_name(const char *name);const struct fsverity_hash_alg *libfsverity_find_hash_alg_by_num (unsigned int num); +/* +* libfsverity_digest_size - Return size of digest for a given algorithm +* @alg_nr: Valid hash algorithm number +* +* Returns: +* int containing size of digest, -1 on error. +*/ +int libfsverity_digest_size (uint16_t alg_nr); + +/* +* libfsverity_find_hash_name - Find name of hash algorithm by number +* @name: Number of hash algorithm +* +* Returns: +* New allocated string containing name of algorithm. +* String must be freed by caller. +* NULL on error +*/ +char *libfsverity_hash_name (uint16_t num); +#endif
Signature · 1 line
2.25.3
PATCH v4 15/20 Make libfsverity_find_hash_alg_by_name() private to the shared library
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
This moves struct fsverity_hash_alg out of the public API. Instead implement show_all_hash_algs() by calling libfsverity_hash_name() until it returns null.
--- cmd_enable.c | 2 +- cmd_measure.c | 17 ++++++++--------- cmd_sign.c | 2 +- fsverity.c | 16 +++++++--------- hash_algs.c | 1 + libfsverity.h | 19 ------------------- libfsverity_private.h | 19 +++++++++++++++++++ 7 files changed, 37 insertions(+), 39 deletions(-)
cmd_enable.c +1 -1
@@ -42,7 +42,7 @@ static bool parse_hash_alg_option(const char *arg, u32 *alg_ptr)return true; }error_msg ("unknown hash algorithm: '%s'" , arg); -fputs ("Available hash algorithms: " , stderr); +fputs ("Available hash algorithms:" , stderr);show_all_hash_algs (stderr);putc ('\n' , stderr);
cmd_measure.c +8 -9
@@ -22,9 +22,8 @@ int fsverity_cmd_measure(const struct fsverity_command *cmd,struct fsverity_digest *d =NULL ;struct filedes file;char digest_hex[FS_VERITY_MAX_DIGEST_SIZE *2 +1 ]; -const struct fsverity_hash_alg *hash_alg;char _hash_alg_name[32 ]; -const char *hash_alg_name; +char *hash_alg_name;int status;int i;
@@ -48,14 +47,14 @@ int fsverity_cmd_measure(const struct fsverity_command *cmd,ASSERT (d->digest_size <=FS_VERITY_MAX_DIGEST_SIZE );bin2hex (d->digest, d->digest_size, digest_hex); - hash_alg =libfsverity_find_hash_alg_by_num (d->digest_algorithm); -if (hash_alg) { - hash_alg_name = hash_alg->name; - }else { + hash_alg_name =libfsverity_hash_name (d->digest_algorithm); +if (!hash_alg_name)sprintf (_hash_alg_name,"ALG_%u" , d->digest_algorithm); - hash_alg_name = _hash_alg_name; - } -printf ("%s:%s %s\n" , hash_alg_name, digest_hex, argv[i]); + +printf ("%s:%s %s\n" , + hash_alg_name ? hash_alg_name :_hash_alg_name, + digest_hex, argv[i]); +free (hash_alg_name); } status =0 ; out:
cmd_sign.c +1 -1
@@ -87,7 +87,7 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,if (!alg_nr) {error_msg ("unknown hash algorithm: '%s'" , optarg); -fputs ("Available hash algorithms: " , stderr); +fputs ("Available hash algorithms:" , stderr);show_all_hash_algs (stderr);putc ('\n' , stderr); goto out_usage;
fsverity.c +7 -9
@@ -51,14 +51,12 @@ static const struct fsverity_command {void show_all_hash_algs (FILE *fp) {int i =1 ; -const char *sep ="" ; -const struct fsverity_hash_alg *alg; - -while ((alg =libfsverity_find_hash_alg_by_num (i++))) { -if (alg && alg->name) { -fprintf (fp,"%s%s" , sep, alg->name); - sep =", " ; - } +const char *sep =" " ; +char *alg; + +while ((alg =libfsverity_hash_name (i++))) { +fprintf (fp,"%s%s" , sep, alg); +free (alg); } }
@@ -75,7 +73,7 @@ static void usage_all(FILE *fp)" fsverity --help\n" " fsverity --version\n" "\n" -"Available hash algorithms: ", fp); +"Available hash algorithms:", fp);show_all_hash_algs (fp);putc ('\n' , fp); }
hash_algs.c +1 -0
@@ -15,6 +15,7 @@#include "helpers.h" #include "fsverity_uapi.h" #include "libfsverity.h" +#include "libfsverity_private.h" #include "hash_algs.h" /* ========== libcrypto (OpenSSL) wrappers ========== */
libfsverity.h +0 -19
@@ -56,14 +56,6 @@ struct libfsverity_signature_params {uint64_t reserved[11 ]; }; -struct fsverity_hash_alg { -const char *name; -int digest_size; -unsigned int block_size; -uint16_t hash_num; -struct hash_ctx *(*create_ctx)(const struct fsverity_hash_alg *alg); -}; -/* * libfsverity_compute_digest - Compute digest of a file * @fd: open file descriptor of file to compute digest for
@@ -112,17 +104,6 @@ libfsverity_sign_digest(const struct libfsverity_digest *digest,*/ uint16_t libfsverity_find_hash_alg_by_name (const char *name); -/* -* libfsverity_find_hash_alg_by_num - Find hash algorithm by number -* @name: Number of hash algorithm -* -* Returns: -* struct fsverity_hash_alg success -* NULL on error -*/ -const struct fsverity_hash_alg * -libfsverity_find_hash_alg_by_num (unsigned int num); -/* * libfsverity_digest_size - Return size of digest for a given algorithm * @alg_nr: Valid hash algorithm number
libfsverity_private.h +19 -0
@@ -30,4 +30,23 @@ struct fsverity_descriptor { uint8_t signature[]; /* optional PKCS#7 signature */ }; +struct fsverity_hash_alg { +const char *name; +int digest_size; +unsigned int block_size; +uint16_t hash_num; +struct hash_ctx *(*create_ctx)(const struct fsverity_hash_alg *alg); +}; + +/* +* libfsverity_find_hash_alg_by_num - Find hash algorithm by number +* @name: Number of hash algorithm +* +* Returns: +* struct fsverity_hash_alg success +* NULL on error +*/ +const struct fsverity_hash_alg * +libfsverity_find_hash_alg_by_num (unsigned int num); +#endif
Signature · 1 line
2.25.3
PATCH v4 16/20 libfsverity_sign_digest() use ARRAY_SIZE()
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
--- libverity.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
libverity.c +1 -2
@@ -521,8 +521,7 @@ libfsverity_sign_digest(const struct libfsverity_digest *digest,if (!sig_params->keyfile || !sig_params->certfile)return -EINVAL ; -for (i =0 ; i <sizeof (sig_params->reserved) / -sizeof (sig_params->reserved[0 ]); i++) { +for (i =0 ; i <ARRAY_SIZE (sig_params->reserved); i++) {if (sig_params->reserved[i])return -EINVAL ; }
Signature · 1 line
2.25.3
PATCH v4 17/20 fsverity_cmd_sign() use sizeof() input argument instead of struct
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
--- cmd_sign.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
cmd_sign.c +2 -2
@@ -147,7 +147,7 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd, goto out_err; } -memset (¶ms,0 ,sizeof (struct libfsverity_merkle_tree_params )); +memset (¶ms,0 ,sizeof (params)); params.version =1 ; params.hash_algorithm = alg_nr; params.block_size = block_size;
@@ -162,7 +162,7 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd, digest_size =libfsverity_digest_size (alg_nr); -memset (&sig_params,0 ,sizeof (struct libfsverity_signature_params )); +memset (&sig_params,0 ,sizeof (sig_params)); sig_params.keyfile = keyfile; sig_params.certfile = certfile;if (libfsverity_sign_digest (digest, &sig_params, &sig, &sig_size)) {
Signature · 1 line
2.25.3
PATCH v4 18/20 fsverity_cmd_sign() don't exit on error without closing file descriptor
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
--- cmd_sign.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)
cmd_sign.c +6 -5
@@ -73,7 +73,7 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd,u16 alg_nr =0 ;int digest_size;size_t sig_size; -int status; +int status, ret;int c;while ((c =getopt_long (argc, argv,"" , longopts,NULL )) !=-1 ) {
@@ -154,12 +154,13 @@ int fsverity_cmd_sign(const struct fsverity_command *cmd, params.salt_size = salt_size; params.salt = salt; -if (libfsverity_compute_digest (&file, file_size, read_callback, - ¶ms, &digest)) - goto out_err; - + ret =libfsverity_compute_digest (&file, file_size, read_callback, + ¶ms, &digest);filedes_close (&file); +if (ret) + goto out_err; + digest_size =libfsverity_digest_size (alg_nr);memset (&sig_params,0 ,sizeof (sig_params));
Signature · 1 line
2.25.3
PATCH v4 19/20 Improve documentation of libfsverity.h API
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
--- libfsverity.h | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-)
libfsverity.h +19 -8
@@ -58,17 +58,21 @@ struct libfsverity_signature_params {/* * libfsverity_compute_digest - Compute digest of a file +* An fsverity digest is the root of the Merkle tree of the file. +* Not to be confused with a traditional file digests computed over +* the entire file. * @fd: open file descriptor of file to compute digest for * @params: struct libfsverity_merkle_tree_params specifying hash algorithm, * block size, version, and optional salt parameters. * reserved parameters must be zero. -* @digest_ret: Pointer to pointer for computed digest +* @digest_ret: Pointer to pointer for computed digest. * * Returns: * * 0 for success, -EINVAL for invalid input arguments, -ENOMEM if failed * to allocate memory, -EBADF if fd is invalid, and -EAGAIN if root hash * fails to compute. -* * digest_ret returns a pointer to the digest on success. +* * digest_ret returns a pointer to the digest on success. The digest object +* is allocated by libfsverity and must be freed by the caller. */ int libfsverity_compute_digest(void *fd, size_t file_size,
@@ -78,6 +82,12 @@ libfsverity_compute_digest(void *fd, size_t file_size,/* * libfsverity_sign_digest - Sign previously computed digest of a file +* This is signature is used by the file system to validate the +* signed file measurement against a public key loaded into the +* .fs-verity kernel keyring, when CONFIG_FS_VERITY_BUILTIN_SIGNATURES +* is enabled. The signature is formatted as PKCS#7 stored in DER +* format. See Documentation/filesystems/fsverity.rst for further +* details. * @digest: pointer to previously computed digest * @sig_params: struct libfsverity_signature_params providing filenames of * the keyfile and certificate file. Reserved parameters must be zero.
@@ -87,7 +97,8 @@ libfsverity_compute_digest(void *fd, size_t file_size,* Returns: * * 0 for success, -EINVAL for invalid input arguments, -EAGAIN if key or * certificate files fail to read, or if signing the digest fails. -* * sig_ret returns a pointer to the signed digest on success. +* * sig_ret returns a pointer to the signed digest on success. This object +* is allocated by libfsverity_sign_digest and must be freed by the caller. * * sig_size_ret returns the size of the signed digest on success. */ int
@@ -100,7 +111,7 @@ libfsverity_sign_digest(const struct libfsverity_digest *digest,* @name: Pointer to name of hash algorithm * * Returns: -* uint16_t containing hash algorithm number, zero on error. +* uint16_t containing hash algorithm number, zero if not found. */ uint16_t libfsverity_find_hash_alg_by_name (const char *name);
@@ -109,7 +120,7 @@ uint16_t libfsverity_find_hash_alg_by_name(const char *name);* @alg_nr: Valid hash algorithm number * * Returns: -* int containing size of digest, -1 on error. +* int containing size of digest, -1 if algorithm is not known. */ int libfsverity_digest_size (uint16_t alg_nr);
@@ -118,9 +129,9 @@ int libfsverity_digest_size(uint16_t alg_nr);* @name: Number of hash algorithm * * Returns: -* New allocated string containing name of algorithm. -* String must be freed by caller. -* NULL on error +* New allocated string containing name of algorithm. +* The string must be freed by caller. +* NULL if algorithm is not known. */ char *libfsverity_hash_name (uint16_t num);
Signature · 1 line
2.25.3
PATCH v4 20/20 Fixup Makefile
In reply to Jes SorensenFrom: Jes Sorensen <[email protected]>
Set soname for libfsverity, install shared library and header file, and make clean handle shared library too.
--- Makefile | 25 +++++++++++++++++-------- 1 file changed, 17 insertions(+), 8 deletions(-)
Makefile +17 -8
@@ -1,6 +1,5 @@ EXE := fsverity STATIC := fsverity-static -LIB := libfsverity.so INC := libfsverity.h CFLAGS := -O2 -Wall CPPFLAGS := -D_FILE_OFFSET_BITS=64
@@ -15,12 +14,17 @@ SSRC := libverity.c hash_algs.c SHOBJ := libverity.so hash_algs.so STOBJ := libverity.o hash_algs.o HDRS := $(wildcard *.h) +LIB_MAJOR := 1 +LIB_MINOR := 0.0 +LIB_SO := libfsverity.so +LIB_SONAME := $(LIB_SO).$(LIB_MAJOR) +LIB_FULL := $(LIB_SONAME).$(LIB_MINOR) all:$(EXE) static:$(STATIC) -$(EXE):$(OBJ) $(LIB) +$(EXE):$(OBJ) $(LIB_FULL) $(CC) -o $@ $(OBJ) $(LDLIBS) -L . -l fsverity $(STATIC):$(OBJ) $(STOBJ)
@@ -35,16 +39,21 @@ $(STOBJ): %.o: %.c $(HDRS) $(SHOBJ): %.so: %.c $(HDRS) $(CC) -c -fPIC $(CFLAGS) $(CPPFLAGS) $< -o $@ -libfsverity.so: $(SHOBJ) - $(CC) $(LDLIBS) -shared -o $@ $(SHOBJ) +$(LIB_FULL): $(SHOBJ) + $(CC) $(LDLIBS) -shared -Wl,-soname,$(LIB_SONAME) -o $@ $(SHOBJ) + rm -f $(LIB_SONAME) $(LIB_SO) + ln -s $(LIB_FULL) $(LIB_SONAME) + ln -s $(LIB_SONAME) $(LIB_SO) clean: - rm -f $(EXE) $(OBJ) $(SHOBJ) $(LIB) $(STOBJ) $(STATIC) + rm -f $(EXE) $(OBJ) $(SHOBJ) $(LIB_SONAME) $(LIB_SO) $(LIB_FULL) $(STOBJ) $(STATIC) install:all - install -Dm755 -t $(BINDIR) $(EXE) - install -Dm755 -t $(LIBDIR) $(LIB) - install -Dm644 -t $(INCDIR) $(INC) + install -Dm755 -t $(DESTDIR)$(BINDIR) $(EXE) + install -Dm755 -t $(DESTDIR)$(LIBDIR) $(LIB_FULL) + ln -s $(LIB_FULL) $(DESTDIR)$(LIBDIR)/$(LIB_SONAME) + ln -s $(LIB_SONAME) $(DESTDIR)$(LIBDIR)/$(LIB_SO) + install -Dm644 -t $(DESTDIR)$(INCDIR) $(INC) install-static:static install -Dm755 -t $(BINDIR) $(STATIC)
Signature · 1 line
2.25.3
Quoted 6 lines · Jes Sorensen
From: Jes Sorensen <[email protected]>
Hi
This is an update to the libfsverity patches I posted about a month ago, which I believe address all the issues in the feedback I received.
Hi Eric,
Wanted to check in and hear if you had a chance to look at this?
Thanks,
Jes
Quoted 74 lines
I have a version of rpm that requires this library which is able to sign files and a plugin which will install fsverity signatures when the rpm is installed. The code for rpm can be found on github - note that I do rebase the repo as I fix bugs:
https://github.com/jessorensen/rpm/tree/rpm-fsverityA git tree with these patches can also be found here:
https://git.kernel.org/pub/scm/linux/kernel/git/jes/fsverity-utils.gitThis update changes a number of issues:
- Change the API forlibfsverity_compute_digest()to take a callback read function, which is needed to deal with the internal cpio processing of rpm.
- Provides the option to build fsverity linked statically against libfsverity
-Makefilesupport to install libfsverity.so,libfsverity.hand sets the soname
- Make structfsverity_descriptorand structfsverity_hash_alginternal to the library
- Improved documentation of the API inlibfsverity.hI have a .spec file for it that packages this into an rpm for Fedora, as well as a packaged version of rpm with fsverity support in it, which I am happy to share.
Let me know what you think!
Thanks,
JesJes Sorensen (20):
Build basic shared library framework
Changecompute_file_measurement()to take a file descriptor as
argument
Movefsverity_descriptordefinition tolibfsverity.h
Move hash algorithm code to shared library
Createlibfsverity_compute_digest()and adaptcmd_signto use it Introducelibfsverity_sign_digest()
Validate input arguments tolibfsverity_compute_digest()Validate input parameters forlibfsverity_sign_digest()Document API of libfsverity
Changelibfsverity_compute_digest()to take a read function Make full_{read,write}() return proper error codes instead of bool
libfsverity: Remove dependencies onutil.c
UpdateMakefileto install libfsverity andfsverity.hChangelibfsverity_find_hash_alg_by_name()to return the alg number Makelibfsverity_find_hash_alg_by_name()private to the shared librarylibfsverity_sign_digest()useARRAY_SIZE()fsverity_cmd_sign()usesizeof()input argument instead of structfsverity_cmd_sign()don't exit on error without closing file
descriptor
Improve documentation oflibfsverity.hAPI
FixupMakefileMakefile | 49 +++- cmd_enable.c | 19 +- cmd_measure.c | 19 +- cmd_sign.c | 565 +++++------------------------------------ fsverity.c | 17 +- hash_algs.c | 95 ++++--- hash_algs.h | 36 +-- helpers.h | 43 ++++ libfsverity.h | 138 ++++++++++ libfsverity_private.h | 52 ++++ libverity.c | 572 ++++++++++++++++++++++++++++++++++++++++++ util.c | 15 +- util.h | 62 +---- 13 files changed, 1029 insertions(+), 653 deletions(-) create mode 100644 helpers.h create mode 100644 libfsverity.h create mode 100644 libfsverity_private.h create mode 100644 libverity.c
Eric Biggers
maintainerQuoted 8 lines · Jes Sorensen
Quoted 6 lines · Jes Sorensen
From: Jes Sorensen <[email protected]>
Hi
This is an update to the libfsverity patches I posted about a month ago, which I believe address all the issues in the feedback I received.
Quoted 7 lines
Hi Eric,
Wanted to check in and hear if you had a chance to look at this?
Thanks,
Jes
No, it's on my list of things to review though.
- Eric