forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c 
 kernel/security/integrity/digsig.c
....@@ -1,21 +1,16 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
12 /*
23  * Copyright (C) 2011 Intel Corporation
34  *
45  * Author:
56  * Dmitry Kasatkin <dmitry.kasatkin@intel.com>
6
- *
7
- * This program is free software; you can redistribute it and/or modify
8
- * it under the terms of the GNU General Public License as published by
9
- * the Free Software Foundation, version 2 of the License.
10
- *
117  */
12
-
13
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
148 
159 #include <linux/err.h>
1610 #include <linux/sched.h>
1711 #include <linux/slab.h>
1812 #include <linux/cred.h>
13
+#include <linux/kernel_read_file.h>
1914 #include <linux/key-type.h>
2015 #include <linux/digsig.h>
2116 #include <linux/vmalloc.h>
....@@ -26,7 +21,7 @@
2621 
2722 static struct key *keyring[INTEGRITY_KEYRING_MAX];
2823 
29
-static const char *keyring_name[INTEGRITY_KEYRING_MAX] = {
24
+static const char * const keyring_name[INTEGRITY_KEYRING_MAX] = {
3025 #ifndef CONFIG_INTEGRITY_TRUSTED_KEYRING
3126 	"_evm",
3227 	"_ima",
....@@ -34,14 +29,8 @@
3429 	".evm",
3530 	".ima",
3631 #endif
37
-	"_module",
32
+	".platform",
3833 };
39
-
40
-#ifdef CONFIG_INTEGRITY_TRUSTED_KEYRING
41
-static bool init_keyring __initdata = true;
42
-#else
43
-static bool init_keyring __initdata;
44
-#endif
4534 
4635 #ifdef CONFIG_IMA_KEYRINGS_PERMIT_SIGNED_BY_BUILTIN_OR_SECONDARY
4736 #define restrict_link_to_ima restrict_link_by_builtin_and_secondary_trusted
....@@ -49,11 +38,10 @@
4938 #define restrict_link_to_ima restrict_link_by_builtin_trusted
5039 #endif
5140 
52
-int integrity_digsig_verify(const unsigned int id, const char *sig, int siglen,
53
-			    const char *digest, int digestlen)
41
+static struct key *integrity_keyring_from_id(const unsigned int id)
5442 {
55
-	if (id >= INTEGRITY_KEYRING_MAX || siglen < 2)
56
-		return -EINVAL;
43
+	if (id >= INTEGRITY_KEYRING_MAX)
44
+		return ERR_PTR(-EINVAL);
5745 
5846 	if (!keyring[id]) {
5947 		keyring[id] =
....@@ -62,30 +50,87 @@
6250 			int err = PTR_ERR(keyring[id]);
6351 			pr_err("no %s keyring: %d\n", keyring_name[id], err);
6452 			keyring[id] = NULL;
65
-			return err;
53
+			return ERR_PTR(err);
6654 		}
6755 	}
56
+
57
+	return keyring[id];
58
+}
59
+
60
+int integrity_digsig_verify(const unsigned int id, const char *sig, int siglen,
61
+			    const char *digest, int digestlen)
62
+{
63
+	struct key *keyring;
64
+
65
+	if (siglen < 2)
66
+		return -EINVAL;
67
+
68
+	keyring = integrity_keyring_from_id(id);
69
+	if (IS_ERR(keyring))
70
+		return PTR_ERR(keyring);
6871 
6972 	switch (sig[1]) {
7073 	case 1:
7174 		/* v1 API expect signature without xattr type */
72
-		return digsig_verify(keyring[id], sig + 1, siglen - 1,
73
-				     digest, digestlen);
75
+		return digsig_verify(keyring, sig + 1, siglen - 1, digest,
76
+				     digestlen);
7477 	case 2:
75
-		return asymmetric_verify(keyring[id], sig, siglen,
76
-					 digest, digestlen);
78
+		return asymmetric_verify(keyring, sig, siglen, digest,
79
+					 digestlen);
7780 	}
7881 
7982 	return -EOPNOTSUPP;
8083 }
8184 
82
-int __init integrity_init_keyring(const unsigned int id)
85
+int integrity_modsig_verify(const unsigned int id, const struct modsig *modsig)
86
+{
87
+	struct key *keyring;
88
+
89
+	keyring = integrity_keyring_from_id(id);
90
+	if (IS_ERR(keyring))
91
+		return PTR_ERR(keyring);
92
+
93
+	return ima_modsig_verify(keyring, modsig);
94
+}
95
+
96
+static int __init __integrity_init_keyring(const unsigned int id,
97
+					   key_perm_t perm,
98
+					   struct key_restriction *restriction)
8399 {
84100 	const struct cred *cred = current_cred();
85
-	struct key_restriction *restriction;
86101 	int err = 0;
87102 
88
-	if (!init_keyring)
103
+	keyring[id] = keyring_alloc(keyring_name[id], KUIDT_INIT(0),
104
+				    KGIDT_INIT(0), cred, perm,
105
+				    KEY_ALLOC_NOT_IN_QUOTA, restriction, NULL);
106
+	if (IS_ERR(keyring[id])) {
107
+		err = PTR_ERR(keyring[id]);
108
+		pr_info("Can't allocate %s keyring (%d)\n",
109
+			keyring_name[id], err);
110
+		keyring[id] = NULL;
111
+	} else {
112
+		if (id == INTEGRITY_KEYRING_PLATFORM)
113
+			set_platform_trusted_keys(keyring[id]);
114
+	}
115
+
116
+	return err;
117
+}
118
+
119
+int __init integrity_init_keyring(const unsigned int id)
120
+{
121
+	struct key_restriction *restriction;
122
+	key_perm_t perm;
123
+	int ret;
124
+
125
+	perm = (KEY_POS_ALL & ~KEY_POS_SETATTR) | KEY_USR_VIEW
126
+		| KEY_USR_READ | KEY_USR_SEARCH;
127
+
128
+	if (id == INTEGRITY_KEYRING_PLATFORM) {
129
+		restriction = NULL;
130
+		goto out;
131
+	}
132
+
133
+	if (!IS_ENABLED(CONFIG_INTEGRITY_TRUSTED_KEYRING))
89134 		return 0;
90135 
91136 	restriction = kzalloc(sizeof(struct key_restriction), GFP_KERNEL);
....@@ -93,57 +138,70 @@
93138 		return -ENOMEM;
94139 
95140 	restriction->check = restrict_link_to_ima;
141
+	perm |= KEY_USR_WRITE;
96142 
97
-	keyring[id] = keyring_alloc(keyring_name[id], KUIDT_INIT(0),
98
-				    KGIDT_INIT(0), cred,
99
-				    ((KEY_POS_ALL & ~KEY_POS_SETATTR) |
100
-				     KEY_USR_VIEW | KEY_USR_READ |
101
-				     KEY_USR_WRITE | KEY_USR_SEARCH),
102
-				    KEY_ALLOC_NOT_IN_QUOTA,
103
-				    restriction, NULL);
104
-	if (IS_ERR(keyring[id])) {
105
-		err = PTR_ERR(keyring[id]);
106
-		pr_info("Can't allocate %s keyring (%d)\n",
107
-			keyring_name[id], err);
108
-		keyring[id] = NULL;
109
-	}
110
-	return err;
143
+out:
144
+	ret = __integrity_init_keyring(id, perm, restriction);
145
+	if (ret)
146
+		kfree(restriction);
147
+	return ret;
111148 }
112149 
113
-int __init integrity_load_x509(const unsigned int id, const char *path)
150
+int __init integrity_add_key(const unsigned int id, const void *data,
151
+			     off_t size, key_perm_t perm)
114152 {
115153 	key_ref_t key;
116
-	void *data;
117
-	loff_t size;
118
-	int rc;
154
+	int rc = 0;
119155 
120156 	if (!keyring[id])
121157 		return -EINVAL;
122158 
123
-	rc = kernel_read_file_from_path(path, &data, &size, 0,
159
+	key = key_create_or_update(make_key_ref(keyring[id], 1), "asymmetric",
160
+				   NULL, data, size, perm,
161
+				   KEY_ALLOC_NOT_IN_QUOTA);
162
+	if (IS_ERR(key)) {
163
+		rc = PTR_ERR(key);
164
+		pr_err("Problem loading X.509 certificate %d\n", rc);
165
+	} else {
166
+		pr_notice("Loaded X.509 cert '%s'\n",
167
+			  key_ref_to_ptr(key)->description);
168
+		key_ref_put(key);
169
+	}
170
+
171
+	return rc;
172
+
173
+}
174
+
175
+int __init integrity_load_x509(const unsigned int id, const char *path)
176
+{
177
+	void *data = NULL;
178
+	size_t size;
179
+	int rc;
180
+	key_perm_t perm;
181
+
182
+	rc = kernel_read_file_from_path(path, 0, &data, INT_MAX, NULL,
124183 					READING_X509_CERTIFICATE);
125184 	if (rc < 0) {
126185 		pr_err("Unable to open file: %s (%d)", path, rc);
127186 		return rc;
128187 	}
188
+	size = rc;
129189 
130
-	key = key_create_or_update(make_key_ref(keyring[id], 1),
131
-				   "asymmetric",
132
-				   NULL,
133
-				   data,
134
-				   size,
135
-				   ((KEY_POS_ALL & ~KEY_POS_SETATTR) |
136
-				    KEY_USR_VIEW | KEY_USR_READ),
137
-				   KEY_ALLOC_NOT_IN_QUOTA);
138
-	if (IS_ERR(key)) {
139
-		rc = PTR_ERR(key);
140
-		pr_err("Problem loading X.509 certificate (%d): %s\n",
141
-		       rc, path);
142
-	} else {
143
-		pr_notice("Loaded X.509 cert '%s': %s\n",
144
-			  key_ref_to_ptr(key)->description, path);
145
-		key_ref_put(key);
146
-	}
190
+	perm = (KEY_POS_ALL & ~KEY_POS_SETATTR) | KEY_USR_VIEW | KEY_USR_READ;
191
+
192
+	pr_info("Loading X.509 certificate: %s\n", path);
193
+	rc = integrity_add_key(id, (const void *)data, size, perm);
194
+
147195 	vfree(data);
148
-	return 0;
196
+	return rc;
197
+}
198
+
199
+int __init integrity_load_cert(const unsigned int id, const char *source,
200
+			       const void *data, size_t len, key_perm_t perm)
201
+{
202
+	if (!data)
203
+		return -EINVAL;
204
+
205
+	pr_info("Loading X.509 certificate: %s\n", source);
206
+	return integrity_add_key(id, data, len, perm);
149207 }