Merge branch 'validate-policy-rules' into next-integrity

From "ima: Fix rule parsing bugs and extend KEXEC_CMDLINE rule support" coverletter. This series ultimately extends the supported IMA rule conditionals for the KEXEC_CMDLINE hook function. As of today, there's an imbalance in IMA language conditional support for KEXEC_CMDLINE rules in comparison to KEXEC_KERNEL_CHECK and KEXEC_INITRAMFS_CHECK rules. The KEXEC_CMDLINE rules do not support *any* conditionals so you cannot have a sequence of rules like this: dont_measure func=KEXEC_KERNEL_CHECK obj_type=foo_t dont_measure func=KEXEC_INITRAMFS_CHECK obj_type=foo_t dont_measure func=KEXEC_CMDLINE obj_type=foo_t measure func=KEXEC_KERNEL_CHECK measure func=KEXEC_INITRAMFS_CHECK measure func=KEXEC_CMDLINE Instead, KEXEC_CMDLINE rules can only be measured or not measured and there's no additional flexibility in today's implementation of the KEXEC_CMDLINE hook function. With this series, the above sequence of rules becomes valid and any calls to kexec_file_load() with a kernel and initramfs inode type of foo_t will not be measured (that includes the kernel cmdline buffer) while all other objects given to a kexec_file_load() syscall will be measured. There's obviously not an inode directly associated with the kernel cmdline buffer but this patch series ties the inode based decision making for KEXEC_CMDLINE to the kernel's inode. I think this will be intuitive to policy authors. While reading IMA code and preparing to make this change, I realized that the buffer based hook functions (KEXEC_CMDLINE and KEY_CHECK) are quite special in comparison to longer standing hook functions. These buffer based hook functions can only support measure actions and there are some restrictions on the conditionals that they support. However, the rule parser isn't enforcing any of those restrictions and IMA policy authors wouldn't have any immediate way of knowing that the policy that they wrote is invalid. For example, the sequence of rules above parses successfully in today's kernel but the "dont_measure func=KEXEC_CMDLINE ..." rule is incorrectly handled in ima_match_rules(). The dont_measure rule is *always* considered to be a match so, surprisingly, no KEXEC_CMDLINE measurements are made. While making the rule parser more strict, I realized that the parser does not correctly free all of the allocated memory associated with an ima_rule_entry when going down some error paths. Invalid policy loaded by the policy administrator could result in small memory leaks.

Mimi Zohar committed 6 years ago

Commit a068d932 parents 34e980b 483417710 files · +184 −94Browse files

Unified · Split

10 files

include/linux/ima.h +2 −2
kernel/kexec_file.c +1 −1
security/integrity/ima/ima.h +6 −7
security/integrity/ima/ima_api.c +1 −1
security/integrity/ima/ima_appraise.c +1 −1
security/integrity/ima/ima_asymmetric_keys.c +1 −1
security/integrity/ima/ima_main.c +17 −6
security/integrity/ima/ima_modsig.c +0 −20
security/integrity/ima/ima_policy.c +154 −54
security/integrity/ima/ima_queue_keys.c +1 −1

include/linux/ima.h+2−2

