Split fsverity-utils into a shared library
Subsystems (2)
v3 cover Split fsverity-utils into a shared library
From: Jes Sorensen <[email protected]>
Hi,
This is an updated version of my patches to split fsverity-utils into a shared library. This version addresses most of the comments I received in the last version:
1) Document the API
2) Verified ran xfstest against the build
3) Make struct fsverity_descriptor private
4) Reviewed (and documented) error codes
5) Improved validation of input parameters, and return error if any reserved field is not zero.
I left struct fsverity_hash_alg in the public API, because it adds useful information to the user, in particular providing the digest size, and allows the caller to walk the list to obtain the supported algorithms. The alternative is to introduce a libverity_get_digest_size() call.
I still need to add some self-tests to the build and deal with the soname stuff.
Next up is rpm support.
Cheers,
Jes
Jes Sorensen (9):
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
Makefile | 18 +- cmd_enable.c | 11 +- cmd_measure.c | 4 +- cmd_sign.c | 526 +++------------------------------------ fsverity.c | 16 +- hash_algs.c | 26 +- hash_algs.h | 27 -- libfsverity.h | 127 ++++++++++ libfsverity_private.h | 33 +++ libverity.c | 559 ++++++++++++++++++++++++++++++++++++++++++ util.h | 2 + 11 files changed, 801 insertions(+), 548 deletions(-) create mode 100644 libfsverity.h create mode 100644 libfsverity_private.h create mode 100644 libverity.c
Signature · 1 line
2.24.1
PATCH v3 1/9 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.24.1
Eric Biggers
maintainerRe: [PATCH 1/9] Build basic shared library framework
Quoted 57 lines · Jes Sorensen
From: Jes Sorensen <[email protected]>
This introduces a dummy shared library to start moving things into.
Signed-off-by Jes Sorensen <[email protected]>--- Makefile | 18 +++++++++++++++--- libverity.c | 10 ++++++++++ 2 files changed, 25 insertions(+), 3 deletions(-) create mode 100644 libverity.cMakefile +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 +0
-0
libverity.c line 10
Quoted 10 lines
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. +*/ +
Could you preserve the option to build the 'fsverity' program as a statically linked binary? Having to deal with installing libfsverity.so in some environments can be annoying.
We maybe should use proper build system that would handle things like this -- though, for small projects like this it's nice to just have a simple Makefile. What I've done in another project that uses just a Makefile is support building both a static library a shared library, where the static library is created from .o files and the shared library is built from .shlib.o files. Then the binaries can be linked to either one based on a 'make' variable.
- Eric
Eric Biggers
maintainerRe: [PATCH 1/9] Build basic shared library framework
In reply to Jes SorensenQuoted 16 lines · Jes Sorensen
From: Jes Sorensen <[email protected]>
This introduces a dummy shared library to start moving things into.
Signed-off-by Jes Sorensen <[email protected]>--- Makefile | 18 +++++++++++++++--- libverity.c | 10 ++++++++++ 2 files changed, 25 insertions(+), 3 deletions(-) create mode 100644 libverity.cMakefile +0
-0
Makefile line 7
Quoted 7 lines
Makefile +2
-0@@ -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
LIBDIR isn't used at all. I assume you meant for it to be location where the library gets installed? The proper way to handle installation locations (assuming we stay with a plain Makefile and not move to another build system) would be:
PREFIX ?= /usr/local
BINDIR ?= $(PREFIX)/bin
INCDIR ?= $(PREFIX)/include
LIBDIR ?= $(PREFIX)/lib
then install binaries into $(DESTDIR)$(BINDIR), headers into $(DESTDIR)$(INCDIR), and libraries into $(DESTDIR)$(LIBDIR). This matches the conventions for autoconf.
- Eric
Re: [PATCH 1/9] Build basic shared library framework
Quoted 30 lines · Eric Biggers
Quoted 16 lines · Jes Sorensen
From: Jes Sorensen <[email protected]>
This introduces a dummy shared library to start moving things into.
Signed-off-by Jes Sorensen <[email protected]>--- Makefile | 18 +++++++++++++++--- libverity.c | 10 ++++++++++ 2 files changed, 25 insertions(+), 3 deletions(-) create mode 100644 libverity.cMakefile +0
-0Makefile line 7
Quoted 7 lines
Makefile +2
-0@@ -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/lib64LIBDIR isn't used at all. I assume you meant for it to be location where the library gets installed? The proper way to handle installation locations (assuming we stay with a plain
Makefileand not move to another build system) would be:
Quoted 8 lines
PREFIX ?=
/usr/local
BINDIR ?= $(PREFIX)/bin
INCDIR ?= $(PREFIX)/include
LIBDIR ?= $(PREFIX)/libthen install binaries into $(DESTDIR)$(BINDIR), headers into $(DESTDIR)$(INCDIR), and libraries into $(DESTDIR)$(LIBDIR). This matches the conventions for autoconf.
I pushed a change to git which addresses this, I still need to address the soname though.
Long term it might be nice to switch to autoconf/automake, at the same time I love dealing with it about as much as going to the dentist for a root canal.
Cheers,
Jes
PATCH v3 2/9 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.24.1
PATCH v3 3/9 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.24.1
Eric Biggers
maintainerRe: [PATCH 3/9] Move fsverity_descriptor definition to libfsverity.h
Quoted 79 lines · Jes Sorensen
From: Jes Sorensen <[email protected]>
Signed-off-by 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 +10
-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 */
libfsverity.h struct libfsverity_signature_params { · line 59
Quoted 10 lines
libfsverity.h +10
-0+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 */ +}; +
I thought there was no need for this to be part of the library API?
- Eric
Re: [PATCH 3/9] Move fsverity_descriptor definition to libfsverity.h
Quoted 84 lines · Eric Biggers
Quoted 83 lines · Jes Sorensen
From: Jes Sorensen <[email protected]>
Signed-off-by 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 +14
-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 */
Quoted 8 lines
libfsverity.h struct libfsverity_signature_params { · line 59
Quoted 6 lines
libfsverity.h +6
-0+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 */ +}; +I thought there was no need for this to be part of the library API?
Hi Eric,
Been busy working on RPM support, but looking at this again now. Given that the fsverity signature is a hash of the descriptor, I don't see how we can avoid this?
Cheers,
Jes
Eric Biggers
maintainerRe: [PATCH 3/9] Move fsverity_descriptor definition to libfsverity.h
Quoted 94 lines · Jes Sorensen
Quoted 84 lines · Eric Biggers
Quoted 83 lines · Jes Sorensen
From: Jes Sorensen <[email protected]>
Signed-off-by 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 +14
-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 */ Quoted 8 lines
libfsverity.h struct libfsverity_signature_params { · line 59
Quoted 6 lines
libfsverity.h +6
-0+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 */ +}; +I thought there was no need for this to be part of the library API?
Quoted 6 lines
Hi Eric,
Been busy working on RPM support, but looking at this again now. Given that the fsverity signature is a hash of the descriptor, I don't see how we can avoid this?
struct fsverity_descriptor isn't signed directly; it's hashed as an intermediate step in libfsverity_compute_digest(). So why would the library user need the definition of 'struct fsverity_descriptor'?
- Eric
Re: [PATCH 3/9] Move fsverity_descriptor definition to libfsverity.h
Quoted 6 lines · Eric Biggers
Quoted 5 lines · Jes Sorensen
Quoted 1 line · Eric Biggers
I thought there was no need for this to be part of the library API?
Hi Eric,
Quoted 8 lines
Quoted 4 lines
Been busy working on RPM support, but looking at this again now. Given that the fsverity signature is a hash of the descriptor, I don't see how we can avoid this?
struct
fsverity_descriptorisn't signed directly; it's hashed as an intermediate step inlibfsverity_compute_digest(). So why would the library user need the definition of 'structfsverity_descriptor'?
Hi Eric,
You're right, I actually moved it to libfsverity_private.h already, but it's in the new patches I am working on.
I pushed it all to git.kernel.org, but I still need to address some of the issues you responded about. I'll post an update to this when I have worked through your list of comments. Most noticeable is that I had to rework the read API to make it work with RPM, but you can find my current tree here (libfsverity branch):
https://git.kernel.org/pub/scm/linux/kernel/git/jes/fsverity-utils.git/
Current RPM work is here:
https://github.com/jessorensen/rpm/tree/rpm-fsverity
Cheers,
Jes
PATCH v3 4/9 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.24.1
Eric Biggers
maintainerRe: [PATCH 4/9] Move hash algorithm code to shared library
Quoted 29 lines · Jes Sorensen
libfsverity.h +9
-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 */
libfsverity.h struct fsverity_descriptor { · line 76
Quoted 10 lines
libfsverity.h +8
-0}; +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); +}; +
It's still a bit weird to have struct fsverity_hash_alg as part of the library API, since the .create_ctx() member is for internal library use only. We at least need to clearly comment this:
struct fsverity_hash_alg {
const char *name;
unsigned int digest_size;
unsigned int block_size;
uint16_t hash_num;
/* for library-internal use only */
struct hash_ctx *(*create_ctx)(const struct fsverity_hash_alg *alg);
};But ideally there would be nothing library-internal in the API at all.
- Eric
Re: [PATCH 4/9] Move hash algorithm code to shared library
Quoted 25 lines · Eric Biggers
libfsverity.h struct fsverity_descriptor { · line 76
Quoted 9 lines · Jes Sorensen
libfsverity.h +8
-0+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); +}; +It's still a bit weird to have struct
fsverity_hash_algas part of the library API, since the .create_ctx() member is for internal library use only. We at least need to clearly comment this:struct fsverity_hash_alg { const char *name; unsigned int digest_size; unsigned int block_size; uint16_t hash_num; /* for library-internal use only */ struct hash_ctx *(*create_ctx)(const struct fsverity_hash_alg *alg); };
Quoted 1 line
But ideally there would be nothing library-internal in the API at all.
So I looked this over again, and came up with a solution which gets rid of struct fsverity_hash_alg from the public API. To get around it I extended the API like this:
<uint16_t> = libfsverity_find_alg_by_name(<char *name>)
<int> = libfsverity_digest_size(<uint16_t alg_nr>)
In order to be able to print the algorithm name and list supported algorithms, I introduced:
<char *> = libfsverity_alg_name(<uint16_t alg_nr>)
Cheers,
Jes
PATCH v3 5/9 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.24.1
Eric Biggers
maintainerRe: [PATCH 5/9] Create libfsverity_compute_digest() and adapt cmd_sign to use it
Quoted 5 lines · Jes Sorensen
cmd_sign.c +0
-1@@ -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);
cmd_sign.c int fsverity_cmd_sign(const struct fsverity_command *cmd, · line 439
Quoted 10 lines
cmd_sign.c +1
-6-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 ));
Please use 'sizeof(params)' in cases like this.
cmd_sign.c int fsverity_cmd_sign(const struct fsverity_command *cmd, · line 447
Quoted 8 lines
cmd_sign.c +7
-0+ 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;
This doesn't close the file on error.
- Eric
PATCH v3 6/9 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.24.1
PATCH v3 7/9 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.24.1
PATCH v3 8/9 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.24.1
Eric Biggers
maintainerRe: [PATCH 8/9] Validate input parameters for libfsverity_sign_digest()
Quoted 29 lines · Jes Sorensen
From: Jes Sorensen <[email protected]>
Return
-EINVALon any invalid input argument, as well as if any of the reserved fields are set in structlibfsverity_signature_digestSigned-off-by Jes Sorensen <[email protected]>--- libverity.c | 34 ++++++++++++++++++++++++++-------- 1 file changed, 26 insertions(+), 8 deletions(-)libverity.c +8
-2@@ -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)))
libverity.c libfsverity_sign_digest(const struct libfsverity_digest *digest, · line 514
Quoted 10 lines
libverity.c +10
-0+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 ; + }
This can use ARRAY_SIZE().
- Eric
PATCH v3 9/9 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.24.1
Eric Biggers
maintainerRe: [PATCH 9/9] Document API of libfsverity
Quoted 23 lines · Jes Sorensen
From: Jes Sorensen <[email protected]>
Signed-off-by Jes Sorensen <[email protected]>--- libfsverity.h | 45 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+)libfsverity.h +8
-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 +*
libfsverity.h struct fsverity_hash_alg { · line 84
Quoted 10 lines
libfsverity.h +6
-0+* 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);
Can you add a brief explanation here that clarifies that the "digest of a file" in this context means fs-verity's Merkle tree-based hash (what the kernel calls the "file measurement"), not a standard file hash? These could easily be confused, especially by people not as familiar with fs-verity.
Also, it's important to also mention that the digest needs to be free()d.
Quoted 9 lines
libfsverity.h +8
-0+/* +* 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 +*
libfsverity.h struct fsverity_hash_alg { · line 103
Quoted 10 lines
libfsverity.h +6
-0+* 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);
Can you add some more details here? What is the signature for, what type of signature is it, what format do the key file and certificate file need to be in, what crypto algorithms do they need to use, etc.?
(I know, I need to add a man page for the 'fsverity' program that explains this too. There's some explanation in the README but not enough.)
Also, it's important to mention that the signature needs to be free()d.
libfsverity.h struct fsverity_hash_alg { · line 112
Quoted 8 lines
libfsverity.h +8
-0+/* +* 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 +*/
We should be more specific and write "NULL if not found", since "not found" is the only type of error that makes sense for this.
libfsverity.h struct fsverity_hash_alg { · line 125
Quoted 13 lines
libfsverity.h +9
-0const 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);
Likewise.
- Eric
Eric Biggers
maintainerQuoted 42 lines · Jes Sorensen
From: Jes Sorensen <[email protected]>
Hi,
This is an updated version of my patches to split fsverity-utils into a shared library. This version addresses most of the comments I received in the last version:
1) Document the API
2) Verified ran xfstest against the build
3) Make structfsverity_descriptorprivate
4) Reviewed (and documented) error codes
5) Improved validation of input parameters, and return error if any reserved field is not zero.I left struct
fsverity_hash_algin the public API, because it adds useful information to the user, in particular providing the digest size, and allows the caller to walk the list to obtain the supported algorithms. The alternative is to introduce alibverity_get_digest_size()call.I still need to add some self-tests to the build and deal with the soname stuff.
Next up is rpm support.
Cheers,
JesJes Sorensen (9):
Build basic shared library framework
Changecompute_file_measurement()to take a file descriptor as
argument
Movefsverity_descriptordefinition tolibfsverity.hMove 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
Quoted 15 lines
Makefile | 18 +- cmd_enable.c | 11 +- cmd_measure.c | 4 +- cmd_sign.c | 526 +++------------------------------------ fsverity.c | 16 +- hash_algs.c | 26 +- hash_algs.h | 27 -- libfsverity.h | 127 ++++++++++ libfsverity_private.h | 33 +++ libverity.c | 559 ++++++++++++++++++++++++++++++++++++++++++ util.h | 2 + 11 files changed, 801 insertions(+), 548 deletions(-) create mode 100644 libfsverity.h create mode 100644 libfsverity_private.h create mode 100644 libverity.c
Have you tried using the library? It doesn't work for me because it uses functions from util.c which aren't compiled in:
test.c:
#include "libfsverity.h"
int main() { }$ gcc test.c -L. -lfsverity
/usr/bin/ld: ./libfsverity.so: undefined reference to do_error_msg' /usr/bin/ld: ./libfsverity.so: undefined reference to error_msg_errno' /usr/bin/ld: ./libfsverity.so: undefined reference to error_msg' /usr/bin/ld: ./libfsverity.so: undefined reference to fatal_error' /usr/bin/ld: ./libfsverity.so: undefined reference to assertion_failed' /usr/bin/ld: ./libfsverity.so: undefined reference to xmalloc' /usr/bin/ld: ./libfsverity.so: undefined reference to xzalloc' /usr/bin/ld: ./libfsverity.so: undefined reference to xmemdup'
- Eric