ima: support fs-verity digests and signatures
Subsystems (7)
Mimi Zohar
maintainerv3 cover ima: support fs-verity digests and signatures
Support for including fs-verity file digests and signatures in the IMA measurement list as well as verifying the fs-verity file digest based signatures, all based on IMA policy rules, was discussed from the beginning, prior to fs-verity being upstreamed[1,2].
Support including fs-verity file digests in the 'd-ng' template field based on a new policy rule option named 'digest_type=hash|verity'. Also support verifying fs-verity file digest based signatures based on policy.
A new template field named 'd-type' as well as a new template named 'ima-ngv2' are defined to differentiate betweeen file hashes and fs-verity file digests, when file signatures are not included in the IMA measurement list.
To disambiguate the type of file signature, define IMA_VERITY_SIG xattr type and a new signature format version, which is a hash of the new ima_file_id structure.
[1] https://events19.linuxfoundation.org/wp-content/uploads/2017/11/fs-verify_Mike-Halcrow_Eric-Biggers.pdf
[2] Documentation/filesystems/fsverity.rst
Changelog v3:
- Addressed Eric Bigger's comments: included Ack, incremented the signature format version, the crypto issues are generic and will be addressed by him separately.
- Addressed Vitaly Chikunov's comments: hard coded maximum digest size rather than using a flexible array, removed unnecessary assignment, and fixed comment to match variable name.
- Defined new "ima_max_digest_size" struct to avoid wrapping the "ima_digest_data" struct inside a function local structure or having to dynamically allocate it with enough memory for the specific hash algo size.
Changelog v2:
- Addressed Eric Bigger's comments: sign the hash of fsverity's digest and the digest's metadata, use match_string, use preferred function name fsverity_get_digest(), support including unsigned fs-verity's digests in the IMA measurement list.
- Remove signatures requirement for including fs-verity's file digests in the 'd-ng' field of the measurement list.
Changelog v1:
- Updated both fsverity and IMA documentation.
- Addressed both Eric Bigger's and Lakshmi's comments.
Mimi Zohar (8):
ima: rename IMA_ACTION_FLAGS to IMA_NONACTION_FLAGS
ima: define ima_max_digest_data struct without a flexible array
variable
fs-verity: define a function to return the integrity protected file
digest
ima: define a new template field 'd-type' and a new template
'ima-ngv2'
ima: include fsverity's file digests in the IMA measurement list
ima: define signature version 3
ima: support fs-verity file digest based version 3 signatures
fsverity: update the documentation
Documentation/ABI/testing/ima_policy | 17 +++++ Documentation/filesystems/fsverity.rst | 22 +++--- Documentation/security/IMA-templates.rst | 10 ++- fs/verity/Kconfig | 1 + fs/verity/fsverity_private.h | 7 -- fs/verity/measure.c | 39 +++++++++++ include/linux/fsverity.h | 18 +++++ security/integrity/digsig.c | 3 +- security/integrity/ima/ima.h | 2 +- security/integrity/ima/ima_api.c | 29 +++++++- security/integrity/ima/ima_appraise.c | 83 ++++++++++++++++++++++- security/integrity/ima/ima_crypto.c | 2 +- security/integrity/ima/ima_init.c | 9 +-- security/integrity/ima/ima_main.c | 2 +- security/integrity/ima/ima_policy.c | 40 ++++++++++- security/integrity/ima/ima_template.c | 3 + security/integrity/ima/ima_template_lib.c | 26 ++++++- security/integrity/ima/ima_template_lib.h | 2 + security/integrity/integrity.h | 53 +++++++++++++-- 19 files changed, 329 insertions(+), 39 deletions(-)
Signature · 1 line
2.27.0
Mimi Zohar
maintainerPATCH v3 1/8 ima: rename IMA_ACTION_FLAGS to IMA_NONACTION_FLAGS
Simple policy rule options, such as fowner, uid, or euid, can be checked immediately, while other policy rule options, such as requiring a file signature, need to be deferred.
The 'flags' field in the integrity_iint_cache struct contains the policy action', 'subaction', and non action/subaction.
action: measure/measured, appraise/appraised, (collect)/collected,
audit/audited
subaction: appraise status for each hook (e.g. file, mmap, bprm, read,
creds)
non action/subaction: deferred policy rule options and state
Rename the IMA_ACTION_FLAGS to IMA_NONACTION_FLAGS.
--- security/integrity/ima/ima_main.c | 2 +- security/integrity/ima/ima_policy.c | 2 +- security/integrity/integrity.h | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-)
security/integrity/ima/ima_main.c +1 -1
@@ -263,7 +263,7 @@ static int process_measurement(struct file *file, const struct cred *cred,/* reset appraisal flags if ima_inode_post_setattr was called */ iint->flags &= ~(IMA_APPRAISE |IMA_APPRAISED |IMA_APPRAISE_SUBMASK |IMA_APPRAISED_SUBMASK | -IMA_ACTION_FLAGS ); +IMA_NONACTION_FLAGS );/* * Re-evaulate the file if either the xattr has changed or the
security/integrity/ima/ima_policy.c +1 -1
@@ -712,7 +712,7 @@ int ima_match_policy(struct user_namespace *mnt_userns, struct inode *inode, func, mask, func_data))continue ; - action |= entry->flags &IMA_ACTION_FLAGS ; + action |= entry->flags &IMA_NONACTION_FLAGS ; action |= entry->action &IMA_DO_MASK ;if (entry->action &IMA_APPRAISE ) {
security/integrity/integrity.h +2 -2
@@ -30,8 +30,8 @@#define IMA_HASH 0x00000100#define IMA_HASHED 0x00000200 -/* iint cache flags */ -#define IMA_ACTION_FLAGS 0xff000000 +/* iint policy rule cache flags */ +#define IMA_NONACTION_FLAGS 0xff000000#define IMA_DIGSIG_REQUIRED 0x01000000#define IMA_PERMIT_DIRECTIO 0x02000000#define IMA_NEW_FILE 0x04000000
Signature · 1 line
2.27.0
Mimi Zohar
maintainerPATCH v3 2/8 ima: define ima_max_digest_data struct without a flexible array variable
In reply to Mimi ZoharReplace (the ugly) wrapping of the "ima_digest_data" struct, containing a flexible array variable, inside another local structure, by defining "ima_max_digest_data" struct with the maximum digest size.
For example, use the "ima_max_digest_data" struct when calculating the "boot_aggregate" value.
--- security/integrity/ima/ima.h | 2 +- security/integrity/ima/ima_crypto.c | 2 +- security/integrity/ima/ima_init.c | 9 +++------ security/integrity/ima/ima_template_lib.c | 3 ++- security/integrity/integrity.h | 24 +++++++++++++++++++++++ 5 files changed, 31 insertions(+), 9 deletions(-)
security/integrity/ima/ima.h +1 -1
@@ -144,7 +144,7 @@ int ima_calc_buffer_hash(const void *buf, loff_t len, struct ima_digest_data *hash);int ima_calc_field_array_hash (struct ima_field_data *field_data,struct ima_template_entry *entry); -int ima_calc_boot_aggregate (struct ima_digest_data *hash); +int ima_calc_boot_aggregate (struct ima_max_digest_data *hash);void ima_add_violation (struct file *file,const unsigned char *filename,struct integrity_iint_cache *iint,const char *op,const char *cause);
security/integrity/ima/ima_crypto.c +1 -1
@@ -840,7 +840,7 @@ static int ima_calc_boot_aggregate_tfm(char *digest, u16 alg_id,return rc; } -int ima_calc_boot_aggregate (struct ima_digest_data *hash) +int ima_calc_boot_aggregate (struct ima_max_digest_data *hash) {struct crypto_shash *tfm;u16 crypto_id, alg_id;
security/integrity/ima/ima_init.c +3 -6
@@ -47,16 +47,13 @@ static int __init ima_add_boot_aggregate(void)struct integrity_iint_cache tmp_iint, *iint = &tmp_iint;struct ima_event_data event_data = { .iint = iint, .filename = boot_aggregate_name }; +struct ima_max_digest_data hash;int result = -ENOMEM ;int violation =0 ; -struct { -struct ima_digest_data hdr; -char digest[TPM_MAX_DIGEST_SIZE ]; - } hash;memset (iint,0 ,sizeof (*iint));memset (&hash,0 ,sizeof (hash)); - iint->ima_hash = &hash.hdr; + iint->ima_hash = (struct ima_digest_data *)&hash; iint->ima_hash->algo = ima_hash_algo; iint->ima_hash->length = hash_digest_size[ima_hash_algo];
@@ -73,7 +70,7 @@ static int __init ima_add_boot_aggregate(void)* is not found. */ if (ima_tpm_chip) { - result =ima_calc_boot_aggregate (&hash.hdr); + result =ima_calc_boot_aggregate (&hash);if (result <0 ) { audit_cause ="hashing_error" ; goto err_out;
security/integrity/ima/ima_template_lib.c +2 -1
@@ -330,7 +330,8 @@ int ima_eventdigest_init(struct ima_event_data *event_data,if ((const char *)event_data->filename == boot_aggregate_name) {if (ima_tpm_chip) { hash.hdr.algo =HASH_ALGO_SHA1 ; - result =ima_calc_boot_aggregate (&hash.hdr); + result =ima_calc_boot_aggregate ( + (struct ima_max_digest_data *)&hash.hdr);/* algo can change depending on available PCR banks */ if (!result && hash.hdr.algo !=HASH_ALGO_SHA1 )
security/integrity/integrity.h +24 -0
@@ -15,6 +15,7 @@#include <linux/types.h> #include <linux/integrity.h> #include <crypto/sha1.h> +#include <crypto/hash.h> #include <linux/key.h> #include <linux/audit.h>
@@ -110,6 +111,29 @@ struct ima_digest_data {u8 digest[]; } __packed; +/* +* Instead of dynamically allocating memory for the ima_digest_data struct +* with space for the specific hash algo or wrapping the ima_digest_data +* struct inside another local structure, define ima_max_digest_data struct +* with the maximum digest size. +*/ +struct ima_max_digest_data { +u8 algo; +u8 length; +union { +struct { +u8 unused; +u8 type; + } sha1; +struct { +u8 type; +u8 algo; + } ng; +u8 data[2 ]; + } xattr; +u8 digest[HASH_MAX_DIGESTSIZE ]; +} __packed; +/* * signature format v2 - for using with asymmetric keys */
Signature · 1 line
2.27.0
Mimi Zohar
maintainerPATCH v3 3/8 fs-verity: define a function to return the integrity protected file digest
In reply to Mimi ZoharDefine a function named fsverity_get_digest() to return the verity file digest and the associated hash algorithm (enum hash_algo).
--- fs/verity/Kconfig | 1 + fs/verity/fsverity_private.h | 7 ------- fs/verity/measure.c | 39 ++++++++++++++++++++++++++++++++++++ include/linux/fsverity.h | 18 +++++++++++++++++ 4 files changed, 58 insertions(+), 7 deletions(-)
fs/verity/Kconfig +1 -0
@@ -3,6 +3,7 @@ config FS_VERITY bool "FS Verity (read-only file-based authenticity protection)" select CRYPTO + select CRYPTO_HASH_INFO # SHA-256 is implied as it's intended to be the default hash algorithm. # To avoid bloat, other wanted algorithms must be selected explicitly. # Note that CRYPTO_SHA256 denotes the generic C implementation, but
fs/verity/fsverity_private.h +0 -7
@@ -14,7 +14,6 @@#define pr_fmt (fmt) "fs-verity: " fmt -#include <crypto/sha2.h> #include <linux/fsverity.h> #include <linux/mempool.h>
@@ -26,12 +25,6 @@ struct ahash_request;*/ #define FS_VERITY_MAX_LEVELS 8 -/* -* Largest digest size among all hash algorithms supported by fs-verity. -* Currently assumed to be <= size of fsverity_descriptor::root_hash. -*/ -#define FS_VERITY_MAX_DIGEST_SIZE SHA512_DIGEST_SIZE -/* A hash algorithm supported by fs-verity */ struct fsverity_hash_alg {struct crypto_ahash *tfm;/* hash tfm, allocated on demand */
fs/verity/measure.c +39 -0
@@ -57,3 +57,42 @@ int fsverity_ioctl_measure(struct file *filp, void __user *_uarg)return 0 ; }EXPORT_SYMBOL_GPL (fsverity_ioctl_measure); + +/** +* fsverity_get_digest() - get a verity file's digest +* @inode: inode to get digest of +* @digest: (out) pointer to the digest +* @alg: (out) pointer to the hash algorithm enumeration +* +* Return the file hash algorithm and digest of an fsverity protected file. +* +* Return: 0 on success, -errno on failure +*/ +int fsverity_get_digest (struct inode *inode, +u8 digest[FS_VERITY_MAX_DIGEST_SIZE ], +enum hash_algo *alg) +{ +const struct fsverity_info *vi; +const struct fsverity_hash_alg *hash_alg; +int i; + + vi =fsverity_get_info (inode); +if (!vi) +return -ENODATA ;/* not a verity file */ + + hash_alg = vi->tree_params.hash_alg; +memset (digest,0 ,FS_VERITY_MAX_DIGEST_SIZE ); + +/* convert hash algorithm to hash_algo_name */ + i =match_string (hash_algo_name,HASH_ALGO__LAST , hash_alg->name); +if (i <0 ) +return -EINVAL ; + *alg = i; + +memcpy (digest, vi->file_digest, hash_alg->digest_size); + +pr_debug ("file digest %s:%*phN\n" , hash_algo_name[*alg], + hash_digest_size[*alg], digest); + +return 0 ; +}
include/linux/fsverity.h +18 -0
@@ -12,8 +12,16 @@#define _LINUX_FSVERITY_H#include <linux/fs.h> +#include <crypto/hash_info.h> +#include <crypto/sha2.h> #include <uapi/linux/fsverity.h> +/* +* Largest digest size among all hash algorithms supported by fs-verity. +* Currently assumed to be <= size of fsverity_descriptor::root_hash. +*/ +#define FS_VERITY_MAX_DIGEST_SIZE SHA512_DIGEST_SIZE +/* Verity operations for filesystems */ struct fsverity_operations {
@@ -131,6 +139,9 @@ int fsverity_ioctl_enable(struct file *filp, const void __user *arg);/* measure.c */ int fsverity_ioctl_measure (struct file *filp,void __user *arg); +int fsverity_get_digest (struct inode *inode, +u8 digest[FS_VERITY_MAX_DIGEST_SIZE ], +enum hash_algo *alg);/* open.c */
@@ -170,6 +181,13 @@ static inline int fsverity_ioctl_measure(struct file *filp, void __user *arg)return -EOPNOTSUPP ; } +static inline int fsverity_get_digest (struct inode *inode, +u8 digest[FS_VERITY_MAX_DIGEST_SIZE ], +enum hash_algo *alg) +{ +return -EOPNOTSUPP ; +} +/* open.c */ static inline int fsverity_file_open (struct inode *inode,struct file *filp)
Signature · 1 line
2.27.0
Eric Biggers
maintainerRe: [PATCH v3 3/8] fs-verity: define a function to return the integrity protected file digest
fs/verity/measure.c int fsverity_ioctl_measure(struct file *filp, void __user *_uarg) · line 90
Quoted 8 lines · Mimi Zohar
fs/verity/measure.c +8
-0+ hash_alg = vi->tree_params.hash_alg; +memset (digest,0 ,FS_VERITY_MAX_DIGEST_SIZE ); + +/* convert hash algorithm to hash_algo_name */ + i =match_string (hash_algo_name,HASH_ALGO__LAST , hash_alg->name); +if (i <0 ) +return -EINVAL ; + *alg = i;
The above comment is backwards. This code is converting a hash algorithm name to an ID. The comment is unclear, but it sounds like it's saying the opposite.
Review
Quoted 2 lines
(quoted diff) +2
-0+ + memcpy(digest, vi->file_digest, hash_alg->digest_size);
Here there are two "sources of truth" for the digest size. How about checking that they are the same:
if (WARN_ON_ONCE(hash_alg->digest_size != hash_digest_size[*alg])) return -EINVAL;
- Eric
Mimi Zohar
maintainerPATCH v3 4/8 ima: define a new template field 'd-type' and a new template 'ima-ngv2'
In reply to Mimi ZoharIn preparation to differentiate between regular file hashes and fs-verity's file digests, define a new template field named 'd-type'. Define and include the new 'd-type' field in the new template named 'ima-ngv2'.
--- security/integrity/ima/ima_template.c | 3 +++ security/integrity/ima/ima_template_lib.c | 13 +++++++++++++ security/integrity/ima/ima_template_lib.h | 2 ++ 3 files changed, 18 insertions(+)
security/integrity/ima/ima_template.c +3 -0
@@ -19,6 +19,7 @@ enum header_fields { HDR_PCR, HDR_DIGEST, HDR_TEMPLATE_NAME,static struct ima_template_desc builtin_templates[] = { {.name =IMA_TEMPLATE_IMA_NAME , .fmt =IMA_TEMPLATE_IMA_FMT }, {.name ="ima-ng" , .fmt ="d-ng|n-ng" }, + {.name ="ima-ngv2" , .fmt ="d-ng|n-ng|d-type" }, {.name ="ima-sig" , .fmt ="d-ng|n-ng|sig" }, {.name ="ima-buf" , .fmt ="d-ng|n-ng|buf" }, {.name ="ima-modsig" , .fmt ="d-ng|n-ng|sig|d-modsig|modsig" },
@@ -39,6 +40,8 @@ static const struct ima_template_field supported_fields[] = { .field_show = ima_show_template_digest_ng}, {.field_id = "n-ng", .field_init = ima_eventname_ng_init, .field_show = ima_show_template_string}, + {.field_id = "d-type", .field_init = ima_eventdigest_type_init, + .field_show = ima_show_template_string}, {.field_id = "sig", .field_init = ima_eventsig_init, .field_show = ima_show_template_sig}, {.field_id = "buf", .field_init = ima_eventbuf_init,
security/integrity/ima/ima_template_lib.c +13 -0
@@ -387,6 +387,19 @@ int ima_eventdigest_ng_init(struct ima_event_data *event_data, hash_algo, field_data); } +/* +* This function writes the digest type of an event. +*/ +int ima_eventdigest_type_init (struct ima_event_data *event_data, +struct ima_field_data *field_data) +{ +static const char *const digest_type[] = {"hash" }; + +return ima_write_template_field_data (digest_type[0 ], +strlen (digest_type[0 ]), +DATA_FMT_STRING , field_data); +} +/* * This function writes the digest of the file which is expected to match the * digest contained in the file's appended signature.
security/integrity/ima/ima_template_lib.h +2 -0
@@ -38,6 +38,8 @@ int ima_eventname_init(struct ima_event_data *event_data, struct ima_field_data *field_data);int ima_eventdigest_ng_init (struct ima_event_data *event_data,struct ima_field_data *field_data); +int ima_eventdigest_type_init (struct ima_event_data *event_data, +struct ima_field_data *field_data);int ima_eventdigest_modsig_init (struct ima_event_data *event_data,struct ima_field_data *field_data); int ima_eventname_ng_init(struct ima_event_data *event_data,
Signature · 1 line
2.27.0
Mimi Zohar
maintainerPATCH v3 5/8 ima: include fsverity's file digests in the IMA measurement list
In reply to Mimi ZoharAllow fsverity's file digests to be included in the IMA measurement list based on policy.
Define a new measurement policy rule option named 'digest_type=' to allow fsverity file digests to be included in the measurement list in the d-ng field.
Including the 'd-type' template field is recommended for unsigned fs-verity digests to distinguish between d-ng digest types. The following policy rule, for example, specifies the new 'ima-ngv2' template.
measure func=FILE_CHECK digest_type=hash|verity template=ima-ngv2
--- Documentation/ABI/testing/ima_policy | 7 +++++ Documentation/security/IMA-templates.rst | 6 ++++ security/integrity/ima/ima_api.c | 29 +++++++++++++++-- security/integrity/ima/ima_policy.c | 38 ++++++++++++++++++++++- security/integrity/ima/ima_template_lib.c | 9 +++++- security/integrity/integrity.h | 4 ++- 6 files changed, 88 insertions(+), 5 deletions(-)
Documentation/ABI/testing/ima_policy +7 -0
@@ -51,6 +51,7 @@ Description: appraise_flag:= [check_blacklist] Currently, blacklist check is only for files signed with appended signature. + digest_type:= [hash|verity] keyrings:= list of keyrings (eg, .builtin_trusted_keys|.ima). Only valid when action is "measure" and func is KEY_CHECK.
@@ -149,3 +150,9 @@ Description: security.ima xattr of a file: appraise func=SETXATTR_CHECK appraise_algos=sha256,sha384,sha512 + + Example of measure rule allowing fs-verity's digests on a + particular filesystem with indication of type of digest. + + measure func=FILE_CHECK digest_type=hash|verity \ + fsuuid=... template=ima-ngv2
Documentation/security/IMA-templates.rst +6 -0
@@ -69,6 +69,7 @@ descriptors by adding their identifier to the format string algorithm (field format: [<hash algo>:]digest, where the digest prefix is shown only if the hash algorithm is not SHA1 or MD5); - 'd-modsig': the digest of the event without the appended modsig; + - 'd-type': the type of file digest (e.g. hash, verity[1]); - 'n-ng': the name of the event, without size limitations; - 'sig': the file signature, or the EVM portable signature if the file signature is not found;
@@ -106,3 +107,8 @@ currently the following methods are supported: the ``ima_template=`` parameter; - register a new template descriptor with custom format through the kernel command line parameter ``ima_template_fmt=``. + + +References +========== +[1] Documentation/filesystems/fsverity.rst
security/integrity/ima/ima_api.c +27 -2
@@ -14,6 +14,7 @@#include <linux/xattr.h> #include <linux/evm.h> #include <linux/iversion.h> +#include <linux/fsverity.h> #include "ima.h"
@@ -200,6 +201,23 @@ int ima_get_action(struct user_namespace *mnt_userns, struct inode *inode, allowed_algos); } +static int ima_get_verity_digest (struct integrity_iint_cache *iint, +struct ima_digest_data *hash) +{ +u8 verity_digest[FS_VERITY_MAX_DIGEST_SIZE ]; +enum hash_algo verity_alg; +int rc; + + rc =fsverity_get_digest (iint->inode, verity_digest, &verity_alg); +if (rc) +return -EINVAL ; +if (hash->algo != verity_alg) +return -EINVAL ; + hash->length = hash_digest_size[verity_alg]; +memcpy (hash->digest, verity_digest, hash->length); +return 0 ; +} +/* * ima_collect_measurement - collect file measurement *
@@ -248,10 +266,17 @@ int ima_collect_measurement(struct integrity_iint_cache *iint,/* Initialize hash digest to 0's in case of failure */ memset (&hash.digest,0 ,sizeof (hash.digest)); -if (buf) +if (buf) { result =ima_calc_buffer_hash (buf, size, &hash.hdr); -else + }else if (iint->flags &IMA_VERITY_ALLOWED ) { + result =ima_get_verity_digest (iint, &hash.hdr); +if (result <0 ) + result =ima_calc_file_hash (file, &hash.hdr); +else + iint->flags |=IMA_VERITY_DIGEST ; + }else { result =ima_calc_file_hash (file, &hash.hdr); + }if (result && result != -EBADF && result != -EINVAL ) goto out;
security/integrity/ima/ima_policy.c +37 -1
@@ -1024,6 +1024,7 @@ enum policy_opt { Opt_fowner_gt, Opt_fgroup_gt, Opt_uid_lt, Opt_euid_lt, Opt_gid_lt, Opt_egid_lt, Opt_fowner_lt, Opt_fgroup_lt, + Opt_digest_type, Opt_appraise_type, Opt_appraise_flag, Opt_appraise_algos, Opt_permit_directio, Opt_pcr, Opt_template, Opt_keyrings, Opt_label, Opt_err
@@ -1066,6 +1067,7 @@ static const match_table_t policy_tokens = { {Opt_egid_lt, "egid<%s"}, {Opt_fowner_lt, "fowner<%s"}, {Opt_fgroup_lt, "fgroup<%s"}, + {Opt_digest_type, "digest_type=%s"}, {Opt_appraise_type, "appraise_type=%s"}, {Opt_appraise_flag, "appraise_flag=%s"}, {Opt_appraise_algos, "appraise_algos=%s"},
@@ -1173,6 +1175,21 @@ static void check_template_modsig(const struct ima_template_desc *template)#undef MSG } +/* +* Make sure the policy rule and template format are in sync. +*/ +static void check_template_field (const struct ima_template_desc *template, +const char *field,const char *msg) +{ +int i; + +for (i =0 ; i < template->num_fields; i++) +if (!strcmp (template->fields[i]->field_id, field)) +return ; + +pr_notice_once ("%s" , msg); +} +static bool ima_validate_rule (struct ima_rule_entry *entry) {/* Ensure that the action is set and is compatible with the flags */
@@ -1215,7 +1232,8 @@ static bool ima_validate_rule(struct ima_rule_entry *entry)IMA_INMASK |IMA_EUID |IMA_PCR |IMA_FSNAME |IMA_GID |IMA_EGID |IMA_FGROUP |IMA_DIGSIG_REQUIRED | - IMA_PERMIT_DIRECTIO | IMA_VALIDATE_ALGOS)) +IMA_PERMIT_DIRECTIO |IMA_VALIDATE_ALGOS | + IMA_VERITY_ALLOWED)) return false;break ;
@@ -1708,6 +1726,13 @@ static int ima_parse_rule(char *rule, struct ima_rule_entry *entry)LSM_SUBJ_TYPE , AUDIT_SUBJ_TYPE);break ; +case Opt_digest_type: +ima_log_string (ab,"digest_type" , args[0 ].from); +if ((strcmp (args[0 ].from,"hash|verity" )) ==0 ) + entry->flags |=IMA_VERITY_ALLOWED ; +else + result = -EINVAL ; +break ;case Opt_appraise_type:ima_log_string (ab,"appraise_type" , args[0 ].from);if ((strcmp (args[0 ].from,"imasig" )) ==0 )
@@ -1798,6 +1823,15 @@ static int ima_parse_rule(char *rule, struct ima_rule_entry *entry)check_template_modsig (template_desc); } +/* d-type template field recommended for unsigned fs-verity digests */ +if (!result && entry->action ==MEASURE && + entry->flags &IMA_VERITY_ALLOWED ) { + template_desc = entry->template ? entry->template : +ima_template_desc_current (); +check_template_field (template_desc,"d-type" , +"verity rules should include d-type" ); + } +audit_log_format (ab,"res=%d" , !result);audit_log_end (ab);return result;
@@ -2147,6 +2181,8 @@ int ima_policy_show(struct seq_file *m, void *v)else seq_puts (m,"appraise_type=imasig " ); } +if (entry->flags &IMA_VERITY_ALLOWED ) +seq_puts (m,"digest_type=hash|verity " );if (entry->flags &IMA_CHECK_BLACKLIST )seq_puts (m,"appraise_flag=check_blacklist " );if (entry->flags &IMA_PERMIT_DIRECTIO )
security/integrity/ima/ima_template_lib.c +8 -1
@@ -393,7 +393,14 @@ int ima_eventdigest_ng_init(struct ima_event_data *event_data,int ima_eventdigest_type_init (struct ima_event_data *event_data,struct ima_field_data *field_data) { -static const char *const digest_type[] = {"hash" }; +static const char *const digest_type[] = {"hash" ,"verity" }; + +if (event_data->iint->flags &IMA_VERITY_DIGEST ) { +return ima_write_template_field_data (digest_type[1 ], +strlen (digest_type[1 ]), +DATA_FMT_STRING , + field_data); + } return ima_write_template_field_data(digest_type[0], strlen(digest_type[0]),
security/integrity/integrity.h +3 -1
@@ -32,7 +32,7 @@#define IMA_HASHED 0x00000200/* iint policy rule cache flags */ -#define IMA_NONACTION_FLAGS 0xff000000 +#define IMA_NONACTION_FLAGS 0xff800000#define IMA_DIGSIG_REQUIRED 0x01000000#define IMA_PERMIT_DIRECTIO 0x02000000#define IMA_NEW_FILE 0x04000000
@@ -40,6 +40,8 @@#define IMA_FAIL_UNVERIFIABLE_SIGS 0x10000000#define IMA_MODSIG_ALLOWED 0x20000000#define IMA_CHECK_BLACKLIST 0x40000000 +#define IMA_VERITY_ALLOWED 0x80000000 +#define IMA_VERITY_DIGEST 0x00800000#define IMA_DO_MASK (IMA_MEASURE | IMA_APPRAISE | IMA_AUDIT | \ IMA_HASH | IMA_APPRAISE_SUBMASK)
Signature · 1 line
2.27.0
Eric Biggers
maintainerRe: [PATCH v3 5/8] ima: include fsverity's file digests in the IMA measurement list
Quoted 29 lines · Mimi Zohar
Allow fsverity's file digests to be included in the IMA measurement list based on policy.
Define a new measurement policy rule option named 'digest_type=' to allow fsverity file digests to be included in the measurement list in the d-ng field.
Including the 'd-type' template field is recommended for unsigned fs-verity digests to distinguish between d-ng digest types. The following policy rule, for example, specifies the new 'ima-ngv2' template.
measure func=FILE_CHECK digest_type=hash|verity template=ima-ngv2
Signed-off-by Mimi Zohar <[email protected]>--- Documentation/ABI/testing/ima_policy | 7 +++++ Documentation/security/IMA-templates.rst | 6 ++++ security/integrity/ima/ima_api.c | 29 +++++++++++++++-- security/integrity/ima/ima_policy.c | 38 ++++++++++++++++++++++- security/integrity/ima/ima_template_lib.c | 9 +++++- security/integrity/integrity.h | 4 ++- 6 files changed, 88 insertions(+), 5 deletions(-)Documentation/ABI/testing/ima_policy +0
-0
Documentation/ABI/testing/ima_policy Description: · line 54
Quoted 4 lines
Documentation/ABI/testing/ima_policy +1
-0@@ -51,6 +51,7 @@ Description: appraise_flag:= [check_blacklist] Currently, blacklist check is only for files signed with appended signature. + digest_type:= [hash|verity]
This doesn't explain what this option actually does.
Documentation/security/IMA-templates.rst descriptors by adding their identifier to the format string · line 72
Quoted 9 lines
Documentation/security/IMA-templates.rst +1
-0@@ -69,6 +69,7 @@ descriptors by adding their identifier to the format string algorithm (field format: [<hash algo>:]digest, where the digest prefix is shown only if the hash algorithm is not SHA1 or MD5); - 'd-modsig': the digest of the event without the appended modsig; + - 'd-type': the type of file digest (e.g. hash, verity[1]);
This should explain how this is different from the hash algorithm.
- Eric
Mimi Zohar
maintainerPATCH v3 6/8 ima: define signature version 3
In reply to Mimi ZoharTo disambiguate the signed data, instead of directly signing the file data hash, signature version 3 signs the hash of the ima_file_id structure.
--- security/integrity/digsig.c | 3 ++- security/integrity/ima/ima_appraise.c | 36 +++++++++++++++++++++++++++ security/integrity/integrity.h | 20 +++++++++++++-- 3 files changed, 56 insertions(+), 3 deletions(-)
security/integrity/digsig.c +2 -1
@@ -74,7 +74,8 @@ int integrity_digsig_verify(const unsigned int id, const char *sig, int siglen,/* v1 API expect signature without xattr type */ return digsig_verify (keyring, sig +1 , siglen -1 , digest, digestlen); -case 2 : +case 2 :/* regular file data hash based sginature */ +case 3 :/* struct ima_file_id data base signature */ return asymmetric_verify (keyring, sig, siglen, digest, digestlen); }
security/integrity/ima/ima_appraise.c +36 -0
@@ -225,6 +225,34 @@ int ima_read_xattr(struct dentry *dentry,return ret; } +/* +* calc_file_id_hash - calculate the hash of the ima_file_id struct data +* @type: xattr type [enum evm_ima_xattr_type] +* @algo: hash algorithm [enum hash_algo] +* @digest: pointer to the digest to be hashed +* @hash: (out) pointer to the hash +* +* IMA signature version 3 disambiguates the data that is signed by +* indirectly signing the hash of the ima_file_id structure data. +* +* Return 0 on success, error code otherwise. +*/ +static int calc_file_id_hash (enum evm_ima_xattr_type type, +enum hash_algo algo,const u8 *digest, +struct ima_max_digest_data *hash) +{ +struct ima_file_id file_id = {.hash_algorithm = algo}; +uint unused =HASH_MAX_DIGESTSIZE - hash_digest_size[algo]; + +memcpy (file_id.hash, digest, hash_digest_size[algo]); + + hash->algo = algo; + hash->length = hash_digest_size[algo]; + +return ima_calc_buffer_hash (&file_id,sizeof (file_id) - unused, + (struct ima_digest_data *)hash); +} +/* * xattr_verify - verify xattr digest or signature *
@@ -236,6 +264,7 @@ static int xattr_verify(enum ima_hooks func, struct integrity_iint_cache *iint, struct evm_ima_xattr_data *xattr_value, int xattr_len, enum integrity_status *status, const char **cause) { + struct signature_v2_hdr *sig;int rc = -EINVAL , hash_start =0 ;switch (xattr_value->type) {
@@ -274,6 +303,13 @@ static int xattr_verify(enum ima_hooks func, struct integrity_iint_cache *iint,break ;case EVM_IMA_XATTR_DIGSIG :set_bit (IMA_DIGSIG , &iint->atomic_flags); + + sig = (typeof (sig ))xattr_value; +if (sig->version !=2 ) { + *cause ="invalid-signature-version" ; + *status =INTEGRITY_FAIL ; +break ; + } rc = integrity_digsig_verify(INTEGRITY_KEYRING_IMA, (const char *)xattr_value, xattr_len,
security/integrity/integrity.h +18 -2
@@ -94,7 +94,7 @@ struct evm_xattr {u8 digest[SHA1_DIGEST_SIZE ]; } __packed; -#define IMA_MAX_DIGEST_SIZE 64 +#define IMA_MAX_DIGEST_SIZE HASH_MAX_DIGESTSIZEstruct ima_digest_data {u8 algo;
@@ -137,7 +137,11 @@ struct ima_max_digest_data { } __packed;/* -* signature format v2 - for using with asymmetric keys +* signature header format v2 - for using with asymmetric keys +* +* signature format: +* version 2: regular file data hash based signature +* version 3: struct ima_file_id data based signature */ struct signature_v2_hdr {uint8_t type;/* xattr type */
@@ -148,6 +152,18 @@ struct signature_v2_hdr {uint8_t sig[];/* signature payload */ } __packed; +/* +* IMA signature version 3 disambiguates the data that is signed, by +* indirectly signing the hash of the ima_file_id structure data. +* +* (The hash of the ima_file_id structure is only of the portion used.) +*/ +struct ima_file_id { +__u8 hash_type;/* xattr type [enum evm_ima_xattr_type] */ +__u8 hash_algorithm;/* Digest algorithm [enum hash_algo] */ +__u8 hash[HASH_MAX_DIGESTSIZE ]; +} __packed; +/* integrity data associated with an inode */ struct integrity_iint_cache {struct rb_node rb_node;/* rooted in integrity_iint_tree */
Signature · 1 line
2.27.0
Mimi Zohar
maintainerPATCH v3 7/8 ima: support fs-verity file digest based version 3 signatures
In reply to Mimi ZoharInstead of calculating a file hash and verifying the signature stored in the security.ima xattr against the calculated file hash, verify fs-verity's signature (version 3).
To differentiate between a regular file hash and an fs-verity file digest based signature stored as security.ima xattr, define a new signature type named IMA_VERITY_DIGSIG.
Update the 'ima-sig' template field to display the new fs-verity signature type as well.
For example:
appraise func=BPRM_CHECK digest_type=hash|verity
--- Documentation/ABI/testing/ima_policy | 10 +++++ Documentation/security/IMA-templates.rst | 4 +- security/integrity/ima/ima_appraise.c | 49 ++++++++++++++++++++++- security/integrity/ima/ima_template_lib.c | 3 +- security/integrity/integrity.h | 5 ++- 5 files changed, 65 insertions(+), 6 deletions(-)
Documentation/ABI/testing/ima_policy +10 -0
@@ -151,6 +151,16 @@ Description: appraise func=SETXATTR_CHECK appraise_algos=sha256,sha384,sha512 + Example of measure and appraise rules allowing fs-verity + signed digests on a particular filesystem identified by + it's fsuuid: + + measure func=BPRM_CHECK digest_type=hash|verity \ + fsuuid=... template=ima-sig + appraise func=BPRM_CHECK digest_type=hash|verity \ + fsuuid=... + + Example of measure rule allowing fs-verity's digests on a particular filesystem with indication of type of digest.
Documentation/security/IMA-templates.rst +2 -2
@@ -71,8 +71,8 @@ descriptors by adding their identifier to the format string - 'd-modsig': the digest of the event without the appended modsig; - 'd-type': the type of file digest (e.g. hash, verity[1]); - 'n-ng': the name of the event, without size limitations; - - 'sig': the file signature, or the EVM portable signature if the file - signature is not found; + - 'sig': the file signature, based on either the file's/fsverity's digest[1], + or the EVM portable signature if the file signature is not found; - 'modsig' the appended file signature; - 'buf': the buffer data that was used to generate the hash without size limitations; - 'evmsig': the EVM portable signature;
security/integrity/ima/ima_appraise.c +47 -2
94 lines not on this page · raw message
security/integrity/ima/ima_template_lib.c +2 -1
@@ -499,7 +499,8 @@ int ima_eventsig_init(struct ima_event_data *event_data, {struct evm_ima_xattr_data *xattr_value = event_data->xattr_value; -if ((!xattr_value) || (xattr_value->type !=EVM_IMA_XATTR_DIGSIG )) +if (!xattr_value || + !(xattr_value->type & (EVM_IMA_XATTR_DIGSIG |IMA_VERITY_DIGSIG )))return ima_eventevmsig_init (event_data, field_data); return ima_write_template_field_data(xattr_value, event_data->xattr_len,
security/integrity/integrity.h +4 -1
@@ -80,6 +80,7 @@ enum evm_ima_xattr_type {EVM_IMA_XATTR_DIGSIG ,IMA_XATTR_DIGEST_NG ,EVM_XATTR_PORTABLE_DIGSIG , +IMA_VERITY_DIGSIG , IMA_XATTR_LAST };
@@ -154,7 +155,9 @@ struct signature_v2_hdr {/* * IMA signature version 3 disambiguates the data that is signed, by -* indirectly signing the hash of the ima_file_id structure data. +* indirectly signing the hash of the ima_file_id structure data, +* containing either the fsverity_descriptor struct digest or, in the +* future, the regular IMA file hash. * * (The hash of the ima_file_id structure is only of the portion used.) */
Signature · 1 line
2.27.0
Eric Biggers
maintainerRe: [PATCH v3 7/8] ima: support fs-verity file digest based version 3 signatures
Quoted 14 lines · Mimi Zohar
Instead of calculating a file hash and verifying the signature stored in the security.ima xattr against the calculated file hash, verify fs-verity's signature (version 3).
To differentiate between a regular file hash and an fs-verity file digest based signature stored as security.ima xattr, define a new signature type named
IMA_VERITY_DIGSIG.Update the 'ima-sig' template field to display the new fs-verity signature type as well.
For example:
appraise func=BPRM_CHECK digest_type=hash|verity
Quoted 8 lines
Signed-off-by Mimi Zohar <[email protected]>--- Documentation/ABI/testing/ima_policy | 10 +++++ Documentation/security/IMA-templates.rst | 4 +- security/integrity/ima/ima_appraise.c | 49 ++++++++++++++++++++++- security/integrity/ima/ima_template_lib.c | 3 +- security/integrity/integrity.h | 5 ++- 5 files changed, 65 insertions(+), 6 deletions(-)
All this IMA-specific stuff is confusing to me, so let me ask a question about what the end result actually is. Let's say I want to use IMA to authenticate ("appraise") a file. I've signed its fs-verity digest with a key. I put only that one key in the IMA keyring, and that key was only ever used to sign that one fs-verity digest. Can an attacker (who controls the file's contents and IMA xattr) replace the file with one with a different contents and still pass the IMA check? For example, could they replace the file's contents with the ima_file_id of the authentic file, and then downgrade the signature version to v2? If they can do that, then the goal of authentication wasn't met. It might be necessary to enforce that only one signature version is used at a time, to avoid this kind of ambiguity.
- Eric
Mimi Zohar
maintainerRe: [PATCH v3 7/8] ima: support fs-verity file digest based version 3 signatures
Quoted 24 lines · Eric Biggers
Quoted 14 lines · Mimi Zohar
Instead of calculating a file hash and verifying the signature stored in the security.ima xattr against the calculated file hash, verify fs-verity's signature (version 3).
To differentiate between a regular file hash and an fs-verity file digest based signature stored as security.ima xattr, define a new signature type named
IMA_VERITY_DIGSIG.Update the 'ima-sig' template field to display the new fs-verity signature type as well.
For example:
appraise func=BPRM_CHECK digest_type=hash|verityQuoted 8 lines
Signed-off-by Mimi Zohar <[email protected]>--- Documentation/ABI/testing/ima_policy | 10 +++++ Documentation/security/IMA-templates.rst | 4 +- security/integrity/ima/ima_appraise.c | 49 ++++++++++++++++++++++- security/integrity/ima/ima_template_lib.c | 3 +- security/integrity/integrity.h | 5 ++- 5 files changed, 65 insertions(+), 6 deletions(-)
Quoted 11 lines
All this IMA-specific stuff is confusing to me, so let me ask a question about what the end result actually is. Let's say I want to use IMA to authenticate ("appraise") a file. I've signed its fs-verity digest with a key. I put only that one key in the IMA keyring, and that key was only ever used to sign that one fs-verity digest. Can an attacker (who controls the file's contents and IMA xattr) replace the file with one with a different contents and still pass the IMA check? For example, could they replace the file's contents with the
ima_file_idof the authentic file, and then downgrade the signature version to v2? If they can do that, then the goal of authentication wasn't met. It might be necessary to enforce that only one signature version is used at a time, to avoid this kind of ambiguity.
Instead of only allowing a single signature version, the signature
verification could be based on policy rules. "ima: include fsverity's
file digests in the IMA measurement list" defines the new policy rule 'digest_type=' option, which currently permits either IMA or fsverity signatures to match. Instead only allow IMA or fsverity signatures, not both, on a per policy rule basis.
From an IMA perspective, this would be safe since the builtin policies do not support fs-verity signatures. After loading a custom policy, additional rules can only extend the custom policy.
thanks,
Mimi
Mimi Zohar
maintainerPATCH v3 8/8 fsverity: update the documentation
In reply to Mimi ZoharUpdate the fsverity documentation related to IMA signature support.
--- Documentation/filesystems/fsverity.rst | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-)
Documentation/filesystems/fsverity.rst +13 -9
@@ -74,8 +74,12 @@ authenticating the files is up to userspace. However, to meet some users' needs, fs-verity optionally supports a simple signature verification mechanism where users can configure the kernel to require that all fs-verity files be signed by a key loaded into a keyring; see -`Built-in signature verification`_. Support for fs-verity file hashes -in IMA (Integrity Measurement Architecture) policies is also planned. +`Built-in signature verification`_. + +IMA supports including fs-verity file digests and signatures based +on the fs-verity file digests in the IMA (Integrity Measurement +Architecture) measurement list and verifying fs-verity based file +signatures stored as security.ima xattrs, based on policy. User API ========
@@ -653,13 +657,13 @@ weren't already directly answered in other parts of this document. hashed and what to do with those hashes, such as log them, authenticate them, or add them to a measurement list. - IMA is planned to support the fs-verity hashing mechanism as an - alternative to doing full file hashes, for people who want the - performance and security benefits of the Merkle tree based hash. - But it doesn't make sense to force all uses of fs-verity to be - through IMA. As a standalone filesystem feature, fs-verity - already meets many users' needs, and it's testable like other - filesystem features e.g. with xfstests. + IMA supports the fs-verity hashing mechanism as an alternative + to doing full file hashes, for people who want the performance + and security benefits of the Merkle tree based hash. But it + doesn't make sense to force all uses of fs-verity to be through + IMA. As a standalone filesystem feature, fs-verity already meets + many users' needs, and it's testable like other filesystem + features e.g. with xfstests. :Q: Isn't fs-verity useless because the attacker can just modify the hashes in the Merkle tree, which is stored on-disk?
Signature · 1 line
2.27.0
Eric Biggers
maintainerQuoted 2 lines · Mimi Zohar
Support including fs-verity file digests in the 'd-ng' template field based on a new policy rule option named 'digest_type=hash|verity'.
Perhaps it should be full_hash or verity? verity is a type of hash.
- Eric
Mimi Zohar
maintainerQuoted 6 lines · Eric Biggers
Quoted 2 lines · Mimi Zohar
Support including fs-verity file digests in the 'd-ng' template field based on a new policy rule option named 'digest_type=hash|verity'.
Perhaps it should be
full_hashor verity? verity is a type of hash.
Ok, but instead of "full_hash", let's rename it to "ima" or "verity".
thanks,
Mimi