@@ -25,7 +25,7 @@ extern int ima_post_read_file(struct file file, void buf, loff_t size, · 24 unmodified lines
25	enum kernel_read_file_id id);	25	enum kernel_read_file_id id);
26	extern void ima_post_path_mknod(struct dentry *dentry);	26	extern void ima_post_path_mknod(struct dentry *dentry);
27	extern int ima_file_hash(struct file file, char buf, size_t buf_size);	27	extern int ima_file_hash(struct file file, char buf, size_t buf_size);
28	extern void ima_kexec_cmdline(const void *buf, int size);	28	extern void ima_kexec_cmdline(int kernel_fd, const void *buf, int size);
29		29
30	#ifdef CONFIG_IMA_KEXEC	30	#ifdef CONFIG_IMA_KEXEC
31	extern void ima_add_kexec_buffer(struct kimage *image);	31	extern void ima_add_kexec_buffer(struct kimage *image);
@@ -103,7 +103,7 @@ static inline int ima_file_hash(struct file file, char buf, size_t buf_size) · 71 unmodified lines
103	return -EOPNOTSUPP;	103	return -EOPNOTSUPP;
104	}	104	}
105		105
106	static inline void ima_kexec_cmdline(const void *buf, int size) {}	106	static inline void ima_kexec_cmdline(int kernel_fd, const void *buf, int size) {}
107	#endif /* CONFIG_IMA */	107	#endif /* CONFIG_IMA */
108		108
109	#ifndef CONFIG_IMA_KEXEC	109	#ifndef CONFIG_IMA_KEXEC

kernel/kexec_file.c+1−1

@@ -287,7 +287,7 @@ kimage_file_prepare_segments(struct kimage *image, int kernel_fd, int initrd_fd, · 286 unmodified lines
287	goto out;	287	goto out;
288	}	288	}
289		289
290	ima_kexec_cmdline(image->cmdline_buf,	290	ima_kexec_cmdline(kernel_fd, image->cmdline_buf,
291	image->cmdline_buf_len - 1);	291	image->cmdline_buf_len - 1);
292	}	292	}
293		293

security/integrity/ima/ima.h+6−7

 			   struct evm_ima_xattr_data *xattr_value,
 			   int xattr_len, const struct modsig *modsig, int pcr,
 			   struct ima_template_desc *template_desc);
-void process_buffer_measurement(const void *buf, int size,
+void process_buffer_measurement(struct inode *inode, const void *buf, int size,
 				const char *eventname, enum ima_hooks func,
 				int pcr, const char *keyring);
 void ima_audit_measurement(struct integrity_iint_cache *iint,
 #endif /* CONFIG_IMA_APPRAISE */
 #ifdef CONFIG_IMA_APPRAISE_MODSIG
-bool ima_hook_supports_modsig(enum ima_hooks func);
 int ima_read_modsig(enum ima_hooks func, const void *buf, loff_t buf_len,
 		    struct modsig **modsig);
 void ima_collect_modsig(struct modsig *modsig, const void *buf, loff_t size);
 		       u32 *data_len);
 void ima_free_modsig(struct modsig *modsig);
 #else
-static inline bool ima_hook_supports_modsig(enum ima_hooks func)
-{
-	return false;
-}
 static inline int ima_read_modsig(enum ima_hooks func, const void *buf,
 				  loff_t buf_len, struct modsig **modsig)
 {
 #ifdef CONFIG_IMA_LSM_RULES
 #define security_filter_rule_init security_audit_rule_init
+#define security_filter_rule_free security_audit_rule_free
 #define security_filter_rule_match security_audit_rule_match
 #else
 	return -EINVAL;
 }
+static inline void security_filter_rule_free(void *lsmrule)
+{
+}
 static inline int security_filter_rule_match(u32 secid, u32 field, u32 op,
 					     void *lsmrule)
 {

security/integrity/ima/ima_api.c+1−1

@@ -162,7 +162,7 @@ err_out: · 161 unmodified lines
162		162
163	/**	163	/**
164	* ima_get_action - appraise & measure decision based on policy.	164	* ima_get_action - appraise & measure decision based on policy.
165	* @inode: pointer to inode to measure	165	* @inode: pointer to the inode associated with the object being validated
166	* @cred: pointer to credentials structure to validate	166	* @cred: pointer to credentials structure to validate
167	* @secid: secid of the task being validated	167	* @secid: secid of the task being validated
168	* @mask: contains the permission mask (MAY_READ, MAY_WRITE, MAY_EXEC,	168	* @mask: contains the permission mask (MAY_READ, MAY_WRITE, MAY_EXEC,

security/integrity/ima/ima_appraise.c+1−1

@@ -328,7 +328,7 @@ int ima_check_blacklist(struct integrity_iint_cache *iint, · 327 unmodified lines
328		328
329	rc = is_binary_blacklisted(digest, digestsize);	329	rc = is_binary_blacklisted(digest, digestsize);
330	if ((rc == -EPERM) && (iint->flags & IMA_MEASURE))	330	if ((rc == -EPERM) && (iint->flags & IMA_MEASURE))
331	process_buffer_measurement(digest, digestsize,	331	process_buffer_measurement(NULL, digest, digestsize,
332	"blacklisted-hash", NONE,	332	"blacklisted-hash", NONE,
333	pcr, NULL);	333	pcr, NULL);
334	}	334	}

security/integrity/ima/ima_asymmetric_keys.c+1−1

@@ -58,7 +58,7 @@ void ima_post_key_create_or_update(struct key keyring, struct key key, · 57 unmodified lines
58	* if the IMA policy is configured to measure a key linked	58	* if the IMA policy is configured to measure a key linked
59	* to the given keyring.	59	* to the given keyring.
60	*/	60	*/
61	process_buffer_measurement(payload, payload_len,	61	process_buffer_measurement(NULL, payload, payload_len,
62	keyring->description, KEY_CHECK, 0,	62	keyring->description, KEY_CHECK, 0,
63	keyring->description);	63	keyring->description);
64	}	64	}

