IMA measures files and buffer data such as keys, command-line arguments
passed to the kernel on kexec system call, etc. While these measurements
are necessary for monitoring and validating the integrity of the system,
they are not sufficient. Various data structures, policies, and states
stored in kernel memory also impact the integrity of the system.
Several kernel subsystems contain such integrity critical data -
e.g. LSMs like SELinux, AppArmor etc. or device-mapper targets like
dm-crypt, dm-verity, dm-integrity etc. These kernel subsystems help
protect the integrity of a device. Their integrity critical data is not
expected to change frequently during run-time. Some of these structures
cannot be defined as __ro_after_init, because they are initialized later.
For a given device, various external services/infrastructure tools
(including the attestation service) interact with it - both during the
setup and during rest of the device run-time. They share sensitive data
and/or execute critical workload on that device. The external services
may want to verify the current run-time state of the relevant kernel
subsystems before fully trusting the device with business critical
data/workload. For instance, verifying that SELinux is in "enforce" mode
along with the expected policy, disks are encrypted with a certain
configuration, secure boot is enabled etc.
This series provides the necessary IMA functionality for kernel
subsystems to ensure their configuration can be measured:
- by kernel subsystems themselves,
- in a tamper resistant way,
- and re-measured - triggered on state/configuration change.
This patch set:
- defines a new IMA hook ima_measure_critical_data() to measure
integrity critical data,
- limits the critical data being measured based on a label,
- defines a builtin critical data measurement policy,
- and includes an SELinux consumer of the new IMA critical data hook.
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 207cdd565dfc ("ima: Don't modify file descriptor mode on the fly")
Change Log v7:
Incorporated feedback from Mimi on v6 of this series.
- Updated cover letter and patch descriptions as per Mimi's feedback.
- Changed references to variable names and policy documentation from
plural "data_sources" to singular "data_source".
- Updated SELinux patch to measure only policy, instead of policy and
state. The state measurement will be upstreamed through a separate
patch.
- Updated admin-guide/kernel-parameters.txt to document support for
critical_data in builtin policy.
Change Log v6:
Incorporated feedback from Mimi on v5 of this series.
- Got rid of patch 5 from the v5 of the series.(the allow list for data
sources)
- Updated function descriptions, changed variable names etc.
- Moved the input param event_data_source in ima_measure_critical_data()
to a new patch. (patch 6/8 of this series)
- Split patch 4 from v5 of the series into two patches (patch 4/8 and
patch 5/8)
- Updated cover letter and patch descriptions as per feedback.
Change Log v5:
(1) Incorporated feedback from Stephen on the last SeLinux patch.
SeLinux Patch: https://patchwork.kernel.org/patch/11801585/
- Freed memory in the reverse order of allocation in
selinux_measure_state().
- Used scnprintf() instead of snprintf() to create the string for
selinux state.
- Allocated event name passed to ima_measure_critical_data() before
gathering selinux state and policy information for measuring.
(2) Incorporated feedback from Mimi on v4 of this series.
V4 of this Series: https://patchwork.kernel.org/project/linux-integrity/list/?series=354437
- Removed patch "[v4,2/6] IMA: conditionally allow empty rule data"
- Reversed the order of following patches.
[v4,4/6] IMA: add policy to measure critical data from kernel components
[v4,5/6] IMA: add hook to measure critical data from kernel components
and renamed them to remove "from kernel components"
- Added a new patch to this series -
IMA: add critical_data to built-in policy rules
- Added the next version of SeLinux patch (mentioned above) to this
series
selinux: measure state and hash of the policy using IMA
- Updated cover-letter description to give broader perspective of the
feature, rearranging paragraphs, removing unnecessary info, clarifying
terms etc.
- Got rid of opt_list param from ima_match_rule_data().
- Updated the documentation to remove sources that don't yet exist.
- detailed IMA hook description added to ima_measure_critical_data(),
as well as elaborating terms event_name, event_data_source.
- "data_sources:=" is not a mandatory policy option for
func=CRITICAL_DATA anymore. If not present, all the data sources
specified in __ima_supported_kernel_data_sources will be measured.
Lakshmi Ramasubramanian (2):
IMA: define a builtin critical data measurement policy
selinux: include a consumer of the new IMA critical data hook
Tushar Sugandhi (6):
IMA: generalize keyring specific measurement constructs
IMA: add support to measure buffer data hash
IMA: define a hook to measure kernel integrity critical data
IMA: add policy rule to measure critical data
IMA: limit critical data measurement based on a label
IMA: extend critical data hook to limit the measurement based on a
label
Documentation/ABI/testing/ima_policy | 5 +-
.../admin-guide/kernel-parameters.txt | 5 +-
include/linux/ima.h | 8 ++
security/integrity/ima/ima.h | 8 +-
security/integrity/ima/ima_api.c | 8 +-
security/integrity/ima/ima_appraise.c | 2 +-
security/integrity/ima/ima_asymmetric_keys.c | 2 +-
security/integrity/ima/ima_main.c | 81 +++++++++++-
security/integrity/ima/ima_policy.c | 122 ++++++++++++++----
security/integrity/ima/ima_queue_keys.c | 3 +-
security/selinux/Makefile | 2 +
security/selinux/include/security.h | 11 +-
security/selinux/measure.c | 86 ++++++++++++
security/selinux/ss/services.c | 71 ++++++++--
14 files changed, 364 insertions(+), 50 deletions(-)
create mode 100644 security/selinux/measure.c
--
2.17.1
From: Lakshmi Ramasubramanian <[email protected]>
Define a new critical data builtin policy to allow measuring
early kernel integrity critical data before a custom IMA policy
is loaded.
Add critical data to built-in IMA rules if the kernel command line
contains "ima_policy=critical_data".
Update the documentation on kernel parameters to document
the new critical data builtin policy.
Signed-off-by: Lakshmi Ramasubramanian <[email protected]>
---
Documentation/admin-guide/kernel-parameters.txt | 5 ++++-
security/integrity/ima/ima_policy.c | 12 ++++++++++++
2 files changed, 16 insertions(+), 1 deletion(-)
diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index 526d65d8573a..6034d75c3ca0 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -1746,7 +1746,7 @@
ima_policy= [IMA]
The builtin policies to load during IMA setup.
Format: "tcb | appraise_tcb | secure_boot |
- fail_securely"
+ fail_securely | critical_data"
The "tcb" policy measures all programs exec'd, files
mmap'd for exec, and all files opened with the read
@@ -1765,6 +1765,9 @@
filesystems with the SB_I_UNVERIFIABLE_SIGNATURE
flag.
+ The "critical_data" policy measures kernel integrity
+ critical data.
+
ima_tcb [IMA] Deprecated. Use ima_policy= instead.
Load a policy which meets the needs of the Trusted
Computing Base. This means IMA will measure all
diff --git a/security/integrity/ima/ima_policy.c b/security/integrity/ima/ima_policy.c
index 7486d09a3f60..37ca16a9e65f 100644
--- a/security/integrity/ima/ima_policy.c
+++ b/security/integrity/ima/ima_policy.c
@@ -206,6 +206,10 @@ static struct ima_rule_entry secure_boot_rules[] __ro_after_init = {
.flags = IMA_FUNC | IMA_DIGSIG_REQUIRED},
};
+static struct ima_rule_entry critical_data_rules[] __ro_after_init = {
+ {.action = MEASURE, .func = CRITICAL_DATA, .flags = IMA_FUNC},
+};
+
/* An array of architecture specific rules */
static struct ima_rule_entry *arch_policy_entry __ro_after_init;
@@ -228,6 +232,7 @@ __setup("ima_tcb", default_measure_policy_setup);
static bool ima_use_appraise_tcb __initdata;
static bool ima_use_secure_boot __initdata;
+static bool ima_use_critical_data __initdata;
static bool ima_fail_unverifiable_sigs __ro_after_init;
static int __init policy_setup(char *str)
{
@@ -242,6 +247,8 @@ static int __init policy_setup(char *str)
ima_use_appraise_tcb = true;
else if (strcmp(p, "secure_boot") == 0)
ima_use_secure_boot = true;
+ else if (strcmp(p, "critical_data") == 0)
+ ima_use_critical_data = true;
else if (strcmp(p, "fail_securely") == 0)
ima_fail_unverifiable_sigs = true;
else
@@ -875,6 +882,11 @@ void __init ima_init_policy(void)
ARRAY_SIZE(default_appraise_rules),
IMA_DEFAULT_POLICY);
+ if (ima_use_critical_data)
+ add_rules(critical_data_rules,
+ ARRAY_SIZE(critical_data_rules),
+ IMA_DEFAULT_POLICY);
+
ima_update_policy_flag();
}
--
2.17.1
From: Lakshmi Ramasubramanian <[email protected]>
IMA measures files and buffer data such as keys, command line arguments
passed to the kernel on kexec system call, etc. While these measurements
enable monitoring and validating the integrity of the system, it is not
sufficient. Various data structures, policies and states stored in kernel
memory also impact the integrity of the system. Updates to these data
structures would have an impact on the security functionalities.
For example, SELinux stores the active policy in memory. Changes to this
data at runtime would have an impact on the security guarantees provided
by SELinux. Measuring such in-memory data structures through IMA
subsystem provides a secure way for a remote attestation service to
know the state of the system and also the runtime changes in the state
of the system.
SELinux policy is a critical data for this security module that needs
to be measured. This measurement can be used by an attestation service,
for instance, to verify if the policy has been setup correctly and that
it hasn't been tampered at run-time.
Measure the hash of the loaded policy by calling the IMA hook
ima_measure_critical_data(). Since the size of the loaded policy can
be large (several MB), measure the hash of the policy instead of
the entire policy to avoid bloating the IMA log entry.
Add "selinux" to the list of supported data sources maintained by IMA
to enable measuring SELinux data.
To enable SELinux data measurement, the following steps are required:
1, Add "ima_policy=critical_data" to the kernel command line arguments
to enable measuring SELinux data at boot time.
For example,
BOOT_IMAGE=/boot/vmlinuz-5.10.0-rc1+ root=UUID=fd643309-a5d2-4ed3-b10d-3c579a5fab2f ro nomodeset security=selinux ima_policy=critical_data
2, Add the following rule to /etc/ima/ima-policy
measure func=CRITICAL_DATA data_source=selinux
Sample measurement of the hash of SELinux policy:
To verify the measured data with the current SELinux policy run
the following commands and verify the output hash values match.
sha256sum /sys/fs/selinux/policy | cut -d' ' -f 1
grep "selinux-policy-hash" /sys/kernel/security/integrity/ima/ascii_runtime_measurements | tail -1 | cut -d' ' -f 6
Note that the actual verification of SELinux policy would require loading
the expected policy into an identical kernel on a pristine/known-safe
system and run the sha256sum /sys/kernel/selinux/policy there to get
the expected hash.
Signed-off-by: Lakshmi Ramasubramanian <[email protected]>
Suggested-by: Stephen Smalley <[email protected]>
---
Documentation/ABI/testing/ima_policy | 3 +-
security/selinux/Makefile | 2 +
security/selinux/include/security.h | 11 +++-
security/selinux/measure.c | 86 ++++++++++++++++++++++++++++
security/selinux/ss/services.c | 71 ++++++++++++++++++++---
5 files changed, 162 insertions(+), 11 deletions(-)
create mode 100644 security/selinux/measure.c
diff --git a/Documentation/ABI/testing/ima_policy b/Documentation/ABI/testing/ima_policy
index 0f4ee9e0a455..7c7023f7986b 100644
--- a/Documentation/ABI/testing/ima_policy
+++ b/Documentation/ABI/testing/ima_policy
@@ -52,8 +52,9 @@ Description:
template:= name of a defined IMA template type
(eg, ima-ng). Only valid when action is "measure".
pcr:= decimal value
- data_source:= [label]
+ data_source:= [selinux]|[label]
label:= a unique string used for grouping and limiting critical data.
+ For example, "selinux" to measure critical data for SELinux.
default policy:
# PROC_SUPER_MAGIC
diff --git a/security/selinux/Makefile b/security/selinux/Makefile
index 4d8e0e8adf0b..83d512116341 100644
--- a/security/selinux/Makefile
+++ b/security/selinux/Makefile
@@ -16,6 +16,8 @@ selinux-$(CONFIG_NETLABEL) += netlabel.o
selinux-$(CONFIG_SECURITY_INFINIBAND) += ibpkey.o
+selinux-$(CONFIG_IMA) += measure.o
+
ccflags-y := -I$(srctree)/security/selinux -I$(srctree)/security/selinux/include
$(addprefix $(obj)/,$(selinux-y)): $(obj)/flask.h
diff --git a/security/selinux/include/security.h b/security/selinux/include/security.h
index 3cc8bab31ea8..18ee65c98446 100644
--- a/security/selinux/include/security.h
+++ b/security/selinux/include/security.h
@@ -229,7 +229,8 @@ void selinux_policy_cancel(struct selinux_state *state,
struct selinux_policy *policy);
int security_read_policy(struct selinux_state *state,
void **data, size_t *len);
-
+int security_read_policy_kernel(struct selinux_state *state,
+ void **data, size_t *len);
int security_policycap_supported(struct selinux_state *state,
unsigned int req_cap);
@@ -446,4 +447,12 @@ extern void ebitmap_cache_init(void);
extern void hashtab_cache_init(void);
extern int security_sidtab_hash_stats(struct selinux_state *state, char *page);
+#ifdef CONFIG_IMA
+extern void selinux_measure_state(struct selinux_state *selinux_state);
+#else
+static inline void selinux_measure_state(struct selinux_state *selinux_state)
+{
+}
+#endif
+
#endif /* _SELINUX_SECURITY_H_ */
diff --git a/security/selinux/measure.c b/security/selinux/measure.c
new file mode 100644
index 000000000000..c409ada6ea39
--- /dev/null
+++ b/security/selinux/measure.c
@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Measure SELinux state using IMA subsystem.
+ */
+#include <linux/vmalloc.h>
+#include <linux/ktime.h>
+#include <linux/ima.h>
+#include "security.h"
+
+/*
+ * This function creates a unique name by appending the timestamp to
+ * the given string. This string is passed as "event_name" to the IMA
+ * hook to measure the given SELinux data.
+ *
+ * The data provided by SELinux to the IMA subsystem for measuring may have
+ * already been measured (for instance the same state existed earlier).
+ * But for SELinux the current data represents a state change and hence
+ * needs to be measured again. To enable this, pass a unique "event_name"
+ * to the IMA hook so that IMA subsystem will always measure the given data.
+ *
+ * For example,
+ * At time T0 SELinux data to be measured is "foo". IMA measures it.
+ * At time T1 the data is changed to "bar". IMA measures it.
+ * At time T2 the data is changed to "foo" again. IMA will not measure it
+ * (since it was already measured) unless the event_name, for instance,
+ * is different in this call.
+ */
+static char *selinux_event_name(const char *name_prefix)
+{
+ char *event_name = NULL;
+ struct timespec64 cur_time;
+
+ ktime_get_real_ts64(&cur_time);
+ event_name = kasprintf(GFP_KERNEL, "%s-%lld:%09ld", name_prefix,
+ cur_time.tv_sec, cur_time.tv_nsec);
+ if (!event_name) {
+ pr_err("%s: event name not allocated.\n", __func__);
+ return NULL;
+ }
+
+ return event_name;
+}
+
+/*
+ * selinux_measure_state - Measure hash of the SELinux policy
+ *
+ * @state: selinux state struct
+ *
+ * NOTE: This function must be called with policy_mutex held.
+ */
+void selinux_measure_state(struct selinux_state *state)
+{
+ void *policy = NULL;
+ char *policy_event_name = NULL;
+ size_t policy_len;
+ int rc = 0;
+ bool initialized = selinux_initialized(state);
+
+ /*
+ * Measure SELinux policy only after initialization is completed.
+ */
+ if (!initialized)
+ goto out;
+
+ policy_event_name = selinux_event_name("selinux-policy-hash");
+ if (!policy_event_name) {
+ pr_err("%s: Event name for policy not allocated.\n",
+ __func__);
+ rc = -ENOMEM;
+ goto out;
+ }
+
+ rc = security_read_policy_kernel(state, &policy, &policy_len);
+ if (rc) {
+ pr_err("%s: Failed to read policy %d.\n", __func__, rc);
+ goto out;
+ }
+
+ ima_measure_critical_data("selinux", policy_event_name,
+ policy, policy_len, true);
+
+ vfree(policy);
+
+out:
+ kfree(policy_event_name);
+}
diff --git a/security/selinux/ss/services.c b/security/selinux/ss/services.c
index 9704c8a32303..dfa2e00894ae 100644
--- a/security/selinux/ss/services.c
+++ b/security/selinux/ss/services.c
@@ -2180,6 +2180,7 @@ static void selinux_notify_policy_change(struct selinux_state *state,
selinux_status_update_policyload(state, seqno);
selinux_netlbl_cache_invalidate();
selinux_xfrm_notify_policyload();
+ selinux_measure_state(state);
}
void selinux_policy_commit(struct selinux_state *state,
@@ -3875,8 +3876,33 @@ int security_netlbl_sid_to_secattr(struct selinux_state *state,
}
#endif /* CONFIG_NETLABEL */
+/**
+ * security_read_selinux_policy - read the policy.
+ * @policy: SELinux policy
+ * @data: binary policy data
+ * @len: length of data in bytes
+ *
+ */
+static int security_read_selinux_policy(struct selinux_policy *policy,
+ void *data, size_t *len)
+{
+ int rc;
+ struct policy_file fp;
+
+ fp.data = data;
+ fp.len = *len;
+
+ rc = policydb_write(&policy->policydb, &fp);
+ if (rc)
+ return rc;
+
+ *len = (unsigned long)fp.data - (unsigned long)data;
+ return 0;
+}
+
/**
* security_read_policy - read the policy.
+ * @state: selinux_state
* @data: binary policy data
* @len: length of data in bytes
*
@@ -3885,8 +3911,6 @@ int security_read_policy(struct selinux_state *state,
void **data, size_t *len)
{
struct selinux_policy *policy;
- int rc;
- struct policy_file fp;
policy = rcu_dereference_protected(
state->policy, lockdep_is_held(&state->policy_mutex));
@@ -3898,14 +3922,43 @@ int security_read_policy(struct selinux_state *state,
if (!*data)
return -ENOMEM;
- fp.data = *data;
- fp.len = *len;
+ return security_read_selinux_policy(policy, *data, len);
+}
- rc = policydb_write(&policy->policydb, &fp);
- if (rc)
- return rc;
+/**
+ * security_read_policy_kernel - read the policy.
+ * @state: selinux_state
+ * @data: binary policy data
+ * @len: length of data in bytes
+ *
+ * Allocates kernel memory for reading SELinux policy.
+ * This function is for internal use only and should not
+ * be used for returning data to user space.
+ *
+ * This function must be called with policy_mutex held.
+ */
+int security_read_policy_kernel(struct selinux_state *state,
+ void **data, size_t *len)
+{
+ struct selinux_policy *policy;
+ int rc = 0;
- *len = (unsigned long)fp.data - (unsigned long)*data;
- return 0;
+ policy = rcu_dereference_protected(
+ state->policy, lockdep_is_held(&state->policy_mutex));
+ if (!policy) {
+ rc = -EINVAL;
+ goto out;
+ }
+
+ *len = policy->policydb.len;
+ *data = vmalloc(*len);
+ if (!*data) {
+ rc = -ENOMEM;
+ goto out;
+ }
+ rc = security_read_selinux_policy(policy, *data, len);
+
+out:
+ return rc;
}
--
2.17.1
A new IMA policy rule is needed for the IMA hook
ima_measure_critical_data() and the corresponding func CRITICAL_DATA for
measuring the input buffer. The policy rule should ensure the buffer
would get measured only when the policy rule allows the action. The
policy rule should also support the necessary constraints (flags etc.)
for integrity critical buffer data measurements.
Add a policy rule to define the constraints for restricting integrity
critical data measurements.
Signed-off-by: Tushar Sugandhi <[email protected]>
---
security/integrity/ima/ima_policy.c | 35 +++++++++++++++++++++++++----
1 file changed, 31 insertions(+), 4 deletions(-)
diff --git a/security/integrity/ima/ima_policy.c b/security/integrity/ima/ima_policy.c
index 2a0c0603626e..9a8ee80a3128 100644
--- a/security/integrity/ima/ima_policy.c
+++ b/security/integrity/ima/ima_policy.c
@@ -34,6 +34,7 @@
#define IMA_PCR 0x0100
#define IMA_FSNAME 0x0200
#define IMA_KEYRINGS 0x0400
+#define IMA_DATA_SOURCE 0x0800
#define UNKNOWN 0
#define MEASURE 0x0001 /* same as IMA_MEASURE */
@@ -85,6 +86,7 @@ struct ima_rule_entry {
} lsm[MAX_LSM_RULES];
char *fsname;
struct ima_rule_opt_list *keyrings; /* Measure keys added to these keyrings */
+ struct ima_rule_opt_list *data_source; /* Measure data from this source */
struct ima_template_desc *template;
};
@@ -479,6 +481,12 @@ static bool ima_match_rule_data(struct ima_rule_entry *rule,
else
opt_list = rule->keyrings;
break;
+ case CRITICAL_DATA:
+ if (!rule->data_source)
+ return true;
+ else
+ opt_list = rule->data_source;
+ break;
default:
break;
}
@@ -518,13 +526,19 @@ static bool ima_match_rules(struct ima_rule_entry *rule, struct inode *inode,
{
int i;
- if (func == KEY_CHECK) {
- return (rule->flags & IMA_FUNC) && (rule->func == func) &&
- ima_match_rule_data(rule, func_data, cred);
- }
if ((rule->flags & IMA_FUNC) &&
(rule->func != func && func != POST_SETATTR))
return false;
+
+ switch (func) {
+ case KEY_CHECK:
+ case CRITICAL_DATA:
+ return ((rule->func == func) &&
+ ima_match_rule_data(rule, func_data, cred));
+ default:
+ break;
+ }
+
if ((rule->flags & IMA_MASK) &&
(rule->mask != mask && func != POST_SETATTR))
return false;
@@ -1119,6 +1133,19 @@ static bool ima_validate_rule(struct ima_rule_entry *entry)
if (ima_rule_contains_lsm_cond(entry))
return false;
+ break;
+ case CRITICAL_DATA:
+ if (entry->action & ~(MEASURE | DONT_MEASURE))
+ return false;
+
+ if (!(entry->flags & IMA_DATA_SOURCE) ||
+ (entry->flags & ~(IMA_FUNC | IMA_UID | IMA_PCR |
+ IMA_DATA_SOURCE)))
+ return false;
+
+ if (ima_rule_contains_lsm_cond(entry))
+ return false;
+
break;
default:
return false;
--
2.17.1
The IMA hook ima_measure_critical_data() does not support a way to
specify the source of the critical data provider. Thus, the data
measurement cannot be constrained based on the data source label
in the IMA policy.
Extend the IMA hook ima_measure_critical_data() to support passing
the data source label as an input parameter, so that the policy rule can
be used to limit the measurements based on the label.
Signed-off-by: Tushar Sugandhi <[email protected]>
---
include/linux/ima.h | 6 ++++--
security/integrity/ima/ima_main.c | 11 ++++++++---
2 files changed, 12 insertions(+), 5 deletions(-)
diff --git a/include/linux/ima.h b/include/linux/ima.h
index 675f54db6264..6434287a81cd 100644
--- a/include/linux/ima.h
+++ b/include/linux/ima.h
@@ -30,7 +30,8 @@ extern int ima_post_read_file(struct file *file, void *buf, loff_t size,
extern void ima_post_path_mknod(struct dentry *dentry);
extern int ima_file_hash(struct file *file, char *buf, size_t buf_size);
extern void ima_kexec_cmdline(int kernel_fd, const void *buf, int size);
-extern void ima_measure_critical_data(const char *event_name,
+extern void ima_measure_critical_data(const char *event_data_source,
+ const char *event_name,
const void *buf, int buf_len,
bool measure_buf_hash);
@@ -125,7 +126,8 @@ static inline int ima_file_hash(struct file *file, char *buf, size_t buf_size)
}
static inline void ima_kexec_cmdline(int kernel_fd, const void *buf, int size) {}
-static inline void ima_measure_critical_data(const char *event_name,
+static inline void ima_measure_critical_data(const char *event_data_source,
+ const char *event_name,
const void *buf, int buf_len,
bool measure_buf_hash) {}
#endif /* CONFIG_IMA */
diff --git a/security/integrity/ima/ima_main.c b/security/integrity/ima/ima_main.c
index ae59f4a4dd70..7c633901f441 100644
--- a/security/integrity/ima/ima_main.c
+++ b/security/integrity/ima/ima_main.c
@@ -924,6 +924,7 @@ void ima_kexec_cmdline(int kernel_fd, const void *buf, int size)
/**
* ima_measure_critical_data - measure kernel integrity critical data
+ * @event_data_source: kernel data source being measured
* @event_name: event name to be used for the buffer entry
* @buf: pointer to buffer containing data to measure
* @buf_len: length of buffer(in bytes)
@@ -932,6 +933,9 @@ void ima_kexec_cmdline(int kernel_fd, const void *buf, int size)
* Measure the kernel subsystem data, critical to the integrity of the kernel,
* into the IMA log and extend the @pcr.
*
+ * Use @event_data_source to describe the kernel data source for the buffer
+ * being measured.
+ *
* Use @event_name to describe the state/buffer data change.
* Examples of critical data (buf) could be kernel in-memory r/o structures,
* hash of the memory structures, or data that represents subsystem state
@@ -944,17 +948,18 @@ void ima_kexec_cmdline(int kernel_fd, const void *buf, int size)
*
* The data (buf) can only be measured, not appraised.
*/
-void ima_measure_critical_data(const char *event_name,
+void ima_measure_critical_data(const char *event_data_source,
+ const char *event_name,
const void *buf, int buf_len,
bool measure_buf_hash)
{
- if (!event_name || !buf || !buf_len) {
+ if (!event_name || !event_data_source || !buf || !buf_len) {
pr_err("Invalid arguments passed to %s().\n", __func__);
return;
}
process_buffer_measurement(NULL, buf, buf_len, event_name,
- CRITICAL_DATA, 0, NULL,
+ CRITICAL_DATA, 0, event_data_source,
measure_buf_hash);
}
--
2.17.1
On 2020-12-09 11:42:08, Tushar Sugandhi wrote:
> A new IMA policy rule is needed for the IMA hook
> ima_measure_critical_data() and the corresponding func CRITICAL_DATA for
> measuring the input buffer. The policy rule should ensure the buffer
> would get measured only when the policy rule allows the action. The
> policy rule should also support the necessary constraints (flags etc.)
> for integrity critical buffer data measurements.
>
> Add a policy rule to define the constraints for restricting integrity
> critical data measurements.
>
> Signed-off-by: Tushar Sugandhi <[email protected]>
> ---
> security/integrity/ima/ima_policy.c | 35 +++++++++++++++++++++++++----
> 1 file changed, 31 insertions(+), 4 deletions(-)
>
> diff --git a/security/integrity/ima/ima_policy.c b/security/integrity/ima/ima_policy.c
> index 2a0c0603626e..9a8ee80a3128 100644
> --- a/security/integrity/ima/ima_policy.c
> +++ b/security/integrity/ima/ima_policy.c
> @@ -34,6 +34,7 @@
> #define IMA_PCR 0x0100
> #define IMA_FSNAME 0x0200
> #define IMA_KEYRINGS 0x0400
> +#define IMA_DATA_SOURCE 0x0800
You introduce data_source= in the next patch. This macro shouldn't be
added until the next patch.
>
> #define UNKNOWN 0
> #define MEASURE 0x0001 /* same as IMA_MEASURE */
> @@ -85,6 +86,7 @@ struct ima_rule_entry {
> } lsm[MAX_LSM_RULES];
> char *fsname;
> struct ima_rule_opt_list *keyrings; /* Measure keys added to these keyrings */
> + struct ima_rule_opt_list *data_source; /* Measure data from this source */
> struct ima_template_desc *template;
> };
>
> @@ -479,6 +481,12 @@ static bool ima_match_rule_data(struct ima_rule_entry *rule,
> else
> opt_list = rule->keyrings;
> break;
> + case CRITICAL_DATA:
> + if (!rule->data_source)
> + return true;
> + else
> + opt_list = rule->data_source;
If you take my suggestions on patch #1, remove the else and simply
assign opt_list here, too.
> + break;
> default:
> break;
> }
> @@ -518,13 +526,19 @@ static bool ima_match_rules(struct ima_rule_entry *rule, struct inode *inode,
> {
> int i;
>
> - if (func == KEY_CHECK) {
> - return (rule->flags & IMA_FUNC) && (rule->func == func) &&
> - ima_match_rule_data(rule, func_data, cred);
> - }
> if ((rule->flags & IMA_FUNC) &&
> (rule->func != func && func != POST_SETATTR))
> return false;
> +
> + switch (func) {
> + case KEY_CHECK:
> + case CRITICAL_DATA:
> + return ((rule->func == func) &&
> + ima_match_rule_data(rule, func_data, cred));
> + default:
> + break;
> + }
> +
> if ((rule->flags & IMA_MASK) &&
> (rule->mask != mask && func != POST_SETATTR))
> return false;
> @@ -1119,6 +1133,19 @@ static bool ima_validate_rule(struct ima_rule_entry *entry)
> if (ima_rule_contains_lsm_cond(entry))
> return false;
>
> + break;
> + case CRITICAL_DATA:
> + if (entry->action & ~(MEASURE | DONT_MEASURE))
> + return false;
> +
> + if (!(entry->flags & IMA_DATA_SOURCE) ||
> + (entry->flags & ~(IMA_FUNC | IMA_UID | IMA_PCR |
> + IMA_DATA_SOURCE)))
IMA_DATA_SOURCE shouldn't exist in this patch. This isn't the right
indentation, either. See how IMA_KEYRINGS is indented in the KEY_CHECK
case above.
Tyler
> + return false;
> +
> + if (ima_rule_contains_lsm_cond(entry))
> + return false;
> +
> break;
> default:
> return false;
> --
> 2.17.1
>
On 2020-12-10 3:10 p.m., Tyler Hicks wrote:
> On 2020-12-09 11:42:08, Tushar Sugandhi wrote:
>> A new IMA policy rule is needed for the IMA hook
>> ima_measure_critical_data() and the corresponding func CRITICAL_DATA for
>> measuring the input buffer. The policy rule should ensure the buffer
>> would get measured only when the policy rule allows the action. The
>> policy rule should also support the necessary constraints (flags etc.)
>> for integrity critical buffer data measurements.
>>
>> Add a policy rule to define the constraints for restricting integrity
>> critical data measurements.
>>
>> Signed-off-by: Tushar Sugandhi <[email protected]>
>> ---
>> security/integrity/ima/ima_policy.c | 35 +++++++++++++++++++++++++----
>> 1 file changed, 31 insertions(+), 4 deletions(-)
>>
>> diff --git a/security/integrity/ima/ima_policy.c b/security/integrity/ima/ima_policy.c
>> index 2a0c0603626e..9a8ee80a3128 100644
>> --- a/security/integrity/ima/ima_policy.c
>> +++ b/security/integrity/ima/ima_policy.c
>> @@ -34,6 +34,7 @@
>> #define IMA_PCR 0x0100
>> #define IMA_FSNAME 0x0200
>> #define IMA_KEYRINGS 0x0400
>> +#define IMA_DATA_SOURCE 0x0800
>
> You introduce data_source= in the next patch. This macro shouldn't be
> added until the next patch.
>
Ok I will move IMA_DATA_SOURCE to the next patch.
>>
>> #define UNKNOWN 0
>> #define MEASURE 0x0001 /* same as IMA_MEASURE */
>> @@ -85,6 +86,7 @@ struct ima_rule_entry {
>> } lsm[MAX_LSM_RULES];
>> char *fsname;
>> struct ima_rule_opt_list *keyrings; /* Measure keys added to these keyrings */
>> + struct ima_rule_opt_list *data_source; /* Measure data from this source */
>> struct ima_template_desc *template;
>> };
>>
>> @@ -479,6 +481,12 @@ static bool ima_match_rule_data(struct ima_rule_entry *rule,
>> else
>> opt_list = rule->keyrings;
>> break;
>> + case CRITICAL_DATA:
>> + if (!rule->data_source)
>> + return true;
>> + else
>> + opt_list = rule->data_source;
>
> If you take my suggestions on patch #1, remove the else and simply
> assign opt_list here, too.
>
Yup. Will do.
>> + break;
>> default:
>> break;
>> }
>> @@ -518,13 +526,19 @@ static bool ima_match_rules(struct ima_rule_entry *rule, struct inode *inode,
>> {
>> int i;
>>
>> - if (func == KEY_CHECK) {
>> - return (rule->flags & IMA_FUNC) && (rule->func == func) &&
>> - ima_match_rule_data(rule, func_data, cred);
>> - }
>> if ((rule->flags & IMA_FUNC) &&
>> (rule->func != func && func != POST_SETATTR))
>> return false;
>> +
>> + switch (func) {
>> + case KEY_CHECK:
>> + case CRITICAL_DATA:
>> + return ((rule->func == func) &&
>> + ima_match_rule_data(rule, func_data, cred));
>> + default:
>> + break;
>> + }
>> +
>> if ((rule->flags & IMA_MASK) &&
>> (rule->mask != mask && func != POST_SETATTR))
>> return false;
>> @@ -1119,6 +1133,19 @@ static bool ima_validate_rule(struct ima_rule_entry *entry)
>> if (ima_rule_contains_lsm_cond(entry))
>> return false;
>>
>> + break;
>> + case CRITICAL_DATA:
>> + if (entry->action & ~(MEASURE | DONT_MEASURE))
>> + return false;
>> +
>> + if (!(entry->flags & IMA_DATA_SOURCE) ||
>> + (entry->flags & ~(IMA_FUNC | IMA_UID | IMA_PCR |
>> + IMA_DATA_SOURCE)))
>
> IMA_DATA_SOURCE shouldn't exist in this patch. This isn't the right
> indentation, either. See how IMA_KEYRINGS is indented in the KEY_CHECK
> case above.
>
Will do.
~Tushar
> Tyler
>
>> + return false;
>> +
>> + if (ima_rule_contains_lsm_cond(entry))
>> + return false;
>> +
>> break;
>> default:
>> return false;
>> --
>> 2.17.1
>>
On 2020-12-11 09:36:30, Tyler Hicks wrote:
> The calls to pr_err() in this aren't quite following the style of the
> other error SELinux error messages.
Sorry, I left out a word. I meant to say that the calls to pr_err() in
this *file* aren't quite following the right style. Please adjust all of
them.
Thanks!
Tyler
On 2020-12-09 11:42:11, Tushar Sugandhi wrote:
> From: Lakshmi Ramasubramanian <[email protected]>
>
> Define a new critical data builtin policy to allow measuring
> early kernel integrity critical data before a custom IMA policy
> is loaded.
>
> Add critical data to built-in IMA rules if the kernel command line
> contains "ima_policy=critical_data".
>
> Update the documentation on kernel parameters to document
> the new critical data builtin policy.
>
> Signed-off-by: Lakshmi Ramasubramanian <[email protected]>
Reviewed-by: Tyler Hicks <[email protected]>
Tyler
> ---
> Documentation/admin-guide/kernel-parameters.txt | 5 ++++-
> security/integrity/ima/ima_policy.c | 12 ++++++++++++
> 2 files changed, 16 insertions(+), 1 deletion(-)
>
> diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
> index 526d65d8573a..6034d75c3ca0 100644
> --- a/Documentation/admin-guide/kernel-parameters.txt
> +++ b/Documentation/admin-guide/kernel-parameters.txt
> @@ -1746,7 +1746,7 @@
> ima_policy= [IMA]
> The builtin policies to load during IMA setup.
> Format: "tcb | appraise_tcb | secure_boot |
> - fail_securely"
> + fail_securely | critical_data"
>
> The "tcb" policy measures all programs exec'd, files
> mmap'd for exec, and all files opened with the read
> @@ -1765,6 +1765,9 @@
> filesystems with the SB_I_UNVERIFIABLE_SIGNATURE
> flag.
>
> + The "critical_data" policy measures kernel integrity
> + critical data.
> +
> ima_tcb [IMA] Deprecated. Use ima_policy= instead.
> Load a policy which meets the needs of the Trusted
> Computing Base. This means IMA will measure all
> diff --git a/security/integrity/ima/ima_policy.c b/security/integrity/ima/ima_policy.c
> index 7486d09a3f60..37ca16a9e65f 100644
> --- a/security/integrity/ima/ima_policy.c
> +++ b/security/integrity/ima/ima_policy.c
> @@ -206,6 +206,10 @@ static struct ima_rule_entry secure_boot_rules[] __ro_after_init = {
> .flags = IMA_FUNC | IMA_DIGSIG_REQUIRED},
> };
>
> +static struct ima_rule_entry critical_data_rules[] __ro_after_init = {
> + {.action = MEASURE, .func = CRITICAL_DATA, .flags = IMA_FUNC},
> +};
> +
> /* An array of architecture specific rules */
> static struct ima_rule_entry *arch_policy_entry __ro_after_init;
>
> @@ -228,6 +232,7 @@ __setup("ima_tcb", default_measure_policy_setup);
>
> static bool ima_use_appraise_tcb __initdata;
> static bool ima_use_secure_boot __initdata;
> +static bool ima_use_critical_data __initdata;
> static bool ima_fail_unverifiable_sigs __ro_after_init;
> static int __init policy_setup(char *str)
> {
> @@ -242,6 +247,8 @@ static int __init policy_setup(char *str)
> ima_use_appraise_tcb = true;
> else if (strcmp(p, "secure_boot") == 0)
> ima_use_secure_boot = true;
> + else if (strcmp(p, "critical_data") == 0)
> + ima_use_critical_data = true;
> else if (strcmp(p, "fail_securely") == 0)
> ima_fail_unverifiable_sigs = true;
> else
> @@ -875,6 +882,11 @@ void __init ima_init_policy(void)
> ARRAY_SIZE(default_appraise_rules),
> IMA_DEFAULT_POLICY);
>
> + if (ima_use_critical_data)
> + add_rules(critical_data_rules,
> + ARRAY_SIZE(critical_data_rules),
> + IMA_DEFAULT_POLICY);
> +
> ima_update_policy_flag();
> }
>
> --
> 2.17.1
>
On 2020-12-09 11:42:10, Tushar Sugandhi wrote:
> The IMA hook ima_measure_critical_data() does not support a way to
> specify the source of the critical data provider. Thus, the data
> measurement cannot be constrained based on the data source label
> in the IMA policy.
>
> Extend the IMA hook ima_measure_critical_data() to support passing
> the data source label as an input parameter, so that the policy rule can
> be used to limit the measurements based on the label.
>
> Signed-off-by: Tushar Sugandhi <[email protected]>
Reviewed-by: Tyler Hicks <[email protected]>
Tyler
> ---
> include/linux/ima.h | 6 ++++--
> security/integrity/ima/ima_main.c | 11 ++++++++---
> 2 files changed, 12 insertions(+), 5 deletions(-)
>
> diff --git a/include/linux/ima.h b/include/linux/ima.h
> index 675f54db6264..6434287a81cd 100644
> --- a/include/linux/ima.h
> +++ b/include/linux/ima.h
> @@ -30,7 +30,8 @@ extern int ima_post_read_file(struct file *file, void *buf, loff_t size,
> extern void ima_post_path_mknod(struct dentry *dentry);
> extern int ima_file_hash(struct file *file, char *buf, size_t buf_size);
> extern void ima_kexec_cmdline(int kernel_fd, const void *buf, int size);
> -extern void ima_measure_critical_data(const char *event_name,
> +extern void ima_measure_critical_data(const char *event_data_source,
> + const char *event_name,
> const void *buf, int buf_len,
> bool measure_buf_hash);
>
> @@ -125,7 +126,8 @@ static inline int ima_file_hash(struct file *file, char *buf, size_t buf_size)
> }
>
> static inline void ima_kexec_cmdline(int kernel_fd, const void *buf, int size) {}
> -static inline void ima_measure_critical_data(const char *event_name,
> +static inline void ima_measure_critical_data(const char *event_data_source,
> + const char *event_name,
> const void *buf, int buf_len,
> bool measure_buf_hash) {}
> #endif /* CONFIG_IMA */
> diff --git a/security/integrity/ima/ima_main.c b/security/integrity/ima/ima_main.c
> index ae59f4a4dd70..7c633901f441 100644
> --- a/security/integrity/ima/ima_main.c
> +++ b/security/integrity/ima/ima_main.c
> @@ -924,6 +924,7 @@ void ima_kexec_cmdline(int kernel_fd, const void *buf, int size)
>
> /**
> * ima_measure_critical_data - measure kernel integrity critical data
> + * @event_data_source: kernel data source being measured
> * @event_name: event name to be used for the buffer entry
> * @buf: pointer to buffer containing data to measure
> * @buf_len: length of buffer(in bytes)
> @@ -932,6 +933,9 @@ void ima_kexec_cmdline(int kernel_fd, const void *buf, int size)
> * Measure the kernel subsystem data, critical to the integrity of the kernel,
> * into the IMA log and extend the @pcr.
> *
> + * Use @event_data_source to describe the kernel data source for the buffer
> + * being measured.
> + *
> * Use @event_name to describe the state/buffer data change.
> * Examples of critical data (buf) could be kernel in-memory r/o structures,
> * hash of the memory structures, or data that represents subsystem state
> @@ -944,17 +948,18 @@ void ima_kexec_cmdline(int kernel_fd, const void *buf, int size)
> *
> * The data (buf) can only be measured, not appraised.
> */
> -void ima_measure_critical_data(const char *event_name,
> +void ima_measure_critical_data(const char *event_data_source,
> + const char *event_name,
> const void *buf, int buf_len,
> bool measure_buf_hash)
> {
> - if (!event_name || !buf || !buf_len) {
> + if (!event_name || !event_data_source || !buf || !buf_len) {
> pr_err("Invalid arguments passed to %s().\n", __func__);
> return;
> }
>
> process_buffer_measurement(NULL, buf, buf_len, event_name,
> - CRITICAL_DATA, 0, NULL,
> + CRITICAL_DATA, 0, event_data_source,
> measure_buf_hash);
> }
>
> --
> 2.17.1
>
On 2020-12-10 3:19 p.m., Tyler Hicks wrote:
> On 2020-12-09 11:42:10, Tushar Sugandhi wrote:
>> The IMA hook ima_measure_critical_data() does not support a way to
>> specify the source of the critical data provider. Thus, the data
>> measurement cannot be constrained based on the data source label
>> in the IMA policy.
>>
>> Extend the IMA hook ima_measure_critical_data() to support passing
>> the data source label as an input parameter, so that the policy rule can
>> be used to limit the measurements based on the label.
>>
>> Signed-off-by: Tushar Sugandhi <[email protected]>
>
> Reviewed-by: Tyler Hicks <[email protected]>
>
> Tyler
>
Thanks for the review.
~Tushar
On 2020-12-10 3:22 p.m., Tyler Hicks wrote:
> On 2020-12-09 11:42:11, Tushar Sugandhi wrote:
>> From: Lakshmi Ramasubramanian <[email protected]>
>>
>> Define a new critical data builtin policy to allow measuring
>> early kernel integrity critical data before a custom IMA policy
>> is loaded.
>>
>> Add critical data to built-in IMA rules if the kernel command line
>> contains "ima_policy=critical_data".
>>
>> Update the documentation on kernel parameters to document
>> the new critical data builtin policy.
>>
>> Signed-off-by: Lakshmi Ramasubramanian <[email protected]>
>
> Reviewed-by: Tyler Hicks <[email protected]>
>
> Tyler
>
Thanks for the review.
~Tushar
On 2020-12-09 11:42:12, Tushar Sugandhi wrote:
> From: Lakshmi Ramasubramanian <[email protected]>
>
> IMA measures files and buffer data such as keys, command line arguments
> passed to the kernel on kexec system call, etc. While these measurements
> enable monitoring and validating the integrity of the system, it is not
> sufficient. Various data structures, policies and states stored in kernel
> memory also impact the integrity of the system. Updates to these data
> structures would have an impact on the security functionalities.
This is repetitive when looking at the entire series. I think it can be
dropped.
> For example, SELinux stores the active policy in memory. Changes to this
Start here and drop the "For example, ":
SELinux stores the active policy in memory and changes to this data ...
> data at runtime would have an impact on the security guarantees provided
> by SELinux. Measuring such in-memory data structures through IMA
> subsystem provides a secure way for a remote attestation service to
> know the state of the system and also the runtime changes in the state
> of the system.
>
> SELinux policy is a critical data for this security module that needs
SELinux policy is critical data and should be measured. This measurement ...
> to be measured. This measurement can be used by an attestation service,
> for instance, to verify if the policy has been setup correctly and that
> it hasn't been tampered at run-time.
>
> Measure the hash of the loaded policy by calling the IMA hook
> ima_measure_critical_data(). Since the size of the loaded policy can
> be large (several MB), measure the hash of the policy instead of
> the entire policy to avoid bloating the IMA log entry.
>
> Add "selinux" to the list of supported data sources maintained by IMA
> to enable measuring SELinux data.
>
> To enable SELinux data measurement, the following steps are required:
>
> 1, Add "ima_policy=critical_data" to the kernel command line arguments
> to enable measuring SELinux data at boot time.
> For example,
> BOOT_IMAGE=/boot/vmlinuz-5.10.0-rc1+ root=UUID=fd643309-a5d2-4ed3-b10d-3c579a5fab2f ro nomodeset security=selinux ima_policy=critical_data
>
> 2, Add the following rule to /etc/ima/ima-policy
> measure func=CRITICAL_DATA data_source=selinux
>
> Sample measurement of the hash of SELinux policy:
>
> To verify the measured data with the current SELinux policy run
> the following commands and verify the output hash values match.
>
> sha256sum /sys/fs/selinux/policy | cut -d' ' -f 1
>
> grep "selinux-policy-hash" /sys/kernel/security/integrity/ima/ascii_runtime_measurements | tail -1 | cut -d' ' -f 6
>
> Note that the actual verification of SELinux policy would require loading
> the expected policy into an identical kernel on a pristine/known-safe
> system and run the sha256sum /sys/kernel/selinux/policy there to get
> the expected hash.
>
> Signed-off-by: Lakshmi Ramasubramanian <[email protected]>
> Suggested-by: Stephen Smalley <[email protected]>
> ---
> Documentation/ABI/testing/ima_policy | 3 +-
> security/selinux/Makefile | 2 +
> security/selinux/include/security.h | 11 +++-
> security/selinux/measure.c | 86 ++++++++++++++++++++++++++++
> security/selinux/ss/services.c | 71 ++++++++++++++++++++---
> 5 files changed, 162 insertions(+), 11 deletions(-)
> create mode 100644 security/selinux/measure.c
>
> diff --git a/Documentation/ABI/testing/ima_policy b/Documentation/ABI/testing/ima_policy
> index 0f4ee9e0a455..7c7023f7986b 100644
> --- a/Documentation/ABI/testing/ima_policy
> +++ b/Documentation/ABI/testing/ima_policy
> @@ -52,8 +52,9 @@ Description:
> template:= name of a defined IMA template type
> (eg, ima-ng). Only valid when action is "measure".
> pcr:= decimal value
> - data_source:= [label]
> + data_source:= [selinux]|[label]
> label:= a unique string used for grouping and limiting critical data.
> + For example, "selinux" to measure critical data for SELinux.
>
> default policy:
> # PROC_SUPER_MAGIC
> diff --git a/security/selinux/Makefile b/security/selinux/Makefile
> index 4d8e0e8adf0b..83d512116341 100644
> --- a/security/selinux/Makefile
> +++ b/security/selinux/Makefile
> @@ -16,6 +16,8 @@ selinux-$(CONFIG_NETLABEL) += netlabel.o
>
> selinux-$(CONFIG_SECURITY_INFINIBAND) += ibpkey.o
>
> +selinux-$(CONFIG_IMA) += measure.o
> +
> ccflags-y := -I$(srctree)/security/selinux -I$(srctree)/security/selinux/include
>
> $(addprefix $(obj)/,$(selinux-y)): $(obj)/flask.h
> diff --git a/security/selinux/include/security.h b/security/selinux/include/security.h
> index 3cc8bab31ea8..18ee65c98446 100644
> --- a/security/selinux/include/security.h
> +++ b/security/selinux/include/security.h
> @@ -229,7 +229,8 @@ void selinux_policy_cancel(struct selinux_state *state,
> struct selinux_policy *policy);
> int security_read_policy(struct selinux_state *state,
> void **data, size_t *len);
> -
> +int security_read_policy_kernel(struct selinux_state *state,
> + void **data, size_t *len);
> int security_policycap_supported(struct selinux_state *state,
> unsigned int req_cap);
>
> @@ -446,4 +447,12 @@ extern void ebitmap_cache_init(void);
> extern void hashtab_cache_init(void);
> extern int security_sidtab_hash_stats(struct selinux_state *state, char *page);
>
> +#ifdef CONFIG_IMA
> +extern void selinux_measure_state(struct selinux_state *selinux_state);
> +#else
> +static inline void selinux_measure_state(struct selinux_state *selinux_state)
> +{
> +}
> +#endif
> +
> #endif /* _SELINUX_SECURITY_H_ */
> diff --git a/security/selinux/measure.c b/security/selinux/measure.c
> new file mode 100644
> index 000000000000..c409ada6ea39
> --- /dev/null
> +++ b/security/selinux/measure.c
> @@ -0,0 +1,86 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
> +/*
> + * Measure SELinux state using IMA subsystem.
> + */
> +#include <linux/vmalloc.h>
> +#include <linux/ktime.h>
> +#include <linux/ima.h>
> +#include "security.h"
> +
> +/*
> + * This function creates a unique name by appending the timestamp to
> + * the given string. This string is passed as "event_name" to the IMA
> + * hook to measure the given SELinux data.
> + *
> + * The data provided by SELinux to the IMA subsystem for measuring may have
> + * already been measured (for instance the same state existed earlier).
> + * But for SELinux the current data represents a state change and hence
> + * needs to be measured again. To enable this, pass a unique "event_name"
> + * to the IMA hook so that IMA subsystem will always measure the given data.
> + *
> + * For example,
> + * At time T0 SELinux data to be measured is "foo". IMA measures it.
> + * At time T1 the data is changed to "bar". IMA measures it.
> + * At time T2 the data is changed to "foo" again. IMA will not measure it
> + * (since it was already measured) unless the event_name, for instance,
> + * is different in this call.
> + */
> +static char *selinux_event_name(const char *name_prefix)
> +{
> + char *event_name = NULL;
> + struct timespec64 cur_time;
> +
> + ktime_get_real_ts64(&cur_time);
> + event_name = kasprintf(GFP_KERNEL, "%s-%lld:%09ld", name_prefix,
> + cur_time.tv_sec, cur_time.tv_nsec);
> + if (!event_name) {
> + pr_err("%s: event name not allocated.\n", __func__);
> + return NULL;
> + }
> +
> + return event_name;
> +}
> +
> +/*
> + * selinux_measure_state - Measure hash of the SELinux policy
> + *
> + * @state: selinux state struct
> + *
> + * NOTE: This function must be called with policy_mutex held.
> + */
> +void selinux_measure_state(struct selinux_state *state)
> +{
> + void *policy = NULL;
> + char *policy_event_name = NULL;
> + size_t policy_len;
> + int rc = 0;
> + bool initialized = selinux_initialized(state);
> +
> + /*
> + * Measure SELinux policy only after initialization is completed.
> + */
> + if (!initialized)
> + goto out;
> +
> + policy_event_name = selinux_event_name("selinux-policy-hash");
> + if (!policy_event_name) {
> + pr_err("%s: Event name for policy not allocated.\n",
> + __func__);
If the kasprintf() in selinux_event_name() fails, we'll get two similar
error messages saying that the event name could not be allocated. One of
these error messages can be removed.
> + rc = -ENOMEM;
> + goto out;
> + }
> +
> + rc = security_read_policy_kernel(state, &policy, &policy_len);
> + if (rc) {
> + pr_err("%s: Failed to read policy %d.\n", __func__, rc);
The calls to pr_err() in this aren't quite following the style of the
other error SELinux error messages.
$ git grep pr_err security/selinux
security/selinux/hooks.c: pr_err("SELinux: out of range capability %d\n", cap);
security/selinux/hooks.c: pr_err("SELinux: unable to map context to SID"
security/selinux/netlink.c: pr_err("SELinux: OOM in %s\n", __func__);
security/selinux/selinuxfs.c: pr_err("SELinux: Runtime disable is deprecated, use selinux=0 on the kernel cmdline.\n");
security/selinux/selinuxfs.c: pr_err("SELinux: failed to load policy booleans\n");
security/selinux/selinuxfs.c: pr_err("SELinux: failed to load policy classes\n");
...
security/selinux/ss/services.c: pr_err("SELinux: %s: unrecognized SID %d\n",
security/selinux/ss/services.c: pr_err("SELinux: %s: unrecognized SID %d\n",
security/selinux/ss/services.c: pr_err("SELinux: %s: unrecognized SID %d\n",
security/selinux/ss/services.c: pr_err("SELinux: %s: unrecognized SID %d\n",
security/selinux/ss/services.c: pr_err("SELinux: %s: unrecognized class %s\n",
Prepending your error message strings with "SELinux: " and lowercasing the
first character after "%s: " ought to do it.
All the other code changes in this patch look correct to me.
Tyler
> + goto out;
> + }
> +
> + ima_measure_critical_data("selinux", policy_event_name,
> + policy, policy_len, true);
> +
> + vfree(policy);
> +
> +out:
> + kfree(policy_event_name);
> +}
> diff --git a/security/selinux/ss/services.c b/security/selinux/ss/services.c
> index 9704c8a32303..dfa2e00894ae 100644
> --- a/security/selinux/ss/services.c
> +++ b/security/selinux/ss/services.c
> @@ -2180,6 +2180,7 @@ static void selinux_notify_policy_change(struct selinux_state *state,
> selinux_status_update_policyload(state, seqno);
> selinux_netlbl_cache_invalidate();
> selinux_xfrm_notify_policyload();
> + selinux_measure_state(state);
> }
>
> void selinux_policy_commit(struct selinux_state *state,
> @@ -3875,8 +3876,33 @@ int security_netlbl_sid_to_secattr(struct selinux_state *state,
> }
> #endif /* CONFIG_NETLABEL */
>
> +/**
> + * security_read_selinux_policy - read the policy.
> + * @policy: SELinux policy
> + * @data: binary policy data
> + * @len: length of data in bytes
> + *
> + */
> +static int security_read_selinux_policy(struct selinux_policy *policy,
> + void *data, size_t *len)
> +{
> + int rc;
> + struct policy_file fp;
> +
> + fp.data = data;
> + fp.len = *len;
> +
> + rc = policydb_write(&policy->policydb, &fp);
> + if (rc)
> + return rc;
> +
> + *len = (unsigned long)fp.data - (unsigned long)data;
> + return 0;
> +}
> +
> /**
> * security_read_policy - read the policy.
> + * @state: selinux_state
> * @data: binary policy data
> * @len: length of data in bytes
> *
> @@ -3885,8 +3911,6 @@ int security_read_policy(struct selinux_state *state,
> void **data, size_t *len)
> {
> struct selinux_policy *policy;
> - int rc;
> - struct policy_file fp;
>
> policy = rcu_dereference_protected(
> state->policy, lockdep_is_held(&state->policy_mutex));
> @@ -3898,14 +3922,43 @@ int security_read_policy(struct selinux_state *state,
> if (!*data)
> return -ENOMEM;
>
> - fp.data = *data;
> - fp.len = *len;
> + return security_read_selinux_policy(policy, *data, len);
> +}
>
> - rc = policydb_write(&policy->policydb, &fp);
> - if (rc)
> - return rc;
> +/**
> + * security_read_policy_kernel - read the policy.
> + * @state: selinux_state
> + * @data: binary policy data
> + * @len: length of data in bytes
> + *
> + * Allocates kernel memory for reading SELinux policy.
> + * This function is for internal use only and should not
> + * be used for returning data to user space.
> + *
> + * This function must be called with policy_mutex held.
> + */
> +int security_read_policy_kernel(struct selinux_state *state,
> + void **data, size_t *len)
> +{
> + struct selinux_policy *policy;
> + int rc = 0;
>
> - *len = (unsigned long)fp.data - (unsigned long)*data;
> - return 0;
> + policy = rcu_dereference_protected(
> + state->policy, lockdep_is_held(&state->policy_mutex));
> + if (!policy) {
> + rc = -EINVAL;
> + goto out;
> + }
> +
> + *len = policy->policydb.len;
> + *data = vmalloc(*len);
> + if (!*data) {
> + rc = -ENOMEM;
> + goto out;
> + }
>
> + rc = security_read_selinux_policy(policy, *data, len);
> +
> +out:
> + return rc;
> }
> --
> 2.17.1
>
On 12/11/20 7:41 AM, Tyler Hicks wrote:
> On 2020-12-11 09:36:30, Tyler Hicks wrote:
>> The calls to pr_err() in this aren't quite following the style of the
>> other error SELinux error messages.
>
> Sorry, I left out a word. I meant to say that the calls to pr_err() in
> this *file* aren't quite following the right style. Please adjust all of
> them.
>
> Thanks!
>
Thanks for reviewing the patch Tyler. I'll make the changes per your
comments.
-lakshmi