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