dm-devel:dm-crypt: infrastructure for measurement of DM target data using IMA
Subsystems (6)
v2 cover dm-devel:dm-crypt: infrastructure for measurement of DM target data using IMA
There are several device-mapper targets which contribute to verify the integrity of the mapped devices e.g. dm-integrity, dm-verity, dm-crypt etc.
But they do not use the capabilities provided by kernel integrity subsystem (IMA). For instance, the IMA capability that measures several in-memory constructs and files to detect if they have been accidentally or maliciously altered. IMA also has the capability to include these measurements in the IMA measurement list and use them to extend a TPM PCR so that they can be quoted. These TPM PCR extend operations ensure that the tampering with the order of constructs being measured, and tampering with the measured constructs themselves - doesn't go undetected. In general, this capability is used for remote attestation of in-memory constructs and files of interest. As of today,device-mapper targets don't use the benefits of extended TPM PCR quotes and ultimately the benefits of remote attestation.
This series bridges this gap, so that all device-mapper targets could take advantage of IMA's measuring and quoting abilities - thus ultimately enabling remote attestation for device-mapper targets.
This series is based on the following repo/branch:
repo: https://git.kernel.org/pub/scm/linux/kernel/git/zohar/linux-integrity.git
branch: next-integrity
commit 3db0d0c276a7 ("integrity: remove redundant initialization of variable ret")
This series also has a dependency on the following patch series and should be applied in the following order:
1. https://patchwork.kernel.org/patch/11709527/
2. https://patchwork.kernel.org/patch/11730193/
3. https://patchwork.kernel.org/patch/11730757/
Change Log V2:
- Removed the references to "local" measurement from the description - as this series only support remote attestation, and not local integrity enforcement.
- Taken dependency on the updated base series (2. above), which introduced a boolean parameter measure_buf_hash as per community feedback to support measuring hash of the buffer, instead of the buffer itself.
- Taken dependency on the updated early boot measurement series (3. above).
Tushar Sugandhi (2):
dm-devel: collect target data and submit to IMA to measure
dm-crypt: collect data and submit to DM to measure
drivers/md/Makefile | 1 + drivers/md/dm-crypt.c | 170 +++++++++++++++++++ drivers/md/dm-ima.c | 298 +++++++++++++++++++++++++++++++++ include/linux/device-mapper.h | 60 +++++++ security/integrity/ima/Kconfig | 3 +- 5 files changed, 530 insertions(+), 2 deletions(-) create mode 100644 drivers/md/dm-ima.c
Signature · 1 line
2.17.1
PATCH v2 1/2 dm-devel: collect target data and submit to IMA to measure
For the device-mapper targets to take advantage of IMA's measuring and quoting abilities, and for enabling remote attestation for device-mapper targets, device-mapper needs to provide the functionality to consistently measure target data using ima_measure_critical_data() function provided by IMA. A generic set of functions at device-mapper layer would enable the measurement structure to be uniform across targets, and avoid code duplication. It will also make on-boarding easier and faster for targets that want to use IMA infrastructure for measurements, quoting, and remote attestation. The uniform measurement structure across targets would also help the remote attestation services to consistently process, across targets, the measurement to be attested.
Implement a set of functions at device-mapper layer to manage the data coming from various device-mapper targets to be measured by IMA.
Provide the functionality for various tasks - initialize the necessary data structures, add the data to the list of key-value pairs to be be measured, reset the list if needed (e.g. in error/retry cases), and finally pass it on to device-mapper layer, to be measured by IMA.
Ensure the functionality is generic and implemented at device-mapper layer, so that any device-mapper target can use it to measure its data through IMA.
Also make sure the functionality is non-intrusive/best effort for the targets using it. The errors in managing the list to be measured, and the actual errors in the measurement should not disrupt the core functionality of the targets.
Protect the list of key value pairs to be measured for a given target, by putting it under critical sections - so that multi-threaded targets can safely use the list to append the data from different threads, for measurements and quoting.
Compute the last measurement's hash and store it internally, so that unnecessary duplicate data is not sent to IMA for measurement.
Divide the functionality into 5 main functions:
(1) dm_ima_init_measurements(): Use it to initialize device-mapper target's IMA measurement list. It should abstract the necessary data initialization from the device-mapper target apps.
(2) dm_ima_append_measurement_list(): Use it to append the key-value pair to the existing list of key-value pairs to measure.
(3) dm_ima_finalize_and_measure(): Use it to measure the key-value pair list for a given target, and finally release the resources held by the list for that specific target.
Note that the data given by the target for a given device would be sent to IMA subsystem for measurement only if it has changed since the last time it was measured.
(4) dm_ima_reset_measurement_list(): Use it to reset device-mapper target's ima measurement list, by releasing the resources held by the list. Use it if the measurements list need to be reset after dm_ima_init_measurements() and before calling dm_ima_finalize_and_measure().
This can be needed in scenarios like recovering from error paths and retrying measurements and quoting again.
(5) dm_ima_exit_measurements(): Use it during the destruction of the target - to release the resources held for measurement. This is useful to protect the kernel from possible resource leaks when the target adds data for measurements using dm_ima_append_measurement_list(), but gets destroyed before calling dm_ima_finalize_and_measure().
--- drivers/md/Makefile | 1 + drivers/md/dm-ima.c | 298 ++++++++++++++++++++++++++++++++++ include/linux/device-mapper.h | 60 +++++++ 3 files changed, 359 insertions(+) create mode 100644 drivers/md/dm-ima.c
drivers/md/Makefile +1 -0
@@ -74,6 +74,7 @@ obj-$(CONFIG_DM_LOG_WRITES) += dm-log-writes.o obj-$(CONFIG_DM_INTEGRITY) += dm-integrity.o obj-$(CONFIG_DM_ZONED) += dm-zoned.o obj-$(CONFIG_DM_WRITECACHE) += dm-writecache.o +obj-$(CONFIG_IMA) += dm-ima.o ifeq ($(CONFIG_DM_INIT),y) dm-mod-objs += dm-init.o
drivers/md/dm-ima.c new file +298 -0
298 lines not on this page · raw message
include/linux/device-mapper.h +60 -0
78 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH v2 2/2 dm-crypt: collect data and submit to DM to measure
In reply to Tushar SugandhiCurrently, dm-crypt does not take advantage of IMA measuring capabilities, and ultimately the benefits of remote attestation.
Measure various dm-crypt constructs by calling various device-mapper functions - dm_ima_*() that use IMA measuring capabilities. Implement ima_measure_dm_crypt_data() to measure various dm-crypt constructs.
Ensure that ima_measure_dm_crypt_data() is non intrusive, i.e. failures in this function and the call-stack below should not affect the core functionality of dm-crypt.
A demonstrative usage of above functionality on a system:
If the IMA policy contains the following rule:
measure func=CRITICAL_DATA data_sources=dm-crypt template=ima-buf
and, the following commands are used to setup a crypt target:
#key="faf453b4ee938cff2f0d2c869a0b743f59125c0a37f5bcd8f1dbbd911a78abaa" #arg="'0 1953125 crypt aes-xts-plain64 "
#arg="$arg $key 0 "
#arg="$arg /dev/loop0 0 1 allow_discards'" #tgt_name="test-crypt"
#cmd="dmsetup create $tgt_name --table $arg"
#eval $cmd
then, the IMA log at /sys/kernel/security/integrity/ima/ascii_runtime_measurements should contain the dm-crypt measurements. And, the following IMA log entry should be added in the IMA log,
ima-buf sha1:4cbca71967d6b48e13ff5283d8e657899b005f70 1597518359:539244018:dm-crypt:add_target 74695f6e756d5f646973636172645f62696f733d313b7065725f62696f5f646 174615f73697a653d3830383b646d7265715f73746172743d3136383b74666d 735f636f756e743d313b6f6e5f6469736b5f7461675f73697a653d303b696e7 46567726974795f69765f73697a653d303b696e746567726974795f7461675f 73697a653d303b69765f73697a653d31363b69765f6f66667365743d303b736 563746f725f73686966743d303b736563746f725f73697a653d3531323b666c 6167733d323b6369706865725f666c6167733d303b73746172743d303b6b657 95f6d61635f73697a653d303b6b65795f65787472615f73697a653d303b6b65 795f70617274733d313b6b65795f73697a653d33323b6369706865725f73747 2696e673d6165732d7874732d706c61696e36343b6465766963655f6e616d65 3d3235333a303b
where, the ascii representation of the above data is:
ti_num_discard_bios=1;per_bio_data_size=808;dmreq_start=168; tfms_count=1;on_disk_tag_size=0;integrity_iv_size=0; integrity_tag_size=0;iv_size=16;iv_offset=0;sector_shift=0; sector_size=512;flags=2;cipher_flags=0;start=0;key_mac_size=0; key_extra_size=0;key_parts=1;key_size=32; cipher_string=aes-xts-plain64;device_name=253:0;
Some of the above values can be verified using:
#dmsetup table --showkeys
where, the output of the command should be similar to:
test-crypt: 0 1953125 crypt aes-xts-plain64 faf453b4ee938cff2f0d2c869a0b743f59125c0a37f5bcd8f1dbbd911a78abaa 0 7:0 0 1 allow_discards
--- drivers/md/dm-crypt.c | 170 +++++++++++++++++++++++++++++++++ security/integrity/ima/Kconfig | 3 +- 2 files changed, 171 insertions(+), 2 deletions(-)
drivers/md/dm-crypt.c +170 -0
@@ -2465,6 +2465,8 @@ static void crypt_dtr(struct dm_target *ti) ti->private =NULL ; +dm_ima_exit_measurements (ti->type); +if (!cc)return ;
@@ -2908,6 +2910,166 @@ static int crypt_ctr_optional(struct dm_target *ti, unsigned int argc, char **arreturn 0 ; } +#ifdef CONFIG_IMA +/* +* append integer values to dm-crypt specific data +* to be measured through IMA +*/ +static int ima_append_num_values (struct dm_target *ti, +const char *key, +long long num_val) +{ +char *num_str =NULL ; +int length =0 ; +int r =0 ; + +if (!ti || !key) { + r = -EINVAL ; + goto error; + } + + length =snprintf (NULL ,0 ,"%lld" , num_val); + num_str =kzalloc (length +1 ,GFP_KERNEL ); +if (!num_str) { + r = -ENOMEM ; + goto error; + } +snprintf (num_str, length +1 ,"%lld" , num_val); +dm_ima_append_measurement_list (ti->type, + key, + (const void *)num_str, + length); +kzfree (num_str); +return r; +error: +DMERR ("appending num values to IMA measurement list failed %d" , r); +return r; +} +/* +* Measure dm-crypt specific data through IMA. +* It appends all the needed data to the list as a key-val pair using +* dm_ima_append_measurement_list() and internal ima_append_num_values(), +* and finally measures the list using dm_ima_finalize_and_measure(). +*/ +static void ima_measure_dm_crypt_data (struct dm_target *ti,const char *desc) +{ +int r =0 ; +struct crypt_config *cc =NULL ; +const char *devname =dm_table_device_name (ti->table); + +if (!ti) { + r = -EINVAL ; + goto out; + } + + cc = ti->private; + +if (devname) { +dm_ima_append_measurement_list (ti->type, +"device_name" , + (const void *)devname, +strlen (devname)); + } + +if (cc->cipher_string) { +dm_ima_append_measurement_list (ti->type, +"cipher_string" , + (const void *)cc->cipher_string, +strlen (cc->cipher_string)); + } + +if (cc->cipher_auth) { +dm_ima_append_measurement_list (ti->type, +"cipher_auth" , + (const void *)cc->cipher_auth, +strlen (cc->cipher_auth)); + } + + r =ima_append_num_values (ti,"key_size" , cc->key_size); +if (r) + goto out; + + r =ima_append_num_values (ti,"key_parts" , cc->key_parts); +if (r) + goto out; + + r =ima_append_num_values (ti,"key_extra_size" , cc->key_extra_size); +if (r) + goto out; + + r =ima_append_num_values (ti,"key_mac_size" , cc->key_mac_size); +if (r) + goto out; + + r =ima_append_num_values (ti,"start" , cc->start); +if (r) + goto out; + + r =ima_append_num_values (ti,"cipher_flags" , cc->cipher_flags); +if (r) + goto out; + + r =ima_append_num_values (ti,"flags" , cc->flags); +if (r) + goto out; + + r =ima_append_num_values (ti,"sector_size" , cc->sector_size); +if (r) + goto out; + + r =ima_append_num_values (ti,"sector_shift" , cc->sector_shift); +if (r) + goto out; + + r =ima_append_num_values (ti,"iv_offset" , cc->iv_offset); +if (r) + goto out; + + r =ima_append_num_values (ti,"iv_size" , cc->iv_size); +if (r) + goto out; + + r =ima_append_num_values (ti,"integrity_tag_size" , cc->integrity_tag_size); +if (r) + goto out; + + r =ima_append_num_values (ti,"integrity_iv_size" , cc->integrity_iv_size); +if (r) + goto out; + + r =ima_append_num_values (ti,"on_disk_tag_size" , cc->on_disk_tag_size); +if (r) + goto out; + + r =ima_append_num_values (ti,"tfms_count" , cc->tfms_count); +if (r) + goto out; + + r =ima_append_num_values (ti,"dmreq_start" , cc->dmreq_start); +if (r) + goto out; + + r =ima_append_num_values (ti,"per_bio_data_size" , cc->per_bio_data_size); +if (r) + goto out; + + r =ima_append_num_values (ti,"ti_num_discard_bios" , + ti->num_discard_bios); +if (r) + goto out; + +dm_ima_finalize_and_measure (ti->type, desc, false); +return ; + +out: +DMERR ("IMA measurement of dm-crypt data failed %d" , r); + +} +#else +static inline void ima_measure_dm_crypt_data (struct dm_target *ti, +const char *desc) {} +#endif /* CONFIG_IMA */ +/* * Construct an encryption mapping: * <cipher> [<key>|:<key_size>:<user|logon>:<key_description>] <iv_offset> <dev_path> <start>
@@ -3093,6 +3255,10 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv) ti->num_flush_bios =1 ; +dm_ima_init_measurements (ti->type); + +ima_measure_dm_crypt_data (ti,"add_target" ); +return 0 ; bad:
@@ -3225,6 +3391,8 @@ static void crypt_postsuspend(struct dm_target *ti)struct crypt_config *cc = ti->private;set_bit (DM_CRYPT_SUSPENDED , &cc->flags); + +ima_measure_dm_crypt_data (ti,"post_suspend" ); }static int crypt_preresume (struct dm_target *ti)
@@ -3244,6 +3412,8 @@ static void crypt_resume(struct dm_target *ti)struct crypt_config *cc = ti->private;clear_bit (DM_CRYPT_SUSPENDED , &cc->flags); + +ima_measure_dm_crypt_data (ti,"resume" ); }/* Message interface
security/integrity/ima/Kconfig +1 -2
@@ -324,8 +324,7 @@ config IMA_MEASURE_ASYMMETRIC_KEYS config IMA_QUEUE_EARLY_BOOT_DATA bool - depends on IMA_MEASURE_ASYMMETRIC_KEYS - depends on SYSTEM_TRUSTED_KEYRING + depends on (IMA_MEASURE_ASYMMETRIC_KEYS && SYSTEM_TRUSTED_KEYRING) || DM_CRYPT default y config IMA_SECURE_AND_OR_TRUSTED_BOOT
Signature · 1 line
2.17.1