1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (C) 2010 IBM Corporation
4 * Copyright (c) 2019-2021, Linaro Limited
5 *
6 * See Documentation/security/keys/trusted-encrypted.rst
7 */
8
9 #include <keys/user-type.h>
10 #include <keys/trusted-type.h>
11 #include <keys/trusted_tee.h>
12 #include <keys/trusted_caam.h>
13 #include <keys/trusted_dcp.h>
14 #include <keys/trusted_tpm.h>
15 #include <linux/capability.h>
16 #include <linux/err.h>
17 #include <linux/init.h>
18 #include <linux/key-type.h>
19 #include <linux/module.h>
20 #include <linux/parser.h>
21 #include <linux/random.h>
22 #include <linux/rcupdate.h>
23 #include <linux/slab.h>
24 #include <linux/static_call.h>
25 #include <linux/string.h>
26 #include <linux/uaccess.h>
27
28 static char *trusted_rng = "default";
29 module_param_named(rng, trusted_rng, charp, 0);
30 MODULE_PARM_DESC(rng, "Select trusted key RNG");
31
32 static char *trusted_key_source;
33 module_param_named(source, trusted_key_source, charp, 0);
34 MODULE_PARM_DESC(source, "Select trusted keys source (tpm, tee, caam or dcp)");
35
36 static const struct trusted_key_source trusted_key_sources[] = {
37 #if defined(CONFIG_TRUSTED_KEYS_TPM)
38 { "tpm", &trusted_key_tpm_ops },
39 #endif
40 #if defined(CONFIG_TRUSTED_KEYS_TEE)
41 { "tee", &trusted_key_tee_ops },
42 #endif
43 #if defined(CONFIG_TRUSTED_KEYS_CAAM)
44 { "caam", &trusted_key_caam_ops },
45 #endif
46 #if defined(CONFIG_TRUSTED_KEYS_DCP)
47 { "dcp", &dcp_trusted_key_ops },
48 #endif
49 };
50
51 DEFINE_STATIC_CALL_NULL(trusted_key_seal, *trusted_key_sources[0].ops->seal);
52 DEFINE_STATIC_CALL_NULL(trusted_key_unseal,
53 *trusted_key_sources[0].ops->unseal);
54 DEFINE_STATIC_CALL_NULL(trusted_key_get_random,
55 *trusted_key_sources[0].ops->get_random);
56 static void (*trusted_key_exit)(void);
57 static unsigned char migratable;
58
59 enum {
60 Opt_err,
61 Opt_new, Opt_load, Opt_update,
62 };
63
64 static const match_table_t key_tokens = {
65 {Opt_new, "new"},
66 {Opt_load, "load"},
67 {Opt_update, "update"},
68 {Opt_err, NULL}
69 };
70
71 /*
72 * datablob_parse - parse the keyctl data and fill in the
73 * payload structure
74 *
75 * On success returns 0, otherwise -EINVAL.
76 */
datablob_parse(char ** datablob,struct trusted_key_payload * p)77 static int datablob_parse(char **datablob, struct trusted_key_payload *p)
78 {
79 substring_t args[MAX_OPT_ARGS];
80 long keylen;
81 int ret = -EINVAL;
82 int key_cmd;
83 char *c;
84
85 /* main command */
86 c = strsep(datablob, " \t");
87 if (!c)
88 return -EINVAL;
89 key_cmd = match_token(c, key_tokens, args);
90 switch (key_cmd) {
91 case Opt_new:
92 /* first argument is key size */
93 c = strsep(datablob, " \t");
94 if (!c)
95 return -EINVAL;
96 ret = kstrtol(c, 10, &keylen);
97 if (ret < 0 || keylen < MIN_KEY_SIZE || keylen > MAX_KEY_SIZE)
98 return -EINVAL;
99 p->key_len = keylen;
100 ret = Opt_new;
101 break;
102 case Opt_load:
103 /* first argument is sealed blob */
104 c = strsep(datablob, " \t");
105 if (!c)
106 return -EINVAL;
107 p->blob_len = strlen(c) / 2;
108 if (p->blob_len > MAX_BLOB_SIZE)
109 return -EINVAL;
110 ret = hex2bin(p->blob, c, p->blob_len);
111 if (ret < 0)
112 return -EINVAL;
113 ret = Opt_load;
114 break;
115 case Opt_update:
116 ret = Opt_update;
117 break;
118 case Opt_err:
119 return -EINVAL;
120 }
121 return ret;
122 }
123
trusted_payload_alloc(struct key * key)124 static struct trusted_key_payload *trusted_payload_alloc(struct key *key)
125 {
126 struct trusted_key_payload *p = NULL;
127 int ret;
128
129 ret = key_payload_reserve(key, sizeof(*p));
130 if (ret < 0)
131 goto err;
132 p = kzalloc(sizeof(*p), GFP_KERNEL);
133 if (!p)
134 goto err;
135
136 p->migratable = migratable;
137 err:
138 return p;
139 }
140
141 /*
142 * trusted_instantiate - create a new trusted key
143 *
144 * Unseal an existing trusted blob or, for a new key, get a
145 * random key, then seal and create a trusted key-type key,
146 * adding it to the specified keyring.
147 *
148 * On success, return 0. Otherwise return errno.
149 */
trusted_instantiate(struct key * key,struct key_preparsed_payload * prep)150 static int trusted_instantiate(struct key *key,
151 struct key_preparsed_payload *prep)
152 {
153 struct trusted_key_payload *payload = NULL;
154 size_t datalen = prep->datalen;
155 char *datablob, *orig_datablob;
156 int ret = 0;
157 int key_cmd;
158 size_t key_len;
159
160 if (datalen <= 0 || datalen > 32767 || !prep->data)
161 return -EINVAL;
162
163 orig_datablob = datablob = kmalloc(datalen + 1, GFP_KERNEL);
164 if (!datablob)
165 return -ENOMEM;
166 memcpy(datablob, prep->data, datalen);
167 datablob[datalen] = '\0';
168
169 payload = trusted_payload_alloc(key);
170 if (!payload) {
171 ret = -ENOMEM;
172 goto out;
173 }
174
175 key_cmd = datablob_parse(&datablob, payload);
176 if (key_cmd < 0) {
177 ret = key_cmd;
178 goto out;
179 }
180
181 dump_payload(payload);
182
183 switch (key_cmd) {
184 case Opt_load:
185 ret = static_call(trusted_key_unseal)(payload, datablob);
186 dump_payload(payload);
187 if (ret < 0)
188 pr_info("key_unseal failed (%d)\n", ret);
189 break;
190 case Opt_new:
191 key_len = payload->key_len;
192 ret = static_call(trusted_key_get_random)(payload->key,
193 key_len);
194 if (ret < 0)
195 goto out;
196
197 if (ret != key_len) {
198 pr_info("key_create failed (%d)\n", ret);
199 ret = -EIO;
200 goto out;
201 }
202
203 ret = static_call(trusted_key_seal)(payload, datablob);
204 if (ret < 0)
205 pr_info("key_seal failed (%d)\n", ret);
206 break;
207 default:
208 ret = -EINVAL;
209 }
210 out:
211 kfree_sensitive(orig_datablob);
212 if (!ret)
213 rcu_assign_keypointer(key, payload);
214 else
215 kfree_sensitive(payload);
216 return ret;
217 }
218
trusted_rcu_free(struct rcu_head * rcu)219 static void trusted_rcu_free(struct rcu_head *rcu)
220 {
221 struct trusted_key_payload *p;
222
223 p = container_of(rcu, struct trusted_key_payload, rcu);
224 kfree_sensitive(p);
225 }
226
227 /*
228 * trusted_update - reseal an existing key with new PCR values
229 */
trusted_update(struct key * key,struct key_preparsed_payload * prep)230 static int trusted_update(struct key *key, struct key_preparsed_payload *prep)
231 {
232 struct trusted_key_payload *p;
233 struct trusted_key_payload *new_p;
234 size_t datalen = prep->datalen;
235 char *datablob, *orig_datablob;
236 int ret = 0;
237
238 if (key_is_negative(key))
239 return -ENOKEY;
240 p = key->payload.data[0];
241 if (!p->migratable)
242 return -EPERM;
243 if (datalen <= 0 || datalen > 32767 || !prep->data)
244 return -EINVAL;
245
246 orig_datablob = datablob = kmalloc(datalen + 1, GFP_KERNEL);
247 if (!datablob)
248 return -ENOMEM;
249
250 new_p = trusted_payload_alloc(key);
251 if (!new_p) {
252 ret = -ENOMEM;
253 goto out;
254 }
255
256 memcpy(datablob, prep->data, datalen);
257 datablob[datalen] = '\0';
258 ret = datablob_parse(&datablob, new_p);
259 if (ret != Opt_update) {
260 ret = -EINVAL;
261 kfree_sensitive(new_p);
262 goto out;
263 }
264
265 /* copy old key values, and reseal with new pcrs */
266 new_p->migratable = p->migratable;
267 new_p->key_len = p->key_len;
268 memcpy(new_p->key, p->key, p->key_len);
269 dump_payload(p);
270 dump_payload(new_p);
271
272 ret = static_call(trusted_key_seal)(new_p, datablob);
273 if (ret < 0) {
274 pr_info("key_seal failed (%d)\n", ret);
275 kfree_sensitive(new_p);
276 goto out;
277 }
278
279 rcu_assign_keypointer(key, new_p);
280 call_rcu(&p->rcu, trusted_rcu_free);
281 out:
282 kfree_sensitive(orig_datablob);
283 return ret;
284 }
285
286 /*
287 * trusted_read - copy the sealed blob data to userspace in hex.
288 * On success, return to userspace the trusted key datablob size.
289 */
trusted_read(const struct key * key,char * buffer,size_t buflen)290 static long trusted_read(const struct key *key, char *buffer,
291 size_t buflen)
292 {
293 const struct trusted_key_payload *p;
294 char *bufp;
295 int i;
296
297 p = dereference_key_locked(key);
298 if (!p)
299 return -EINVAL;
300
301 if (buffer && buflen >= 2 * p->blob_len) {
302 bufp = buffer;
303 for (i = 0; i < p->blob_len; i++)
304 bufp = hex_byte_pack(bufp, p->blob[i]);
305 }
306 return 2 * p->blob_len;
307 }
308
309 /*
310 * trusted_destroy - clear and free the key's payload
311 */
trusted_destroy(struct key * key)312 static void trusted_destroy(struct key *key)
313 {
314 kfree_sensitive(key->payload.data[0]);
315 }
316
317 struct key_type key_type_trusted = {
318 .name = "trusted",
319 .instantiate = trusted_instantiate,
320 .update = trusted_update,
321 .destroy = trusted_destroy,
322 .describe = user_describe,
323 .read = trusted_read,
324 };
325 EXPORT_SYMBOL_GPL(key_type_trusted);
326
kernel_get_random(unsigned char * key,size_t key_len)327 static int kernel_get_random(unsigned char *key, size_t key_len)
328 {
329 return get_random_bytes_wait(key, key_len) ?: key_len;
330 }
331
init_trusted(void)332 static int __init init_trusted(void)
333 {
334 int (*get_random)(unsigned char *key, size_t key_len);
335 int i, ret = 0;
336
337 for (i = 0; i < ARRAY_SIZE(trusted_key_sources); i++) {
338 if (trusted_key_source &&
339 strncmp(trusted_key_source, trusted_key_sources[i].name,
340 strlen(trusted_key_sources[i].name)))
341 continue;
342
343 /*
344 * We always support trusted.rng="kernel" and "default" as
345 * well as trusted.rng=$trusted.source if the trust source
346 * defines its own get_random callback.
347 */
348 get_random = trusted_key_sources[i].ops->get_random;
349 if (trusted_rng && strcmp(trusted_rng, "default")) {
350 if (!strcmp(trusted_rng, "kernel")) {
351 get_random = kernel_get_random;
352 } else if (strcmp(trusted_rng, trusted_key_sources[i].name) ||
353 !get_random) {
354 pr_warn("Unsupported RNG. Supported: kernel");
355 if (get_random)
356 pr_cont(", %s", trusted_key_sources[i].name);
357 pr_cont(", default\n");
358 return -EINVAL;
359 }
360 }
361
362 if (!get_random)
363 get_random = kernel_get_random;
364
365 ret = trusted_key_sources[i].ops->init();
366 if (!ret) {
367 static_call_update(trusted_key_seal, trusted_key_sources[i].ops->seal);
368 static_call_update(trusted_key_unseal, trusted_key_sources[i].ops->unseal);
369 static_call_update(trusted_key_get_random, get_random);
370
371 trusted_key_exit = trusted_key_sources[i].ops->exit;
372 migratable = trusted_key_sources[i].ops->migratable;
373 }
374
375 if (!ret || ret != -ENODEV)
376 break;
377 }
378
379 /*
380 * encrypted_keys.ko depends on successful load of this module even if
381 * trusted key implementation is not found.
382 */
383 if (ret == -ENODEV)
384 return 0;
385
386 return ret;
387 }
388
cleanup_trusted(void)389 static void __exit cleanup_trusted(void)
390 {
391 if (trusted_key_exit)
392 (*trusted_key_exit)();
393 }
394
395 late_initcall(init_trusted);
396 module_exit(cleanup_trusted);
397
398 MODULE_DESCRIPTION("Trusted Key type");
399 MODULE_LICENSE("GPL");
400