security/integrity/ima/ima_main.c+17−6

@@ -726,6 +726,7 @@ int ima_load_data(enum kernel_load_data_id id) · 725 unmodified lines
726		726
727	/*	727	/*
728	* process_buffer_measurement - Measure the buffer to ima log.	728	* process_buffer_measurement - Measure the buffer to ima log.
		729	* @inode: inode associated with the object being measured (NULL for KEY_CHECK)
729	* @buf: pointer to the buffer that needs to be added to the log.	730	* @buf: pointer to the buffer that needs to be added to the log.
730	* @size: size of buffer(in bytes).	731	* @size: size of buffer(in bytes).
731	* @eventname: event name to be used for the buffer entry.	732	* @eventname: event name to be used for the buffer entry.
@@ -735,7 +736,7 @@ int ima_load_data(enum kernel_load_data_id id) · 3 unmodified lines
735	*	736	*
736	* Based on policy, the buffer is measured into the ima log.	737	* Based on policy, the buffer is measured into the ima log.
737	*/	738	*/
738	void process_buffer_measurement(const void *buf, int size,	739	void process_buffer_measurement(struct inode inode, const void buf, int size,
739	const char *eventname, enum ima_hooks func,	740	const char *eventname, enum ima_hooks func,
740	int pcr, const char *keyring)	741	int pcr, const char *keyring)
741	{	742	{
@@ -768,7 +769,7 @@ void process_buffer_measurement(const void *buf, int size, · 26 unmodified lines
768	*/	769	*/
769	if (func) {	770	if (func) {
770	security_task_getsecid(current, &secid);	771	security_task_getsecid(current, &secid);
771	action = ima_get_action(NULL, current_cred(), secid, 0, func,	772	action = ima_get_action(inode, current_cred(), secid, 0, func,
772	&pcr, &template, keyring);	773	&pcr, &template, keyring);
773	if (!(action & IMA_MEASURE))	774	if (!(action & IMA_MEASURE))
774	return;	775	return;
@@ -823,16 +824,26 @@ out: · 48 unmodified lines
823		824
824	/**	825	/**
825	* ima_kexec_cmdline - measure kexec cmdline boot args	826	* ima_kexec_cmdline - measure kexec cmdline boot args
		827	* @kernel_fd: file descriptor of the kexec kernel being loaded
826	* @buf: pointer to buffer	828	* @buf: pointer to buffer
827	* @size: size of buffer	829	* @size: size of buffer
828	*	830	*
829	* Buffers can only be measured, not appraised.	831	* Buffers can only be measured, not appraised.
830	*/	832	*/
831	void ima_kexec_cmdline(const void *buf, int size)	833	void ima_kexec_cmdline(int kernel_fd, const void *buf, int size)
832	{	834	{
833	if (buf && size != 0)	835	struct fd f;
834	process_buffer_measurement(buf, size, "kexec-cmdline",	836
835	KEXEC_CMDLINE, 0, NULL);	837	if (!buf \|\| !size)
		838	return;
		839
		840	f = fdget(kernel_fd);
		841	if (!f.file)
		842	return;
		843
		844	process_buffer_measurement(file_inode(f.file), buf, size,
		845	"kexec-cmdline", KEXEC_CMDLINE, 0, NULL);
		846	fdput(f);
836	}	847	}
837		848
838	static int __init init_ima(void)	849	static int __init init_ima(void)

security/integrity/ima/ima_modsig.c+0−20

@@ -32,26 +32,6 @@ struct modsig { · 31 unmodified lines
32	u8 raw_pkcs7[];	32	u8 raw_pkcs7[];
33	};	33	};
34		34
35	/**
36	* ima_hook_supports_modsig - can the policy allow modsig for this hook?
37	*
38	* modsig is only supported by hooks using ima_post_read_file(), because only
39	* they preload the contents of the file in a buffer. FILE_CHECK does that in
40	* some cases, but not when reached from vfs_open(). POLICY_CHECK can support
41	* it, but it's not useful in practice because it's a text file so deny.
42	*/
43	bool ima_hook_supports_modsig(enum ima_hooks func)
44	{
45	switch (func) {
46	case KEXEC_KERNEL_CHECK:
47	case KEXEC_INITRAMFS_CHECK:
48	case MODULE_CHECK:
49	return true;
50	default:
51	return false;
52	}
53	}
54
55	/*	35	/*
56	* ima_read_modsig - Read modsig from buf.	36	* ima_read_modsig - Read modsig from buf.
57	*	37	*

security/integrity/ima/ima_policy.c+154−54

 	int pcr;
 	struct {
 		void *rule;	/* LSM file metadata specific */
-		void *args_p;	/* audit value */
+		char *args_p;	/* audit value */
 		int type;	/* audit type */
 	} lsm[MAX_LSM_RULES];
 	char *fsname;
 	int i;
 	for (i = 0; i < MAX_LSM_RULES; i++) {
-		kfree(entry->lsm[i].rule);
+		security_filter_rule_free(entry->lsm[i].rule);
 		kfree(entry->lsm[i].args_p);
 	}
+}
+static void ima_free_rule(struct ima_rule_entry *entry)
+{
+	if (!entry)
+		return;
+	/*
+	 * entry->template->fields may be allocated in ima_parse_rule() but that
+	 * reference is owned by the corresponding ima_template_desc element in
+	 * the defined_templates list and cannot be freed here
+	 */
+	kfree(entry->fsname);
+	kfree(entry->keyrings);
+	ima_lsm_free_rule(entry);
 	kfree(entry);
 }
 			continue;
 		nentry->lsm[i].type = entry->lsm[i].type;
-		nentry->lsm[i].args_p = kstrdup(entry->lsm[i].args_p,
+		nentry->lsm[i].args_p = entry->lsm[i].args_p;
-						GFP_KERNEL);
+		/*
-		if (!nentry->lsm[i].args_p)
+		 * Remove the reference from entry so that the associated
-			goto out_err;
+		 * memory will not be freed during a later call to
+		 * ima_lsm_free_rule(entry).
+		 */
+		entry->lsm[i].args_p = NULL;
 		security_filter_rule_init(nentry->lsm[i].type,
 					  Audit_equal,
 					  &nentry->lsm[i].rule);
 		if (!nentry->lsm[i].rule)
 			pr_warn("rule for LSM \'%s\' is undefined\n",
-				(char *)entry->lsm[i].args_p);
+				nentry->lsm[i].args_p);
 	}
 	return nentry;
