Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2010 IBM Corporation |
| 3 | * |
| 4 | * Author: |
| 5 | * David Safford <safford@us.ibm.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 | * |
Randy Dunlap | d410fa4 | 2011-05-19 15:59:38 -0700 | [diff] [blame] | 11 | * See Documentation/security/keys-trusted-encrypted.txt |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 12 | */ |
| 13 | |
| 14 | #include <linux/uaccess.h> |
| 15 | #include <linux/module.h> |
| 16 | #include <linux/init.h> |
| 17 | #include <linux/slab.h> |
| 18 | #include <linux/parser.h> |
| 19 | #include <linux/string.h> |
Mimi Zohar | 93ae86e | 2010-11-29 16:20:04 -0500 | [diff] [blame] | 20 | #include <linux/err.h> |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 21 | #include <keys/user-type.h> |
| 22 | #include <keys/trusted-type.h> |
| 23 | #include <linux/key-type.h> |
| 24 | #include <linux/rcupdate.h> |
| 25 | #include <linux/crypto.h> |
| 26 | #include <crypto/hash.h> |
| 27 | #include <crypto/sha.h> |
| 28 | #include <linux/capability.h> |
| 29 | #include <linux/tpm.h> |
| 30 | #include <linux/tpm_command.h> |
| 31 | |
Mimi Zohar | 4b174b6 | 2011-01-18 09:07:11 -0500 | [diff] [blame] | 32 | #include "trusted.h" |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 33 | |
| 34 | static const char hmac_alg[] = "hmac(sha1)"; |
| 35 | static const char hash_alg[] = "sha1"; |
| 36 | |
| 37 | struct sdesc { |
| 38 | struct shash_desc shash; |
| 39 | char ctx[]; |
| 40 | }; |
| 41 | |
| 42 | static struct crypto_shash *hashalg; |
| 43 | static struct crypto_shash *hmacalg; |
| 44 | |
| 45 | static struct sdesc *init_sdesc(struct crypto_shash *alg) |
| 46 | { |
| 47 | struct sdesc *sdesc; |
| 48 | int size; |
| 49 | |
| 50 | size = sizeof(struct shash_desc) + crypto_shash_descsize(alg); |
| 51 | sdesc = kmalloc(size, GFP_KERNEL); |
| 52 | if (!sdesc) |
| 53 | return ERR_PTR(-ENOMEM); |
| 54 | sdesc->shash.tfm = alg; |
| 55 | sdesc->shash.flags = 0x0; |
| 56 | return sdesc; |
| 57 | } |
| 58 | |
Mimi Zohar | 1bdbb40 | 2010-12-13 16:53:11 -0500 | [diff] [blame] | 59 | static int TSS_sha1(const unsigned char *data, unsigned int datalen, |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 60 | unsigned char *digest) |
| 61 | { |
| 62 | struct sdesc *sdesc; |
| 63 | int ret; |
| 64 | |
| 65 | sdesc = init_sdesc(hashalg); |
| 66 | if (IS_ERR(sdesc)) { |
| 67 | pr_info("trusted_key: can't alloc %s\n", hash_alg); |
| 68 | return PTR_ERR(sdesc); |
| 69 | } |
| 70 | |
| 71 | ret = crypto_shash_digest(&sdesc->shash, data, datalen, digest); |
| 72 | kfree(sdesc); |
| 73 | return ret; |
| 74 | } |
| 75 | |
| 76 | static int TSS_rawhmac(unsigned char *digest, const unsigned char *key, |
Mimi Zohar | 1bdbb40 | 2010-12-13 16:53:11 -0500 | [diff] [blame] | 77 | unsigned int keylen, ...) |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 78 | { |
| 79 | struct sdesc *sdesc; |
| 80 | va_list argp; |
| 81 | unsigned int dlen; |
| 82 | unsigned char *data; |
| 83 | int ret; |
| 84 | |
| 85 | sdesc = init_sdesc(hmacalg); |
| 86 | if (IS_ERR(sdesc)) { |
| 87 | pr_info("trusted_key: can't alloc %s\n", hmac_alg); |
| 88 | return PTR_ERR(sdesc); |
| 89 | } |
| 90 | |
| 91 | ret = crypto_shash_setkey(hmacalg, key, keylen); |
| 92 | if (ret < 0) |
| 93 | goto out; |
| 94 | ret = crypto_shash_init(&sdesc->shash); |
| 95 | if (ret < 0) |
| 96 | goto out; |
| 97 | |
| 98 | va_start(argp, keylen); |
| 99 | for (;;) { |
| 100 | dlen = va_arg(argp, unsigned int); |
| 101 | if (dlen == 0) |
| 102 | break; |
| 103 | data = va_arg(argp, unsigned char *); |
Tetsuo Handa | 35576ea | 2011-01-17 09:22:47 +0900 | [diff] [blame] | 104 | if (data == NULL) { |
| 105 | ret = -EINVAL; |
| 106 | break; |
| 107 | } |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 108 | ret = crypto_shash_update(&sdesc->shash, data, dlen); |
| 109 | if (ret < 0) |
Tetsuo Handa | 35576ea | 2011-01-17 09:22:47 +0900 | [diff] [blame] | 110 | break; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 111 | } |
| 112 | va_end(argp); |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 113 | if (!ret) |
| 114 | ret = crypto_shash_final(&sdesc->shash, digest); |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 115 | out: |
| 116 | kfree(sdesc); |
| 117 | return ret; |
| 118 | } |
| 119 | |
| 120 | /* |
| 121 | * calculate authorization info fields to send to TPM |
| 122 | */ |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 123 | static int TSS_authhmac(unsigned char *digest, const unsigned char *key, |
Mimi Zohar | 1bdbb40 | 2010-12-13 16:53:11 -0500 | [diff] [blame] | 124 | unsigned int keylen, unsigned char *h1, |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 125 | unsigned char *h2, unsigned char h3, ...) |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 126 | { |
| 127 | unsigned char paramdigest[SHA1_DIGEST_SIZE]; |
| 128 | struct sdesc *sdesc; |
| 129 | unsigned int dlen; |
| 130 | unsigned char *data; |
| 131 | unsigned char c; |
| 132 | int ret; |
| 133 | va_list argp; |
| 134 | |
| 135 | sdesc = init_sdesc(hashalg); |
| 136 | if (IS_ERR(sdesc)) { |
| 137 | pr_info("trusted_key: can't alloc %s\n", hash_alg); |
| 138 | return PTR_ERR(sdesc); |
| 139 | } |
| 140 | |
| 141 | c = h3; |
| 142 | ret = crypto_shash_init(&sdesc->shash); |
| 143 | if (ret < 0) |
| 144 | goto out; |
| 145 | va_start(argp, h3); |
| 146 | for (;;) { |
| 147 | dlen = va_arg(argp, unsigned int); |
| 148 | if (dlen == 0) |
| 149 | break; |
| 150 | data = va_arg(argp, unsigned char *); |
Tetsuo Handa | 0e7491f | 2011-01-17 09:25:34 +0900 | [diff] [blame] | 151 | if (!data) { |
| 152 | ret = -EINVAL; |
Tetsuo Handa | 154a96b | 2011-01-17 09:27:27 +0900 | [diff] [blame] | 153 | break; |
Tetsuo Handa | 0e7491f | 2011-01-17 09:25:34 +0900 | [diff] [blame] | 154 | } |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 155 | ret = crypto_shash_update(&sdesc->shash, data, dlen); |
Tetsuo Handa | 154a96b | 2011-01-17 09:27:27 +0900 | [diff] [blame] | 156 | if (ret < 0) |
| 157 | break; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 158 | } |
| 159 | va_end(argp); |
Tetsuo Handa | 154a96b | 2011-01-17 09:27:27 +0900 | [diff] [blame] | 160 | if (!ret) |
| 161 | ret = crypto_shash_final(&sdesc->shash, paramdigest); |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 162 | if (!ret) |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 163 | ret = TSS_rawhmac(digest, key, keylen, SHA1_DIGEST_SIZE, |
| 164 | paramdigest, TPM_NONCE_SIZE, h1, |
| 165 | TPM_NONCE_SIZE, h2, 1, &c, 0, 0); |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 166 | out: |
| 167 | kfree(sdesc); |
| 168 | return ret; |
| 169 | } |
| 170 | |
| 171 | /* |
| 172 | * verify the AUTH1_COMMAND (Seal) result from TPM |
| 173 | */ |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 174 | static int TSS_checkhmac1(unsigned char *buffer, |
| 175 | const uint32_t command, |
| 176 | const unsigned char *ononce, |
| 177 | const unsigned char *key, |
Mimi Zohar | 1bdbb40 | 2010-12-13 16:53:11 -0500 | [diff] [blame] | 178 | unsigned int keylen, ...) |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 179 | { |
| 180 | uint32_t bufsize; |
| 181 | uint16_t tag; |
| 182 | uint32_t ordinal; |
| 183 | uint32_t result; |
| 184 | unsigned char *enonce; |
| 185 | unsigned char *continueflag; |
| 186 | unsigned char *authdata; |
| 187 | unsigned char testhmac[SHA1_DIGEST_SIZE]; |
| 188 | unsigned char paramdigest[SHA1_DIGEST_SIZE]; |
| 189 | struct sdesc *sdesc; |
| 190 | unsigned int dlen; |
| 191 | unsigned int dpos; |
| 192 | va_list argp; |
| 193 | int ret; |
| 194 | |
| 195 | bufsize = LOAD32(buffer, TPM_SIZE_OFFSET); |
| 196 | tag = LOAD16(buffer, 0); |
| 197 | ordinal = command; |
| 198 | result = LOAD32N(buffer, TPM_RETURN_OFFSET); |
| 199 | if (tag == TPM_TAG_RSP_COMMAND) |
| 200 | return 0; |
| 201 | if (tag != TPM_TAG_RSP_AUTH1_COMMAND) |
| 202 | return -EINVAL; |
| 203 | authdata = buffer + bufsize - SHA1_DIGEST_SIZE; |
| 204 | continueflag = authdata - 1; |
| 205 | enonce = continueflag - TPM_NONCE_SIZE; |
| 206 | |
| 207 | sdesc = init_sdesc(hashalg); |
| 208 | if (IS_ERR(sdesc)) { |
| 209 | pr_info("trusted_key: can't alloc %s\n", hash_alg); |
| 210 | return PTR_ERR(sdesc); |
| 211 | } |
| 212 | ret = crypto_shash_init(&sdesc->shash); |
| 213 | if (ret < 0) |
| 214 | goto out; |
| 215 | ret = crypto_shash_update(&sdesc->shash, (const u8 *)&result, |
| 216 | sizeof result); |
| 217 | if (ret < 0) |
| 218 | goto out; |
| 219 | ret = crypto_shash_update(&sdesc->shash, (const u8 *)&ordinal, |
| 220 | sizeof ordinal); |
| 221 | if (ret < 0) |
| 222 | goto out; |
| 223 | va_start(argp, keylen); |
| 224 | for (;;) { |
| 225 | dlen = va_arg(argp, unsigned int); |
| 226 | if (dlen == 0) |
| 227 | break; |
| 228 | dpos = va_arg(argp, unsigned int); |
| 229 | ret = crypto_shash_update(&sdesc->shash, buffer + dpos, dlen); |
Tetsuo Handa | 154a96b | 2011-01-17 09:27:27 +0900 | [diff] [blame] | 230 | if (ret < 0) |
| 231 | break; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 232 | } |
| 233 | va_end(argp); |
Tetsuo Handa | 154a96b | 2011-01-17 09:27:27 +0900 | [diff] [blame] | 234 | if (!ret) |
| 235 | ret = crypto_shash_final(&sdesc->shash, paramdigest); |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 236 | if (ret < 0) |
| 237 | goto out; |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 238 | |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 239 | ret = TSS_rawhmac(testhmac, key, keylen, SHA1_DIGEST_SIZE, paramdigest, |
| 240 | TPM_NONCE_SIZE, enonce, TPM_NONCE_SIZE, ononce, |
| 241 | 1, continueflag, 0, 0); |
| 242 | if (ret < 0) |
| 243 | goto out; |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 244 | |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 245 | if (memcmp(testhmac, authdata, SHA1_DIGEST_SIZE)) |
| 246 | ret = -EINVAL; |
| 247 | out: |
| 248 | kfree(sdesc); |
| 249 | return ret; |
| 250 | } |
| 251 | |
| 252 | /* |
| 253 | * verify the AUTH2_COMMAND (unseal) result from TPM |
| 254 | */ |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 255 | static int TSS_checkhmac2(unsigned char *buffer, |
| 256 | const uint32_t command, |
| 257 | const unsigned char *ononce, |
| 258 | const unsigned char *key1, |
Mimi Zohar | 1bdbb40 | 2010-12-13 16:53:11 -0500 | [diff] [blame] | 259 | unsigned int keylen1, |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 260 | const unsigned char *key2, |
Mimi Zohar | 1bdbb40 | 2010-12-13 16:53:11 -0500 | [diff] [blame] | 261 | unsigned int keylen2, ...) |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 262 | { |
| 263 | uint32_t bufsize; |
| 264 | uint16_t tag; |
| 265 | uint32_t ordinal; |
| 266 | uint32_t result; |
| 267 | unsigned char *enonce1; |
| 268 | unsigned char *continueflag1; |
| 269 | unsigned char *authdata1; |
| 270 | unsigned char *enonce2; |
| 271 | unsigned char *continueflag2; |
| 272 | unsigned char *authdata2; |
| 273 | unsigned char testhmac1[SHA1_DIGEST_SIZE]; |
| 274 | unsigned char testhmac2[SHA1_DIGEST_SIZE]; |
| 275 | unsigned char paramdigest[SHA1_DIGEST_SIZE]; |
| 276 | struct sdesc *sdesc; |
| 277 | unsigned int dlen; |
| 278 | unsigned int dpos; |
| 279 | va_list argp; |
| 280 | int ret; |
| 281 | |
| 282 | bufsize = LOAD32(buffer, TPM_SIZE_OFFSET); |
| 283 | tag = LOAD16(buffer, 0); |
| 284 | ordinal = command; |
| 285 | result = LOAD32N(buffer, TPM_RETURN_OFFSET); |
| 286 | |
| 287 | if (tag == TPM_TAG_RSP_COMMAND) |
| 288 | return 0; |
| 289 | if (tag != TPM_TAG_RSP_AUTH2_COMMAND) |
| 290 | return -EINVAL; |
| 291 | authdata1 = buffer + bufsize - (SHA1_DIGEST_SIZE + 1 |
| 292 | + SHA1_DIGEST_SIZE + SHA1_DIGEST_SIZE); |
| 293 | authdata2 = buffer + bufsize - (SHA1_DIGEST_SIZE); |
| 294 | continueflag1 = authdata1 - 1; |
| 295 | continueflag2 = authdata2 - 1; |
| 296 | enonce1 = continueflag1 - TPM_NONCE_SIZE; |
| 297 | enonce2 = continueflag2 - TPM_NONCE_SIZE; |
| 298 | |
| 299 | sdesc = init_sdesc(hashalg); |
| 300 | if (IS_ERR(sdesc)) { |
| 301 | pr_info("trusted_key: can't alloc %s\n", hash_alg); |
| 302 | return PTR_ERR(sdesc); |
| 303 | } |
| 304 | ret = crypto_shash_init(&sdesc->shash); |
| 305 | if (ret < 0) |
| 306 | goto out; |
| 307 | ret = crypto_shash_update(&sdesc->shash, (const u8 *)&result, |
| 308 | sizeof result); |
| 309 | if (ret < 0) |
| 310 | goto out; |
| 311 | ret = crypto_shash_update(&sdesc->shash, (const u8 *)&ordinal, |
| 312 | sizeof ordinal); |
| 313 | if (ret < 0) |
| 314 | goto out; |
| 315 | |
| 316 | va_start(argp, keylen2); |
| 317 | for (;;) { |
| 318 | dlen = va_arg(argp, unsigned int); |
| 319 | if (dlen == 0) |
| 320 | break; |
| 321 | dpos = va_arg(argp, unsigned int); |
| 322 | ret = crypto_shash_update(&sdesc->shash, buffer + dpos, dlen); |
Tetsuo Handa | 154a96b | 2011-01-17 09:27:27 +0900 | [diff] [blame] | 323 | if (ret < 0) |
| 324 | break; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 325 | } |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 326 | va_end(argp); |
Tetsuo Handa | 154a96b | 2011-01-17 09:27:27 +0900 | [diff] [blame] | 327 | if (!ret) |
| 328 | ret = crypto_shash_final(&sdesc->shash, paramdigest); |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 329 | if (ret < 0) |
| 330 | goto out; |
| 331 | |
| 332 | ret = TSS_rawhmac(testhmac1, key1, keylen1, SHA1_DIGEST_SIZE, |
| 333 | paramdigest, TPM_NONCE_SIZE, enonce1, |
| 334 | TPM_NONCE_SIZE, ononce, 1, continueflag1, 0, 0); |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 335 | if (ret < 0) |
| 336 | goto out; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 337 | if (memcmp(testhmac1, authdata1, SHA1_DIGEST_SIZE)) { |
| 338 | ret = -EINVAL; |
| 339 | goto out; |
| 340 | } |
| 341 | ret = TSS_rawhmac(testhmac2, key2, keylen2, SHA1_DIGEST_SIZE, |
| 342 | paramdigest, TPM_NONCE_SIZE, enonce2, |
| 343 | TPM_NONCE_SIZE, ononce, 1, continueflag2, 0, 0); |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 344 | if (ret < 0) |
| 345 | goto out; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 346 | if (memcmp(testhmac2, authdata2, SHA1_DIGEST_SIZE)) |
| 347 | ret = -EINVAL; |
| 348 | out: |
| 349 | kfree(sdesc); |
| 350 | return ret; |
| 351 | } |
| 352 | |
| 353 | /* |
| 354 | * For key specific tpm requests, we will generate and send our |
| 355 | * own TPM command packets using the drivers send function. |
| 356 | */ |
| 357 | static int trusted_tpm_send(const u32 chip_num, unsigned char *cmd, |
| 358 | size_t buflen) |
| 359 | { |
| 360 | int rc; |
| 361 | |
| 362 | dump_tpm_buf(cmd); |
| 363 | rc = tpm_send(chip_num, cmd, buflen); |
| 364 | dump_tpm_buf(cmd); |
| 365 | if (rc > 0) |
| 366 | /* Can't return positive return codes values to keyctl */ |
| 367 | rc = -EPERM; |
| 368 | return rc; |
| 369 | } |
| 370 | |
| 371 | /* |
| 372 | * get a random value from TPM |
| 373 | */ |
| 374 | static int tpm_get_random(struct tpm_buf *tb, unsigned char *buf, uint32_t len) |
| 375 | { |
| 376 | int ret; |
| 377 | |
| 378 | INIT_BUF(tb); |
| 379 | store16(tb, TPM_TAG_RQU_COMMAND); |
| 380 | store32(tb, TPM_GETRANDOM_SIZE); |
| 381 | store32(tb, TPM_ORD_GETRANDOM); |
| 382 | store32(tb, len); |
| 383 | ret = trusted_tpm_send(TPM_ANY_NUM, tb->data, sizeof tb->data); |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 384 | if (!ret) |
| 385 | memcpy(buf, tb->data + TPM_GETRANDOM_SIZE, len); |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 386 | return ret; |
| 387 | } |
| 388 | |
| 389 | static int my_get_random(unsigned char *buf, int len) |
| 390 | { |
| 391 | struct tpm_buf *tb; |
| 392 | int ret; |
| 393 | |
Mimi Zohar | 1bdbb40 | 2010-12-13 16:53:11 -0500 | [diff] [blame] | 394 | tb = kmalloc(sizeof *tb, GFP_KERNEL); |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 395 | if (!tb) |
| 396 | return -ENOMEM; |
| 397 | ret = tpm_get_random(tb, buf, len); |
| 398 | |
| 399 | kfree(tb); |
| 400 | return ret; |
| 401 | } |
| 402 | |
| 403 | /* |
| 404 | * Lock a trusted key, by extending a selected PCR. |
| 405 | * |
| 406 | * Prevents a trusted key that is sealed to PCRs from being accessed. |
| 407 | * This uses the tpm driver's extend function. |
| 408 | */ |
| 409 | static int pcrlock(const int pcrnum) |
| 410 | { |
| 411 | unsigned char hash[SHA1_DIGEST_SIZE]; |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 412 | int ret; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 413 | |
| 414 | if (!capable(CAP_SYS_ADMIN)) |
| 415 | return -EPERM; |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 416 | ret = my_get_random(hash, SHA1_DIGEST_SIZE); |
| 417 | if (ret < 0) |
| 418 | return ret; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 419 | return tpm_pcr_extend(TPM_ANY_NUM, pcrnum, hash) ? -EINVAL : 0; |
| 420 | } |
| 421 | |
| 422 | /* |
| 423 | * Create an object specific authorisation protocol (OSAP) session |
| 424 | */ |
| 425 | static int osap(struct tpm_buf *tb, struct osapsess *s, |
Mimi Zohar | 1bdbb40 | 2010-12-13 16:53:11 -0500 | [diff] [blame] | 426 | const unsigned char *key, uint16_t type, uint32_t handle) |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 427 | { |
| 428 | unsigned char enonce[TPM_NONCE_SIZE]; |
| 429 | unsigned char ononce[TPM_NONCE_SIZE]; |
| 430 | int ret; |
| 431 | |
| 432 | ret = tpm_get_random(tb, ononce, TPM_NONCE_SIZE); |
| 433 | if (ret < 0) |
| 434 | return ret; |
| 435 | |
| 436 | INIT_BUF(tb); |
| 437 | store16(tb, TPM_TAG_RQU_COMMAND); |
| 438 | store32(tb, TPM_OSAP_SIZE); |
| 439 | store32(tb, TPM_ORD_OSAP); |
| 440 | store16(tb, type); |
| 441 | store32(tb, handle); |
| 442 | storebytes(tb, ononce, TPM_NONCE_SIZE); |
| 443 | |
| 444 | ret = trusted_tpm_send(TPM_ANY_NUM, tb->data, MAX_BUF_SIZE); |
| 445 | if (ret < 0) |
| 446 | return ret; |
| 447 | |
| 448 | s->handle = LOAD32(tb->data, TPM_DATA_OFFSET); |
| 449 | memcpy(s->enonce, &(tb->data[TPM_DATA_OFFSET + sizeof(uint32_t)]), |
| 450 | TPM_NONCE_SIZE); |
| 451 | memcpy(enonce, &(tb->data[TPM_DATA_OFFSET + sizeof(uint32_t) + |
| 452 | TPM_NONCE_SIZE]), TPM_NONCE_SIZE); |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 453 | return TSS_rawhmac(s->secret, key, SHA1_DIGEST_SIZE, TPM_NONCE_SIZE, |
| 454 | enonce, TPM_NONCE_SIZE, ononce, 0, 0); |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 455 | } |
| 456 | |
| 457 | /* |
| 458 | * Create an object independent authorisation protocol (oiap) session |
| 459 | */ |
| 460 | static int oiap(struct tpm_buf *tb, uint32_t *handle, unsigned char *nonce) |
| 461 | { |
| 462 | int ret; |
| 463 | |
| 464 | INIT_BUF(tb); |
| 465 | store16(tb, TPM_TAG_RQU_COMMAND); |
| 466 | store32(tb, TPM_OIAP_SIZE); |
| 467 | store32(tb, TPM_ORD_OIAP); |
| 468 | ret = trusted_tpm_send(TPM_ANY_NUM, tb->data, MAX_BUF_SIZE); |
| 469 | if (ret < 0) |
| 470 | return ret; |
| 471 | |
| 472 | *handle = LOAD32(tb->data, TPM_DATA_OFFSET); |
| 473 | memcpy(nonce, &tb->data[TPM_DATA_OFFSET + sizeof(uint32_t)], |
| 474 | TPM_NONCE_SIZE); |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 475 | return 0; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 476 | } |
| 477 | |
| 478 | struct tpm_digests { |
| 479 | unsigned char encauth[SHA1_DIGEST_SIZE]; |
| 480 | unsigned char pubauth[SHA1_DIGEST_SIZE]; |
| 481 | unsigned char xorwork[SHA1_DIGEST_SIZE * 2]; |
| 482 | unsigned char xorhash[SHA1_DIGEST_SIZE]; |
| 483 | unsigned char nonceodd[TPM_NONCE_SIZE]; |
| 484 | }; |
| 485 | |
| 486 | /* |
| 487 | * Have the TPM seal(encrypt) the trusted key, possibly based on |
| 488 | * Platform Configuration Registers (PCRs). AUTH1 for sealing key. |
| 489 | */ |
Mimi Zohar | 1bdbb40 | 2010-12-13 16:53:11 -0500 | [diff] [blame] | 490 | static int tpm_seal(struct tpm_buf *tb, uint16_t keytype, |
| 491 | uint32_t keyhandle, const unsigned char *keyauth, |
| 492 | const unsigned char *data, uint32_t datalen, |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 493 | unsigned char *blob, uint32_t *bloblen, |
| 494 | const unsigned char *blobauth, |
Mimi Zohar | 1bdbb40 | 2010-12-13 16:53:11 -0500 | [diff] [blame] | 495 | const unsigned char *pcrinfo, uint32_t pcrinfosize) |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 496 | { |
| 497 | struct osapsess sess; |
| 498 | struct tpm_digests *td; |
| 499 | unsigned char cont; |
| 500 | uint32_t ordinal; |
| 501 | uint32_t pcrsize; |
| 502 | uint32_t datsize; |
| 503 | int sealinfosize; |
| 504 | int encdatasize; |
| 505 | int storedsize; |
| 506 | int ret; |
| 507 | int i; |
| 508 | |
| 509 | /* alloc some work space for all the hashes */ |
| 510 | td = kmalloc(sizeof *td, GFP_KERNEL); |
| 511 | if (!td) |
| 512 | return -ENOMEM; |
| 513 | |
| 514 | /* get session for sealing key */ |
| 515 | ret = osap(tb, &sess, keyauth, keytype, keyhandle); |
| 516 | if (ret < 0) |
Mimi Zohar | 40c1001 | 2010-12-20 12:37:18 -0500 | [diff] [blame] | 517 | goto out; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 518 | dump_sess(&sess); |
| 519 | |
| 520 | /* calculate encrypted authorization value */ |
| 521 | memcpy(td->xorwork, sess.secret, SHA1_DIGEST_SIZE); |
| 522 | memcpy(td->xorwork + SHA1_DIGEST_SIZE, sess.enonce, SHA1_DIGEST_SIZE); |
| 523 | ret = TSS_sha1(td->xorwork, SHA1_DIGEST_SIZE * 2, td->xorhash); |
| 524 | if (ret < 0) |
Mimi Zohar | 40c1001 | 2010-12-20 12:37:18 -0500 | [diff] [blame] | 525 | goto out; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 526 | |
| 527 | ret = tpm_get_random(tb, td->nonceodd, TPM_NONCE_SIZE); |
| 528 | if (ret < 0) |
Mimi Zohar | 40c1001 | 2010-12-20 12:37:18 -0500 | [diff] [blame] | 529 | goto out; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 530 | ordinal = htonl(TPM_ORD_SEAL); |
| 531 | datsize = htonl(datalen); |
| 532 | pcrsize = htonl(pcrinfosize); |
| 533 | cont = 0; |
| 534 | |
| 535 | /* encrypt data authorization key */ |
| 536 | for (i = 0; i < SHA1_DIGEST_SIZE; ++i) |
| 537 | td->encauth[i] = td->xorhash[i] ^ blobauth[i]; |
| 538 | |
| 539 | /* calculate authorization HMAC value */ |
| 540 | if (pcrinfosize == 0) { |
| 541 | /* no pcr info specified */ |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 542 | ret = TSS_authhmac(td->pubauth, sess.secret, SHA1_DIGEST_SIZE, |
| 543 | sess.enonce, td->nonceodd, cont, |
| 544 | sizeof(uint32_t), &ordinal, SHA1_DIGEST_SIZE, |
| 545 | td->encauth, sizeof(uint32_t), &pcrsize, |
| 546 | sizeof(uint32_t), &datsize, datalen, data, 0, |
| 547 | 0); |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 548 | } else { |
| 549 | /* pcr info specified */ |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 550 | ret = TSS_authhmac(td->pubauth, sess.secret, SHA1_DIGEST_SIZE, |
| 551 | sess.enonce, td->nonceodd, cont, |
| 552 | sizeof(uint32_t), &ordinal, SHA1_DIGEST_SIZE, |
| 553 | td->encauth, sizeof(uint32_t), &pcrsize, |
| 554 | pcrinfosize, pcrinfo, sizeof(uint32_t), |
| 555 | &datsize, datalen, data, 0, 0); |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 556 | } |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 557 | if (ret < 0) |
Mimi Zohar | 40c1001 | 2010-12-20 12:37:18 -0500 | [diff] [blame] | 558 | goto out; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 559 | |
| 560 | /* build and send the TPM request packet */ |
| 561 | INIT_BUF(tb); |
| 562 | store16(tb, TPM_TAG_RQU_AUTH1_COMMAND); |
| 563 | store32(tb, TPM_SEAL_SIZE + pcrinfosize + datalen); |
| 564 | store32(tb, TPM_ORD_SEAL); |
| 565 | store32(tb, keyhandle); |
| 566 | storebytes(tb, td->encauth, SHA1_DIGEST_SIZE); |
| 567 | store32(tb, pcrinfosize); |
| 568 | storebytes(tb, pcrinfo, pcrinfosize); |
| 569 | store32(tb, datalen); |
| 570 | storebytes(tb, data, datalen); |
| 571 | store32(tb, sess.handle); |
| 572 | storebytes(tb, td->nonceodd, TPM_NONCE_SIZE); |
| 573 | store8(tb, cont); |
| 574 | storebytes(tb, td->pubauth, SHA1_DIGEST_SIZE); |
| 575 | |
| 576 | ret = trusted_tpm_send(TPM_ANY_NUM, tb->data, MAX_BUF_SIZE); |
| 577 | if (ret < 0) |
Mimi Zohar | 40c1001 | 2010-12-20 12:37:18 -0500 | [diff] [blame] | 578 | goto out; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 579 | |
| 580 | /* calculate the size of the returned Blob */ |
| 581 | sealinfosize = LOAD32(tb->data, TPM_DATA_OFFSET + sizeof(uint32_t)); |
| 582 | encdatasize = LOAD32(tb->data, TPM_DATA_OFFSET + sizeof(uint32_t) + |
| 583 | sizeof(uint32_t) + sealinfosize); |
| 584 | storedsize = sizeof(uint32_t) + sizeof(uint32_t) + sealinfosize + |
| 585 | sizeof(uint32_t) + encdatasize; |
| 586 | |
| 587 | /* check the HMAC in the response */ |
| 588 | ret = TSS_checkhmac1(tb->data, ordinal, td->nonceodd, sess.secret, |
| 589 | SHA1_DIGEST_SIZE, storedsize, TPM_DATA_OFFSET, 0, |
| 590 | 0); |
| 591 | |
| 592 | /* copy the returned blob to caller */ |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 593 | if (!ret) { |
| 594 | memcpy(blob, tb->data + TPM_DATA_OFFSET, storedsize); |
| 595 | *bloblen = storedsize; |
| 596 | } |
Mimi Zohar | 40c1001 | 2010-12-20 12:37:18 -0500 | [diff] [blame] | 597 | out: |
| 598 | kfree(td); |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 599 | return ret; |
| 600 | } |
| 601 | |
| 602 | /* |
| 603 | * use the AUTH2_COMMAND form of unseal, to authorize both key and blob |
| 604 | */ |
| 605 | static int tpm_unseal(struct tpm_buf *tb, |
Mimi Zohar | 1bdbb40 | 2010-12-13 16:53:11 -0500 | [diff] [blame] | 606 | uint32_t keyhandle, const unsigned char *keyauth, |
| 607 | const unsigned char *blob, int bloblen, |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 608 | const unsigned char *blobauth, |
| 609 | unsigned char *data, unsigned int *datalen) |
| 610 | { |
| 611 | unsigned char nonceodd[TPM_NONCE_SIZE]; |
| 612 | unsigned char enonce1[TPM_NONCE_SIZE]; |
| 613 | unsigned char enonce2[TPM_NONCE_SIZE]; |
| 614 | unsigned char authdata1[SHA1_DIGEST_SIZE]; |
| 615 | unsigned char authdata2[SHA1_DIGEST_SIZE]; |
| 616 | uint32_t authhandle1 = 0; |
| 617 | uint32_t authhandle2 = 0; |
| 618 | unsigned char cont = 0; |
| 619 | uint32_t ordinal; |
| 620 | uint32_t keyhndl; |
| 621 | int ret; |
| 622 | |
| 623 | /* sessions for unsealing key and data */ |
| 624 | ret = oiap(tb, &authhandle1, enonce1); |
| 625 | if (ret < 0) { |
| 626 | pr_info("trusted_key: oiap failed (%d)\n", ret); |
| 627 | return ret; |
| 628 | } |
| 629 | ret = oiap(tb, &authhandle2, enonce2); |
| 630 | if (ret < 0) { |
| 631 | pr_info("trusted_key: oiap failed (%d)\n", ret); |
| 632 | return ret; |
| 633 | } |
| 634 | |
| 635 | ordinal = htonl(TPM_ORD_UNSEAL); |
| 636 | keyhndl = htonl(SRKHANDLE); |
| 637 | ret = tpm_get_random(tb, nonceodd, TPM_NONCE_SIZE); |
| 638 | if (ret < 0) { |
| 639 | pr_info("trusted_key: tpm_get_random failed (%d)\n", ret); |
| 640 | return ret; |
| 641 | } |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 642 | ret = TSS_authhmac(authdata1, keyauth, TPM_NONCE_SIZE, |
| 643 | enonce1, nonceodd, cont, sizeof(uint32_t), |
| 644 | &ordinal, bloblen, blob, 0, 0); |
| 645 | if (ret < 0) |
| 646 | return ret; |
| 647 | ret = TSS_authhmac(authdata2, blobauth, TPM_NONCE_SIZE, |
| 648 | enonce2, nonceodd, cont, sizeof(uint32_t), |
| 649 | &ordinal, bloblen, blob, 0, 0); |
| 650 | if (ret < 0) |
| 651 | return ret; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 652 | |
| 653 | /* build and send TPM request packet */ |
| 654 | INIT_BUF(tb); |
| 655 | store16(tb, TPM_TAG_RQU_AUTH2_COMMAND); |
| 656 | store32(tb, TPM_UNSEAL_SIZE + bloblen); |
| 657 | store32(tb, TPM_ORD_UNSEAL); |
| 658 | store32(tb, keyhandle); |
| 659 | storebytes(tb, blob, bloblen); |
| 660 | store32(tb, authhandle1); |
| 661 | storebytes(tb, nonceodd, TPM_NONCE_SIZE); |
| 662 | store8(tb, cont); |
| 663 | storebytes(tb, authdata1, SHA1_DIGEST_SIZE); |
| 664 | store32(tb, authhandle2); |
| 665 | storebytes(tb, nonceodd, TPM_NONCE_SIZE); |
| 666 | store8(tb, cont); |
| 667 | storebytes(tb, authdata2, SHA1_DIGEST_SIZE); |
| 668 | |
| 669 | ret = trusted_tpm_send(TPM_ANY_NUM, tb->data, MAX_BUF_SIZE); |
| 670 | if (ret < 0) { |
| 671 | pr_info("trusted_key: authhmac failed (%d)\n", ret); |
| 672 | return ret; |
| 673 | } |
| 674 | |
| 675 | *datalen = LOAD32(tb->data, TPM_DATA_OFFSET); |
| 676 | ret = TSS_checkhmac2(tb->data, ordinal, nonceodd, |
| 677 | keyauth, SHA1_DIGEST_SIZE, |
| 678 | blobauth, SHA1_DIGEST_SIZE, |
| 679 | sizeof(uint32_t), TPM_DATA_OFFSET, |
| 680 | *datalen, TPM_DATA_OFFSET + sizeof(uint32_t), 0, |
| 681 | 0); |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 682 | if (ret < 0) { |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 683 | pr_info("trusted_key: TSS_checkhmac2 failed (%d)\n", ret); |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 684 | return ret; |
| 685 | } |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 686 | memcpy(data, tb->data + TPM_DATA_OFFSET + sizeof(uint32_t), *datalen); |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 687 | return 0; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 688 | } |
| 689 | |
| 690 | /* |
| 691 | * Have the TPM seal(encrypt) the symmetric key |
| 692 | */ |
| 693 | static int key_seal(struct trusted_key_payload *p, |
| 694 | struct trusted_key_options *o) |
| 695 | { |
| 696 | struct tpm_buf *tb; |
| 697 | int ret; |
| 698 | |
| 699 | tb = kzalloc(sizeof *tb, GFP_KERNEL); |
| 700 | if (!tb) |
| 701 | return -ENOMEM; |
| 702 | |
| 703 | /* include migratable flag at end of sealed key */ |
| 704 | p->key[p->key_len] = p->migratable; |
| 705 | |
| 706 | ret = tpm_seal(tb, o->keytype, o->keyhandle, o->keyauth, |
| 707 | p->key, p->key_len + 1, p->blob, &p->blob_len, |
| 708 | o->blobauth, o->pcrinfo, o->pcrinfo_len); |
| 709 | if (ret < 0) |
| 710 | pr_info("trusted_key: srkseal failed (%d)\n", ret); |
| 711 | |
| 712 | kfree(tb); |
| 713 | return ret; |
| 714 | } |
| 715 | |
| 716 | /* |
| 717 | * Have the TPM unseal(decrypt) the symmetric key |
| 718 | */ |
| 719 | static int key_unseal(struct trusted_key_payload *p, |
| 720 | struct trusted_key_options *o) |
| 721 | { |
| 722 | struct tpm_buf *tb; |
| 723 | int ret; |
| 724 | |
| 725 | tb = kzalloc(sizeof *tb, GFP_KERNEL); |
| 726 | if (!tb) |
| 727 | return -ENOMEM; |
| 728 | |
| 729 | ret = tpm_unseal(tb, o->keyhandle, o->keyauth, p->blob, p->blob_len, |
| 730 | o->blobauth, p->key, &p->key_len); |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 731 | if (ret < 0) |
| 732 | pr_info("trusted_key: srkunseal failed (%d)\n", ret); |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 733 | else |
| 734 | /* pull migratable flag out of sealed key */ |
| 735 | p->migratable = p->key[--p->key_len]; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 736 | |
| 737 | kfree(tb); |
| 738 | return ret; |
| 739 | } |
| 740 | |
| 741 | enum { |
| 742 | Opt_err = -1, |
| 743 | Opt_new, Opt_load, Opt_update, |
| 744 | Opt_keyhandle, Opt_keyauth, Opt_blobauth, |
| 745 | Opt_pcrinfo, Opt_pcrlock, Opt_migratable |
| 746 | }; |
| 747 | |
| 748 | static const match_table_t key_tokens = { |
| 749 | {Opt_new, "new"}, |
| 750 | {Opt_load, "load"}, |
| 751 | {Opt_update, "update"}, |
| 752 | {Opt_keyhandle, "keyhandle=%s"}, |
| 753 | {Opt_keyauth, "keyauth=%s"}, |
| 754 | {Opt_blobauth, "blobauth=%s"}, |
| 755 | {Opt_pcrinfo, "pcrinfo=%s"}, |
| 756 | {Opt_pcrlock, "pcrlock=%s"}, |
| 757 | {Opt_migratable, "migratable=%s"}, |
| 758 | {Opt_err, NULL} |
| 759 | }; |
| 760 | |
| 761 | /* can have zero or more token= options */ |
| 762 | static int getoptions(char *c, struct trusted_key_payload *pay, |
| 763 | struct trusted_key_options *opt) |
| 764 | { |
| 765 | substring_t args[MAX_OPT_ARGS]; |
| 766 | char *p = c; |
| 767 | int token; |
| 768 | int res; |
| 769 | unsigned long handle; |
| 770 | unsigned long lock; |
| 771 | |
| 772 | while ((p = strsep(&c, " \t"))) { |
| 773 | if (*p == '\0' || *p == ' ' || *p == '\t') |
| 774 | continue; |
| 775 | token = match_token(p, key_tokens, args); |
| 776 | |
| 777 | switch (token) { |
| 778 | case Opt_pcrinfo: |
| 779 | opt->pcrinfo_len = strlen(args[0].from) / 2; |
| 780 | if (opt->pcrinfo_len > MAX_PCRINFO_SIZE) |
| 781 | return -EINVAL; |
Mimi Zohar | 2684bf7 | 2011-09-20 11:23:52 -0400 | [diff] [blame] | 782 | res = hex2bin(opt->pcrinfo, args[0].from, |
| 783 | opt->pcrinfo_len); |
| 784 | if (res < 0) |
| 785 | return -EINVAL; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 786 | break; |
| 787 | case Opt_keyhandle: |
| 788 | res = strict_strtoul(args[0].from, 16, &handle); |
| 789 | if (res < 0) |
| 790 | return -EINVAL; |
| 791 | opt->keytype = SEAL_keytype; |
| 792 | opt->keyhandle = handle; |
| 793 | break; |
| 794 | case Opt_keyauth: |
| 795 | if (strlen(args[0].from) != 2 * SHA1_DIGEST_SIZE) |
| 796 | return -EINVAL; |
Mimi Zohar | 2684bf7 | 2011-09-20 11:23:52 -0400 | [diff] [blame] | 797 | res = hex2bin(opt->keyauth, args[0].from, |
| 798 | SHA1_DIGEST_SIZE); |
| 799 | if (res < 0) |
| 800 | return -EINVAL; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 801 | break; |
| 802 | case Opt_blobauth: |
| 803 | if (strlen(args[0].from) != 2 * SHA1_DIGEST_SIZE) |
| 804 | return -EINVAL; |
Mimi Zohar | 2684bf7 | 2011-09-20 11:23:52 -0400 | [diff] [blame] | 805 | res = hex2bin(opt->blobauth, args[0].from, |
| 806 | SHA1_DIGEST_SIZE); |
| 807 | if (res < 0) |
| 808 | return -EINVAL; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 809 | break; |
| 810 | case Opt_migratable: |
| 811 | if (*args[0].from == '0') |
| 812 | pay->migratable = 0; |
| 813 | else |
| 814 | return -EINVAL; |
| 815 | break; |
| 816 | case Opt_pcrlock: |
| 817 | res = strict_strtoul(args[0].from, 10, &lock); |
| 818 | if (res < 0) |
| 819 | return -EINVAL; |
| 820 | opt->pcrlock = lock; |
| 821 | break; |
| 822 | default: |
| 823 | return -EINVAL; |
| 824 | } |
| 825 | } |
| 826 | return 0; |
| 827 | } |
| 828 | |
| 829 | /* |
| 830 | * datablob_parse - parse the keyctl data and fill in the |
| 831 | * payload and options structures |
| 832 | * |
| 833 | * On success returns 0, otherwise -EINVAL. |
| 834 | */ |
| 835 | static int datablob_parse(char *datablob, struct trusted_key_payload *p, |
| 836 | struct trusted_key_options *o) |
| 837 | { |
| 838 | substring_t args[MAX_OPT_ARGS]; |
| 839 | long keylen; |
| 840 | int ret = -EINVAL; |
| 841 | int key_cmd; |
| 842 | char *c; |
| 843 | |
| 844 | /* main command */ |
| 845 | c = strsep(&datablob, " \t"); |
| 846 | if (!c) |
| 847 | return -EINVAL; |
| 848 | key_cmd = match_token(c, key_tokens, args); |
| 849 | switch (key_cmd) { |
| 850 | case Opt_new: |
| 851 | /* first argument is key size */ |
| 852 | c = strsep(&datablob, " \t"); |
| 853 | if (!c) |
| 854 | return -EINVAL; |
| 855 | ret = strict_strtol(c, 10, &keylen); |
| 856 | if (ret < 0 || keylen < MIN_KEY_SIZE || keylen > MAX_KEY_SIZE) |
| 857 | return -EINVAL; |
| 858 | p->key_len = keylen; |
| 859 | ret = getoptions(datablob, p, o); |
| 860 | if (ret < 0) |
| 861 | return ret; |
| 862 | ret = Opt_new; |
| 863 | break; |
| 864 | case Opt_load: |
| 865 | /* first argument is sealed blob */ |
| 866 | c = strsep(&datablob, " \t"); |
| 867 | if (!c) |
| 868 | return -EINVAL; |
| 869 | p->blob_len = strlen(c) / 2; |
| 870 | if (p->blob_len > MAX_BLOB_SIZE) |
| 871 | return -EINVAL; |
Mimi Zohar | 2684bf7 | 2011-09-20 11:23:52 -0400 | [diff] [blame] | 872 | ret = hex2bin(p->blob, c, p->blob_len); |
| 873 | if (ret < 0) |
| 874 | return -EINVAL; |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 875 | ret = getoptions(datablob, p, o); |
| 876 | if (ret < 0) |
| 877 | return ret; |
| 878 | ret = Opt_load; |
| 879 | break; |
| 880 | case Opt_update: |
| 881 | /* all arguments are options */ |
| 882 | ret = getoptions(datablob, p, o); |
| 883 | if (ret < 0) |
| 884 | return ret; |
| 885 | ret = Opt_update; |
| 886 | break; |
| 887 | case Opt_err: |
| 888 | return -EINVAL; |
| 889 | break; |
| 890 | } |
| 891 | return ret; |
| 892 | } |
| 893 | |
| 894 | static struct trusted_key_options *trusted_options_alloc(void) |
| 895 | { |
| 896 | struct trusted_key_options *options; |
| 897 | |
| 898 | options = kzalloc(sizeof *options, GFP_KERNEL); |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 899 | if (options) { |
| 900 | /* set any non-zero defaults */ |
| 901 | options->keytype = SRK_keytype; |
| 902 | options->keyhandle = SRKHANDLE; |
| 903 | } |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 904 | return options; |
| 905 | } |
| 906 | |
| 907 | static struct trusted_key_payload *trusted_payload_alloc(struct key *key) |
| 908 | { |
| 909 | struct trusted_key_payload *p = NULL; |
| 910 | int ret; |
| 911 | |
| 912 | ret = key_payload_reserve(key, sizeof *p); |
| 913 | if (ret < 0) |
| 914 | return p; |
| 915 | p = kzalloc(sizeof *p, GFP_KERNEL); |
Mimi Zohar | bc5e0af | 2010-12-13 16:53:10 -0500 | [diff] [blame] | 916 | if (p) |
| 917 | p->migratable = 1; /* migratable by default */ |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 918 | return p; |
| 919 | } |
| 920 | |
| 921 | /* |
| 922 | * trusted_instantiate - create a new trusted key |
| 923 | * |
| 924 | * Unseal an existing trusted blob or, for a new key, get a |
| 925 | * random key, then seal and create a trusted key-type key, |
| 926 | * adding it to the specified keyring. |
| 927 | * |
| 928 | * On success, return 0. Otherwise return errno. |
| 929 | */ |
| 930 | static int trusted_instantiate(struct key *key, const void *data, |
Mimi Zohar | 1bdbb40 | 2010-12-13 16:53:11 -0500 | [diff] [blame] | 931 | size_t datalen) |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 932 | { |
| 933 | struct trusted_key_payload *payload = NULL; |
| 934 | struct trusted_key_options *options = NULL; |
| 935 | char *datablob; |
| 936 | int ret = 0; |
| 937 | int key_cmd; |
| 938 | |
| 939 | if (datalen <= 0 || datalen > 32767 || !data) |
| 940 | return -EINVAL; |
| 941 | |
| 942 | datablob = kmalloc(datalen + 1, GFP_KERNEL); |
| 943 | if (!datablob) |
| 944 | return -ENOMEM; |
| 945 | memcpy(datablob, data, datalen); |
| 946 | datablob[datalen] = '\0'; |
| 947 | |
| 948 | options = trusted_options_alloc(); |
| 949 | if (!options) { |
| 950 | ret = -ENOMEM; |
| 951 | goto out; |
| 952 | } |
| 953 | payload = trusted_payload_alloc(key); |
| 954 | if (!payload) { |
| 955 | ret = -ENOMEM; |
| 956 | goto out; |
| 957 | } |
| 958 | |
| 959 | key_cmd = datablob_parse(datablob, payload, options); |
| 960 | if (key_cmd < 0) { |
| 961 | ret = key_cmd; |
| 962 | goto out; |
| 963 | } |
| 964 | |
| 965 | dump_payload(payload); |
| 966 | dump_options(options); |
| 967 | |
| 968 | switch (key_cmd) { |
| 969 | case Opt_load: |
| 970 | ret = key_unseal(payload, options); |
| 971 | dump_payload(payload); |
| 972 | dump_options(options); |
| 973 | if (ret < 0) |
| 974 | pr_info("trusted_key: key_unseal failed (%d)\n", ret); |
| 975 | break; |
| 976 | case Opt_new: |
| 977 | ret = my_get_random(payload->key, payload->key_len); |
| 978 | if (ret < 0) { |
| 979 | pr_info("trusted_key: key_create failed (%d)\n", ret); |
| 980 | goto out; |
| 981 | } |
| 982 | ret = key_seal(payload, options); |
| 983 | if (ret < 0) |
| 984 | pr_info("trusted_key: key_seal failed (%d)\n", ret); |
| 985 | break; |
| 986 | default: |
| 987 | ret = -EINVAL; |
| 988 | goto out; |
| 989 | } |
| 990 | if (!ret && options->pcrlock) |
| 991 | ret = pcrlock(options->pcrlock); |
| 992 | out: |
| 993 | kfree(datablob); |
| 994 | kfree(options); |
| 995 | if (!ret) |
| 996 | rcu_assign_pointer(key->payload.data, payload); |
| 997 | else |
| 998 | kfree(payload); |
| 999 | return ret; |
| 1000 | } |
| 1001 | |
| 1002 | static void trusted_rcu_free(struct rcu_head *rcu) |
| 1003 | { |
| 1004 | struct trusted_key_payload *p; |
| 1005 | |
| 1006 | p = container_of(rcu, struct trusted_key_payload, rcu); |
| 1007 | memset(p->key, 0, p->key_len); |
| 1008 | kfree(p); |
| 1009 | } |
| 1010 | |
| 1011 | /* |
| 1012 | * trusted_update - reseal an existing key with new PCR values |
| 1013 | */ |
Mimi Zohar | 1bdbb40 | 2010-12-13 16:53:11 -0500 | [diff] [blame] | 1014 | static int trusted_update(struct key *key, const void *data, size_t datalen) |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 1015 | { |
| 1016 | struct trusted_key_payload *p = key->payload.data; |
| 1017 | struct trusted_key_payload *new_p; |
| 1018 | struct trusted_key_options *new_o; |
| 1019 | char *datablob; |
| 1020 | int ret = 0; |
| 1021 | |
| 1022 | if (!p->migratable) |
| 1023 | return -EPERM; |
| 1024 | if (datalen <= 0 || datalen > 32767 || !data) |
| 1025 | return -EINVAL; |
| 1026 | |
| 1027 | datablob = kmalloc(datalen + 1, GFP_KERNEL); |
| 1028 | if (!datablob) |
| 1029 | return -ENOMEM; |
| 1030 | new_o = trusted_options_alloc(); |
| 1031 | if (!new_o) { |
| 1032 | ret = -ENOMEM; |
| 1033 | goto out; |
| 1034 | } |
| 1035 | new_p = trusted_payload_alloc(key); |
| 1036 | if (!new_p) { |
| 1037 | ret = -ENOMEM; |
| 1038 | goto out; |
| 1039 | } |
| 1040 | |
| 1041 | memcpy(datablob, data, datalen); |
| 1042 | datablob[datalen] = '\0'; |
| 1043 | ret = datablob_parse(datablob, new_p, new_o); |
| 1044 | if (ret != Opt_update) { |
| 1045 | ret = -EINVAL; |
Jesper Juhl | 5403110 | 2011-01-23 22:40:42 +0100 | [diff] [blame] | 1046 | kfree(new_p); |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 1047 | goto out; |
| 1048 | } |
| 1049 | /* copy old key values, and reseal with new pcrs */ |
| 1050 | new_p->migratable = p->migratable; |
| 1051 | new_p->key_len = p->key_len; |
| 1052 | memcpy(new_p->key, p->key, p->key_len); |
| 1053 | dump_payload(p); |
| 1054 | dump_payload(new_p); |
| 1055 | |
| 1056 | ret = key_seal(new_p, new_o); |
| 1057 | if (ret < 0) { |
| 1058 | pr_info("trusted_key: key_seal failed (%d)\n", ret); |
| 1059 | kfree(new_p); |
| 1060 | goto out; |
| 1061 | } |
| 1062 | if (new_o->pcrlock) { |
| 1063 | ret = pcrlock(new_o->pcrlock); |
| 1064 | if (ret < 0) { |
| 1065 | pr_info("trusted_key: pcrlock failed (%d)\n", ret); |
| 1066 | kfree(new_p); |
| 1067 | goto out; |
| 1068 | } |
| 1069 | } |
| 1070 | rcu_assign_pointer(key->payload.data, new_p); |
| 1071 | call_rcu(&p->rcu, trusted_rcu_free); |
| 1072 | out: |
| 1073 | kfree(datablob); |
| 1074 | kfree(new_o); |
| 1075 | return ret; |
| 1076 | } |
| 1077 | |
| 1078 | /* |
| 1079 | * trusted_read - copy the sealed blob data to userspace in hex. |
| 1080 | * On success, return to userspace the trusted key datablob size. |
| 1081 | */ |
| 1082 | static long trusted_read(const struct key *key, char __user *buffer, |
| 1083 | size_t buflen) |
| 1084 | { |
| 1085 | struct trusted_key_payload *p; |
| 1086 | char *ascii_buf; |
| 1087 | char *bufp; |
| 1088 | int i; |
| 1089 | |
David Howells | 633e804 | 2011-03-07 15:05:51 +0000 | [diff] [blame] | 1090 | p = rcu_dereference_key(key); |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 1091 | if (!p) |
| 1092 | return -EINVAL; |
| 1093 | if (!buffer || buflen <= 0) |
| 1094 | return 2 * p->blob_len; |
| 1095 | ascii_buf = kmalloc(2 * p->blob_len, GFP_KERNEL); |
| 1096 | if (!ascii_buf) |
| 1097 | return -ENOMEM; |
| 1098 | |
| 1099 | bufp = ascii_buf; |
| 1100 | for (i = 0; i < p->blob_len; i++) |
Andy Shevchenko | 0247311 | 2011-10-31 17:12:55 -0700 | [diff] [blame] | 1101 | bufp = hex_byte_pack(bufp, p->blob[i]); |
Mimi Zohar | d00a1c7 | 2010-11-23 17:50:34 -0500 | [diff] [blame] | 1102 | if ((copy_to_user(buffer, ascii_buf, 2 * p->blob_len)) != 0) { |
| 1103 | kfree(ascii_buf); |
| 1104 | return -EFAULT; |
| 1105 | } |
| 1106 | kfree(ascii_buf); |
| 1107 | return 2 * p->blob_len; |
| 1108 | } |
| 1109 | |
| 1110 | /* |
| 1111 | * trusted_destroy - before freeing the key, clear the decrypted data |
| 1112 | */ |
| 1113 | static void trusted_destroy(struct key *key) |
| 1114 | { |
| 1115 | struct trusted_key_payload *p = key->payload.data; |
| 1116 | |
| 1117 | if (!p) |
| 1118 | return; |
| 1119 | memset(p->key, 0, p->key_len); |
| 1120 | kfree(key->payload.data); |
| 1121 | } |
| 1122 | |
| 1123 | struct key_type key_type_trusted = { |
| 1124 | .name = "trusted", |
| 1125 | .instantiate = trusted_instantiate, |
| 1126 | .update = trusted_update, |
| 1127 | .match = user_match, |
| 1128 | .destroy = trusted_destroy, |
| 1129 | .describe = user_describe, |
| 1130 | .read = trusted_read, |
| 1131 | }; |
| 1132 | |
| 1133 | EXPORT_SYMBOL_GPL(key_type_trusted); |
| 1134 | |
| 1135 | static void trusted_shash_release(void) |
| 1136 | { |
| 1137 | if (hashalg) |
| 1138 | crypto_free_shash(hashalg); |
| 1139 | if (hmacalg) |
| 1140 | crypto_free_shash(hmacalg); |
| 1141 | } |
| 1142 | |
| 1143 | static int __init trusted_shash_alloc(void) |
| 1144 | { |
| 1145 | int ret; |
| 1146 | |
| 1147 | hmacalg = crypto_alloc_shash(hmac_alg, 0, CRYPTO_ALG_ASYNC); |
| 1148 | if (IS_ERR(hmacalg)) { |
| 1149 | pr_info("trusted_key: could not allocate crypto %s\n", |
| 1150 | hmac_alg); |
| 1151 | return PTR_ERR(hmacalg); |
| 1152 | } |
| 1153 | |
| 1154 | hashalg = crypto_alloc_shash(hash_alg, 0, CRYPTO_ALG_ASYNC); |
| 1155 | if (IS_ERR(hashalg)) { |
| 1156 | pr_info("trusted_key: could not allocate crypto %s\n", |
| 1157 | hash_alg); |
| 1158 | ret = PTR_ERR(hashalg); |
| 1159 | goto hashalg_fail; |
| 1160 | } |
| 1161 | |
| 1162 | return 0; |
| 1163 | |
| 1164 | hashalg_fail: |
| 1165 | crypto_free_shash(hmacalg); |
| 1166 | return ret; |
| 1167 | } |
| 1168 | |
| 1169 | static int __init init_trusted(void) |
| 1170 | { |
| 1171 | int ret; |
| 1172 | |
| 1173 | ret = trusted_shash_alloc(); |
| 1174 | if (ret < 0) |
| 1175 | return ret; |
| 1176 | ret = register_key_type(&key_type_trusted); |
| 1177 | if (ret < 0) |
| 1178 | trusted_shash_release(); |
| 1179 | return ret; |
| 1180 | } |
| 1181 | |
| 1182 | static void __exit cleanup_trusted(void) |
| 1183 | { |
| 1184 | trusted_shash_release(); |
| 1185 | unregister_key_type(&key_type_trusted); |
| 1186 | } |
| 1187 | |
| 1188 | late_initcall(init_trusted); |
| 1189 | module_exit(cleanup_trusted); |
| 1190 | |
| 1191 | MODULE_LICENSE("GPL"); |