-out_err:
-	ima_lsm_free_rule(nentry);
-	return NULL;
 }
 static int ima_lsm_update_rule(struct ima_rule_entry *entry)
 	list_replace_rcu(&entry->list, &nentry->list);
 	synchronize_rcu();
+	/*
+	 * ima_lsm_copy_rule() shallow copied all references, except for the
+	 * LSM references, from entry to nentry so we only want to free the LSM
+	 * references and the entry itself. All other memory refrences will now
+	 * be owned by nentry.
+	 */
 	ima_lsm_free_rule(entry);
+	kfree(entry);
 	return 0;
 }
+static bool ima_rule_contains_lsm_cond(struct ima_rule_entry *entry)
+{
+	int i;
+	for (i = 0; i < MAX_LSM_RULES; i++)
+		if (entry->lsm[i].args_p)
+			return true;
+	return false;
+}
 /*
  * The LSM policy can be reloaded, leaving the IMA LSM based rules referring
  * to the old, stale LSM policy.  Update the IMA LSM based rules to reflect
 static void ima_lsm_update_rules(void)
 {
 	struct ima_rule_entry *entry, *e;
-	int i, result, needs_update;
+	int result;
 	list_for_each_entry_safe(entry, e, &ima_policy_rules, list) {
-		needs_update = 0;
+		if (!ima_rule_contains_lsm_cond(entry))
-		for (i = 0; i < MAX_LSM_RULES; i++) {
-			if (entry->lsm[i].args_p) {
-				needs_update = 1;
-				break;
-			}
-		}
-		if (!needs_update)
 			continue;
 		result = ima_lsm_update_rule(entry);
 {
 	int i;
-	if ((func == KEXEC_CMDLINE) || (func == KEY_CHECK)) {
+	if (func == KEY_CHECK) {
-		if ((rule->flags & IMA_FUNC) && (rule->func == func)) {
+		return (rule->flags & IMA_FUNC) && (rule->func == func) &&
-			if (func == KEY_CHECK)
+		       ima_match_keyring(rule, keyring, cred);
-				return ima_match_keyring(rule, keyring, cred);
-			return true;
-		}
-		return false;
 	}
 	if ((rule->flags & IMA_FUNC) &&
 	    (rule->func != func && func != POST_SETATTR))
 					   &entry->lsm[lsm_rule].rule);
 	if (!entry->lsm[lsm_rule].rule) {
 		pr_warn("rule for LSM \'%s\' is undefined\n",
-			(char *)entry->lsm[lsm_rule].args_p);
+			entry->lsm[lsm_rule].args_p);
 		if (ima_rules == &ima_default_rules) {
 			kfree(entry->lsm[lsm_rule].args_p);
+			entry->lsm[lsm_rule].args_p = NULL;
 			result = -EINVAL;
 		} else
 			result = 0;
 #undef MSG
 }
+static bool ima_validate_rule(struct ima_rule_entry *entry)
+{
+	/* Ensure that the action is set and is compatible with the flags */
+	if (entry->action == UNKNOWN)
+		return false;
+	if (entry->action != MEASURE && entry->flags & IMA_PCR)
+		return false;
+	if (entry->action != APPRAISE &&
+	    entry->flags & (IMA_DIGSIG_REQUIRED | IMA_MODSIG_ALLOWED | IMA_CHECK_BLACKLIST))
+		return false;
+	/*
+	 * The IMA_FUNC bit must be set if and only if there's a valid hook
+	 * function specified, and vice versa. Enforcing this property allows
+	 * for the NONE case below to validate a rule without an explicit hook
+	 * function.
+	 */
+	if (((entry->flags & IMA_FUNC) && entry->func == NONE) ||
+	    (!(entry->flags & IMA_FUNC) && entry->func != NONE))
+		return false;
+	/*
+	 * Ensure that the hook function is compatible with the other
+	 * components of the rule
+	 */
+	switch (entry->func) {
+	case NONE:
+	case FILE_CHECK:
+	case MMAP_CHECK:
+	case BPRM_CHECK:
+	case CREDS_CHECK:
+	case POST_SETATTR:
+	case FIRMWARE_CHECK:
+	case POLICY_CHECK:
+		if (entry->flags & ~(IMA_FUNC | IMA_MASK | IMA_FSMAGIC |
+				     IMA_UID | IMA_FOWNER | IMA_FSUUID |
+				     IMA_INMASK | IMA_EUID | IMA_PCR |
+				     IMA_FSNAME | IMA_DIGSIG_REQUIRED |
+				     IMA_PERMIT_DIRECTIO))
+			return false;
+		break;
+	case MODULE_CHECK:
+	case KEXEC_KERNEL_CHECK:
+	case KEXEC_INITRAMFS_CHECK:
+		if (entry->flags & ~(IMA_FUNC | IMA_MASK | IMA_FSMAGIC |
+				     IMA_UID | IMA_FOWNER | IMA_FSUUID |
+				     IMA_INMASK | IMA_EUID | IMA_PCR |
+				     IMA_FSNAME | IMA_DIGSIG_REQUIRED |
+				     IMA_PERMIT_DIRECTIO | IMA_MODSIG_ALLOWED |
+				     IMA_CHECK_BLACKLIST))
+			return false;
+		break;
+	case KEXEC_CMDLINE:
+		if (entry->action & ~(MEASURE | DONT_MEASURE))
+			return false;
+		if (entry->flags & ~(IMA_FUNC | IMA_FSMAGIC | IMA_UID |
+				     IMA_FOWNER | IMA_FSUUID | IMA_EUID |
+				     IMA_PCR | IMA_FSNAME))
+			return false;
+		break;
+	case KEY_CHECK:
+		if (entry->action & ~(MEASURE | DONT_MEASURE))
+			return false;
+		if (entry->flags & ~(IMA_FUNC | IMA_UID | IMA_PCR |
+				     IMA_KEYRINGS))
+			return false;
+		if (ima_rule_contains_lsm_cond(entry))
+			return false;
+		break;
+	default:
+		return false;
+	}
+	/* Ensure that combinations of flags are compatible with each other */
+	if (entry->flags & IMA_CHECK_BLACKLIST &&
+	    !(entry->flags & IMA_MODSIG_ALLOWED))
+		return false;
+	return true;
+}
 static int ima_parse_rule(char *rule, struct ima_rule_entry *entry)
 {
 	struct audit_buffer *ab;
 			keyrings_len = strlen(args[0].from) + 1;
 			if ((entry->keyrings) ||
-			    (entry->action != MEASURE) ||
-			    (entry->func != KEY_CHECK) ||
 			    (keyrings_len < 2)) {
 				result = -EINVAL;
 				break;
 						   AUDIT_SUBJ_TYPE);
 			break;
 		case Opt_appraise_type:
-			if (entry->action != APPRAISE) {
-				result = -EINVAL;
-				break;
-			}
 			ima_log_string(ab, "appraise_type", args[0].from);
 			if ((strcmp(args[0].from, "imasig")) == 0)
 				entry->flags |= IMA_DIGSIG_REQUIRED;
-			else if (ima_hook_supports_modsig(entry->func) &&
+			else if (IS_ENABLED(CONFIG_IMA_APPRAISE_MODSIG) &&
 				 strcmp(args[0].from, "imasig|modsig") == 0)
 				entry->flags |= IMA_DIGSIG_REQUIRED |
 						IMA_MODSIG_ALLOWED;
 			break;
 		case Opt_appraise_flag:
 			ima_log_string(ab, "appraise_flag", args[0].from);
-			if (strstr(args[0].from, "blacklist"))
+			if (IS_ENABLED(CONFIG_IMA_APPRAISE_MODSIG) &&
+			    strstr(args[0].from, "blacklist"))
 				entry->flags |= IMA_CHECK_BLACKLIST;
+			else
+				result = -EINVAL;
 			break;
 		case Opt_permit_directio:
 			entry->flags |= IMA_PERMIT_DIRECTIO;
 			break;
 		case Opt_pcr:
-			if (entry->action != MEASURE) {
-				result = -EINVAL;
-				break;
-			}
 			ima_log_string(ab, "pcr", args[0].from);
 			result = kstrtoint(args[0].from, 10, &entry->pcr);
 			break;
 		}
 	}
-	if (!result && (entry->action == UNKNOWN))
+	if (!result && !ima_validate_rule(entry))
 		result = -EINVAL;
 	else if (entry->action == APPRAISE)
 		temp_ima_appraise |= ima_appraise_flag(entry->func);
 	result = ima_parse_rule(p, entry);
 	if (result) {
-		kfree(entry);
+		ima_free_rule(entry);
 		integrity_audit_msg(AUDIT_INTEGRITY_STATUS, NULL,
 				    NULL, op, "invalid-policy", result,
 				    audit_info);
 void ima_delete_rules(void)
 {
 	struct ima_rule_entry *entry, *tmp;
-	int i;
 	temp_ima_appraise = 0;
 	list_for_each_entry_safe(entry, tmp, &ima_temp_rules, list) {
-		for (i = 0; i < MAX_LSM_RULES; i++)
-			kfree(entry->lsm[i].args_p);
 		list_del(&entry->list);
-		kfree(entry);
+		ima_free_rule(entry);
 	}
 }
 			switch (i) {
 			case LSM_OBJ_USER:
 				seq_printf(m, pt(Opt_obj_user),
-					   (char *)entry->lsm[i].args_p);
+					   entry->lsm[i].args_p);
 				break;
 			case LSM_OBJ_ROLE:
 				seq_printf(m, pt(Opt_obj_role),
-					   (char *)entry->lsm[i].args_p);
+					   entry->lsm[i].args_p);
 				break;
 			case LSM_OBJ_TYPE:
 				seq_printf(m, pt(Opt_obj_type),
-					   (char *)entry->lsm[i].args_p);
+					   entry->lsm[i].args_p);
 				break;
 			case LSM_SUBJ_USER:
 				seq_printf(m, pt(Opt_subj_user),
-					   (char *)entry->lsm[i].args_p);
+					   entry->lsm[i].args_p);
 				break;
 			case LSM_SUBJ_ROLE:
 				seq_printf(m, pt(Opt_subj_role),
-					   (char *)entry->lsm[i].args_p);
+					   entry->lsm[i].args_p);
 				break;
 			case LSM_SUBJ_TYPE:
 				seq_printf(m, pt(Opt_subj_type),
-					   (char *)entry->lsm[i].args_p);
+					   entry->lsm[i].args_p);
 				break;
 			}
 			seq_puts(m, " ");

security/integrity/ima/ima_queue_keys.c+1−1

@@ -158,7 +158,7 @@ void ima_process_queued_keys(void) · 157 unmodified lines
158		158
159	list_for_each_entry_safe(entry, tmp, &ima_keys, list) {	159	list_for_each_entry_safe(entry, tmp, &ima_keys, list) {
160	if (!timer_expired)	160	if (!timer_expired)
161	process_buffer_measurement(entry->payload,	161	process_buffer_measurement(NULL, entry->payload,
162	entry->payload_len,	162	entry->payload_len,
163	entry->keyring_name,	163	entry->keyring_name,
164	KEY_CHECK, 0,	164	KEY_CHECK, 0,

Merge branch 'validate-policy-rules' into next-integrity

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code