git.sur5r.net Git - u-boot/blob - lib/tpm.c

   1 /*
   2  * Copyright (c) 2013 The Chromium OS Authors.
   3  * Coypright (c) 2013 Guntermann & Drunck GmbH
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 #include <common.h>
   9 #include <dm.h>
  10 #include <tpm.h>
  11 #include <asm/unaligned.h>
  12 #include <u-boot/sha1.h>
  13
  14 /* Internal error of TPM command library */
  15 #define TPM_LIB_ERROR   ((uint32_t)~0u)
  16
  17 /* Useful constants */
  18 enum {
  19         COMMAND_BUFFER_SIZE             = 256,
  20         TPM_REQUEST_HEADER_LENGTH       = 10,
  21         TPM_RESPONSE_HEADER_LENGTH      = 10,
  22         PCR_DIGEST_LENGTH               = 20,
  23         DIGEST_LENGTH                   = 20,
  24         TPM_REQUEST_AUTH_LENGTH         = 45,
  25         TPM_RESPONSE_AUTH_LENGTH        = 41,
  26         /* some max lengths, valid for RSA keys <= 2048 bits */
  27         TPM_KEY12_MAX_LENGTH            = 618,
  28         TPM_PUBKEY_MAX_LENGTH           = 288,
  29 };
  30
  31 #ifdef CONFIG_TPM_AUTH_SESSIONS
  32
  33 #ifndef CONFIG_SHA1
  34 #error "TPM_AUTH_SESSIONS require SHA1 to be configured, too"
  35 #endif /* !CONFIG_SHA1 */
  36
  37 struct session_data {
  38         int             valid;
  39         uint32_t        handle;
  40         uint8_t         nonce_even[DIGEST_LENGTH];
  41         uint8_t         nonce_odd[DIGEST_LENGTH];
  42 };
  43
  44 static struct session_data oiap_session = {0, };
  45
  46 #endif /* CONFIG_TPM_AUTH_SESSIONS */
  47
  48 /**
  49  * Pack data into a byte string.  The data types are specified in
  50  * the format string: 'b' means unsigned byte, 'w' unsigned word,
  51  * 'd' unsigned double word, and 's' byte string.  The data are a
  52  * series of offsets and values (for type byte string there are also
  53  * lengths).  The data values are packed into the byte string
  54  * sequentially, and so a latter value could over-write a former
  55  * value.
  56  *
  57  * @param str           output string
  58  * @param size          size of output string
  59  * @param format        format string
  60  * @param ...           data points
  61  * @return 0 on success, non-0 on error
  62  */
  63 int pack_byte_string(uint8_t *str, size_t size, const char *format, ...)
  64 {
  65         va_list args;
  66         size_t offset = 0, length = 0;
  67         uint8_t *data = NULL;
  68         uint32_t value = 0;
  69
  70         va_start(args, format);
  71         for (; *format; format++) {
  72                 switch (*format) {
  73                 case 'b':
  74                         offset = va_arg(args, size_t);
  75                         value = va_arg(args, int);
  76                         length = 1;
  77                         break;
  78                 case 'w':
  79                         offset = va_arg(args, size_t);
  80                         value = va_arg(args, int);
  81                         length = 2;
  82                         break;
  83                 case 'd':
  84                         offset = va_arg(args, size_t);
  85                         value = va_arg(args, uint32_t);
  86                         length = 4;
  87                         break;
  88                 case 's':
  89                         offset = va_arg(args, size_t);
  90                         data = va_arg(args, uint8_t *);
  91                         length = va_arg(args, uint32_t);
  92                         break;
  93                 default:
  94                         debug("Couldn't recognize format string\n");
  95                         return -1;
  96                 }
  97
  98                 if (offset + length > size) {
  99                         va_end(args);
 100                         return -1;
 101                 }
 102
 103                 switch (*format) {
 104                 case 'b':
 105                         str[offset] = value;
 106                         break;
 107                 case 'w':
 108                         put_unaligned_be16(value, str + offset);
 109                         break;
 110                 case 'd':
 111                         put_unaligned_be32(value, str + offset);
 112                         break;
 113                 case 's':
 114                         memcpy(str + offset, data, length);
 115                         break;
 116                 }
 117         }
 118         va_end(args);
 119
 120         return 0;
 121 }
 122
 123 /**
 124  * Unpack data from a byte string.  The data types are specified in
 125  * the format string: 'b' means unsigned byte, 'w' unsigned word,
 126  * 'd' unsigned double word, and 's' byte string.  The data are a
 127  * series of offsets and pointers (for type byte string there are also
 128  * lengths).
 129  *
 130  * @param str           output string
 131  * @param size          size of output string
 132  * @param format        format string
 133  * @param ...           data points
 134  * @return 0 on success, non-0 on error
 135  */
 136 int unpack_byte_string(const uint8_t *str, size_t size, const char *format, ...)
 137 {
 138         va_list args;
 139         size_t offset = 0, length = 0;
 140         uint8_t *ptr8 = NULL;
 141         uint16_t *ptr16 = NULL;
 142         uint32_t *ptr32 = NULL;
 143
 144         va_start(args, format);
 145         for (; *format; format++) {
 146                 switch (*format) {
 147                 case 'b':
 148                         offset = va_arg(args, size_t);
 149                         ptr8 = va_arg(args, uint8_t *);
 150                         length = 1;
 151                         break;
 152                 case 'w':
 153                         offset = va_arg(args, size_t);
 154                         ptr16 = va_arg(args, uint16_t *);
 155                         length = 2;
 156                         break;
 157                 case 'd':
 158                         offset = va_arg(args, size_t);
 159                         ptr32 = va_arg(args, uint32_t *);
 160                         length = 4;
 161                         break;
 162                 case 's':
 163                         offset = va_arg(args, size_t);
 164                         ptr8 = va_arg(args, uint8_t *);
 165                         length = va_arg(args, uint32_t);
 166                         break;
 167                 default:
 168                         va_end(args);
 169                         debug("Couldn't recognize format string\n");
 170                         return -1;
 171                 }
 172
 173                 if (offset + length > size)
 174                         return -1;
 175
 176                 switch (*format) {
 177                 case 'b':
 178                         *ptr8 = str[offset];
 179                         break;
 180                 case 'w':
 181                         *ptr16 = get_unaligned_be16(str + offset);
 182                         break;
 183                 case 'd':
 184                         *ptr32 = get_unaligned_be32(str + offset);
 185                         break;
 186                 case 's':
 187                         memcpy(ptr8, str + offset, length);
 188                         break;
 189                 }
 190         }
 191         va_end(args);
 192
 193         return 0;
 194 }
 195
 196 /**
 197  * Get TPM command size.
 198  *
 199  * @param command       byte string of TPM command
 200  * @return command size of the TPM command
 201  */
 202 static uint32_t tpm_command_size(const void *command)
 203 {
 204         const size_t command_size_offset = 2;
 205         return get_unaligned_be32(command + command_size_offset);
 206 }
 207
 208 /**
 209  * Get TPM response return code, which is one of TPM_RESULT values.
 210  *
 211  * @param response      byte string of TPM response
 212  * @return return code of the TPM response
 213  */
 214 static uint32_t tpm_return_code(const void *response)
 215 {
 216         const size_t return_code_offset = 6;
 217         return get_unaligned_be32(response + return_code_offset);
 218 }
 219
 220 /**
 221  * Send a TPM command and return response's return code, and optionally
 222  * return response to caller.
 223  *
 224  * @param command       byte string of TPM command
 225  * @param response      output buffer for TPM response, or NULL if the
 226  *                      caller does not care about it
 227  * @param size_ptr      output buffer size (input parameter) and TPM
 228  *                      response length (output parameter); this parameter
 229  *                      is a bidirectional
 230  * @return return code of the TPM response
 231  */
 232 static uint32_t tpm_sendrecv_command(const void *command,
 233                 void *response, size_t *size_ptr)
 234 {
 235         struct udevice *dev;
 236         int err, ret;
 237         uint8_t response_buffer[COMMAND_BUFFER_SIZE];
 238         size_t response_length;
 239
 240         if (response) {
 241                 response_length = *size_ptr;
 242         } else {
 243                 response = response_buffer;
 244                 response_length = sizeof(response_buffer);
 245         }
 246
 247         ret = uclass_first_device_err(UCLASS_TPM, &dev);
 248         if (ret)
 249                 return ret;
 250         err = tpm_xfer(dev, command, tpm_command_size(command),
 251                        response, &response_length);
 252
 253         if (err < 0)
 254                 return TPM_LIB_ERROR;
 255         if (size_ptr)
 256                 *size_ptr = response_length;
 257
 258         return tpm_return_code(response);
 259 }
 260
 261 int tpm_init(void)
 262 {
 263         int err;
 264         struct udevice *dev;
 265
 266         err = uclass_first_device_err(UCLASS_TPM, &dev);
 267         if (err)
 268                 return err;
 269         return tpm_open(dev);
 270 }
 271
 272 uint32_t tpm_startup(enum tpm_startup_type mode)
 273 {
 274         const uint8_t command[12] = {
 275                 0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x99, 0x0, 0x0,
 276         };
 277         const size_t mode_offset = 10;
 278         uint8_t buf[COMMAND_BUFFER_SIZE];
 279
 280         if (pack_byte_string(buf, sizeof(buf), "sw",
 281                                 0, command, sizeof(command),
 282                                 mode_offset, mode))
 283                 return TPM_LIB_ERROR;
 284
 285         return tpm_sendrecv_command(buf, NULL, NULL);
 286 }
 287
 288 uint32_t tpm_self_test_full(void)
 289 {
 290         const uint8_t command[10] = {
 291                 0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x50,
 292         };
 293         return tpm_sendrecv_command(command, NULL, NULL);
 294 }
 295
 296 uint32_t tpm_continue_self_test(void)
 297 {
 298         const uint8_t command[10] = {
 299                 0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x53,
 300         };
 301         return tpm_sendrecv_command(command, NULL, NULL);
 302 }
 303
 304 uint32_t tpm_nv_define_space(uint32_t index, uint32_t perm, uint32_t size)
 305 {
 306         const uint8_t command[101] = {
 307                 0x0, 0xc1,              /* TPM_TAG */
 308                 0x0, 0x0, 0x0, 0x65,    /* parameter size */
 309                 0x0, 0x0, 0x0, 0xcc,    /* TPM_COMMAND_CODE */
 310                 /* TPM_NV_DATA_PUBLIC->... */
 311                 0x0, 0x18,              /* ...->TPM_STRUCTURE_TAG */
 312                 0, 0, 0, 0,             /* ...->TPM_NV_INDEX */
 313                 /* TPM_NV_DATA_PUBLIC->TPM_PCR_INFO_SHORT */
 314                 0x0, 0x3,
 315                 0, 0, 0,
 316                 0x1f,
 317                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 318                 /* TPM_NV_DATA_PUBLIC->TPM_PCR_INFO_SHORT */
 319                 0x0, 0x3,
 320                 0, 0, 0,
 321                 0x1f,
 322                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 323                 /* TPM_NV_ATTRIBUTES->... */
 324                 0x0, 0x17,              /* ...->TPM_STRUCTURE_TAG */
 325                 0, 0, 0, 0,             /* ...->attributes */
 326                 /* End of TPM_NV_ATTRIBUTES */
 327                 0,                      /* bReadSTClear */
 328                 0,                      /* bWriteSTClear */
 329                 0,                      /* bWriteDefine */
 330                 0, 0, 0, 0,             /* size */
 331         };
 332         const size_t index_offset = 12;
 333         const size_t perm_offset = 70;
 334         const size_t size_offset = 77;
 335         uint8_t buf[COMMAND_BUFFER_SIZE];
 336
 337         if (pack_byte_string(buf, sizeof(buf), "sddd",
 338                                 0, command, sizeof(command),
 339                                 index_offset, index,
 340                                 perm_offset, perm,
 341                                 size_offset, size))
 342                 return TPM_LIB_ERROR;
 343
 344         return tpm_sendrecv_command(buf, NULL, NULL);
 345 }
 346
 347 uint32_t tpm_nv_read_value(uint32_t index, void *data, uint32_t count)
 348 {
 349         const uint8_t command[22] = {
 350                 0x0, 0xc1, 0x0, 0x0, 0x0, 0x16, 0x0, 0x0, 0x0, 0xcf,
 351         };
 352         const size_t index_offset = 10;
 353         const size_t length_offset = 18;
 354         const size_t data_size_offset = 10;
 355         const size_t data_offset = 14;
 356         uint8_t buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
 357         size_t response_length = sizeof(response);
 358         uint32_t data_size;
 359         uint32_t err;
 360
 361         if (pack_byte_string(buf, sizeof(buf), "sdd",
 362                                 0, command, sizeof(command),
 363                                 index_offset, index,
 364                                 length_offset, count))
 365                 return TPM_LIB_ERROR;
 366         err = tpm_sendrecv_command(buf, response, &response_length);
 367         if (err)
 368                 return err;
 369         if (unpack_byte_string(response, response_length, "d",
 370                                 data_size_offset, &data_size))
 371                 return TPM_LIB_ERROR;
 372         if (data_size > count)
 373                 return TPM_LIB_ERROR;
 374         if (unpack_byte_string(response, response_length, "s",
 375                                 data_offset, data, data_size))
 376                 return TPM_LIB_ERROR;
 377
 378         return 0;
 379 }
 380
 381 uint32_t tpm_nv_write_value(uint32_t index, const void *data, uint32_t length)
 382 {
 383         const uint8_t command[256] = {
 384                 0x0, 0xc1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcd,
 385         };
 386         const size_t command_size_offset = 2;
 387         const size_t index_offset = 10;
 388         const size_t length_offset = 18;
 389         const size_t data_offset = 22;
 390         const size_t write_info_size = 12;
 391         const uint32_t total_length =
 392                 TPM_REQUEST_HEADER_LENGTH + write_info_size + length;
 393         uint8_t buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
 394         size_t response_length = sizeof(response);
 395         uint32_t err;
 396
 397         if (pack_byte_string(buf, sizeof(buf), "sddds",
 398                                 0, command, sizeof(command),
 399                                 command_size_offset, total_length,
 400                                 index_offset, index,
 401                                 length_offset, length,
 402                                 data_offset, data, length))
 403                 return TPM_LIB_ERROR;
 404         err = tpm_sendrecv_command(buf, response, &response_length);
 405         if (err)
 406                 return err;
 407
 408         return 0;
 409 }
 410
 411 uint32_t tpm_extend(uint32_t index, const void *in_digest, void *out_digest)
 412 {
 413         const uint8_t command[34] = {
 414                 0x0, 0xc1, 0x0, 0x0, 0x0, 0x22, 0x0, 0x0, 0x0, 0x14,
 415         };
 416         const size_t index_offset = 10;
 417         const size_t in_digest_offset = 14;
 418         const size_t out_digest_offset = 10;
 419         uint8_t buf[COMMAND_BUFFER_SIZE];
 420         uint8_t response[TPM_RESPONSE_HEADER_LENGTH + PCR_DIGEST_LENGTH];
 421         size_t response_length = sizeof(response);
 422         uint32_t err;
 423
 424         if (pack_byte_string(buf, sizeof(buf), "sds",
 425                                 0, command, sizeof(command),
 426                                 index_offset, index,
 427                                 in_digest_offset, in_digest,
 428                                 PCR_DIGEST_LENGTH))
 429                 return TPM_LIB_ERROR;
 430         err = tpm_sendrecv_command(buf, response, &response_length);
 431         if (err)
 432                 return err;
 433
 434         if (unpack_byte_string(response, response_length, "s",
 435                                 out_digest_offset, out_digest,
 436                                 PCR_DIGEST_LENGTH))
 437                 return TPM_LIB_ERROR;
 438
 439         return 0;
 440 }
 441
 442 uint32_t tpm_pcr_read(uint32_t index, void *data, size_t count)
 443 {
 444         const uint8_t command[14] = {
 445                 0x0, 0xc1, 0x0, 0x0, 0x0, 0xe, 0x0, 0x0, 0x0, 0x15,
 446         };
 447         const size_t index_offset = 10;
 448         const size_t out_digest_offset = 10;
 449         uint8_t buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
 450         size_t response_length = sizeof(response);
 451         uint32_t err;
 452
 453         if (count < PCR_DIGEST_LENGTH)
 454                 return TPM_LIB_ERROR;
 455
 456         if (pack_byte_string(buf, sizeof(buf), "sd",
 457                                 0, command, sizeof(command),
 458                                 index_offset, index))
 459                 return TPM_LIB_ERROR;
 460         err = tpm_sendrecv_command(buf, response, &response_length);
 461         if (err)
 462                 return err;
 463         if (unpack_byte_string(response, response_length, "s",
 464                                 out_digest_offset, data, PCR_DIGEST_LENGTH))
 465                 return TPM_LIB_ERROR;
 466
 467         return 0;
 468 }
 469
 470 uint32_t tpm_tsc_physical_presence(uint16_t presence)
 471 {
 472         const uint8_t command[12] = {
 473                 0x0, 0xc1, 0x0, 0x0, 0x0, 0xc, 0x40, 0x0, 0x0, 0xa, 0x0, 0x0,
 474         };
 475         const size_t presence_offset = 10;
 476         uint8_t buf[COMMAND_BUFFER_SIZE];
 477
 478         if (pack_byte_string(buf, sizeof(buf), "sw",
 479                                 0, command, sizeof(command),
 480                                 presence_offset, presence))
 481                 return TPM_LIB_ERROR;
 482
 483         return tpm_sendrecv_command(buf, NULL, NULL);
 484 }
 485
 486 uint32_t tpm_read_pubek(void *data, size_t count)
 487 {
 488         const uint8_t command[30] = {
 489                 0x0, 0xc1, 0x0, 0x0, 0x0, 0x1e, 0x0, 0x0, 0x0, 0x7c,
 490         };
 491         const size_t response_size_offset = 2;
 492         const size_t data_offset = 10;
 493         const size_t header_and_checksum_size = TPM_RESPONSE_HEADER_LENGTH + 20;
 494         uint8_t response[COMMAND_BUFFER_SIZE + TPM_PUBEK_SIZE];
 495         size_t response_length = sizeof(response);
 496         uint32_t data_size;
 497         uint32_t err;
 498
 499         err = tpm_sendrecv_command(command, response, &response_length);
 500         if (err)
 501                 return err;
 502         if (unpack_byte_string(response, response_length, "d",
 503                                 response_size_offset, &data_size))
 504                 return TPM_LIB_ERROR;
 505         if (data_size < header_and_checksum_size)
 506                 return TPM_LIB_ERROR;
 507         data_size -= header_and_checksum_size;
 508         if (data_size > count)
 509                 return TPM_LIB_ERROR;
 510         if (unpack_byte_string(response, response_length, "s",
 511                                 data_offset, data, data_size))
 512                 return TPM_LIB_ERROR;
 513
 514         return 0;
 515 }
 516
 517 uint32_t tpm_force_clear(void)
 518 {
 519         const uint8_t command[10] = {
 520                 0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x5d,
 521         };
 522
 523         return tpm_sendrecv_command(command, NULL, NULL);
 524 }
 525
 526 uint32_t tpm_physical_enable(void)
 527 {
 528         const uint8_t command[10] = {
 529                 0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x6f,
 530         };
 531
 532         return tpm_sendrecv_command(command, NULL, NULL);
 533 }
 534
 535 uint32_t tpm_physical_disable(void)
 536 {
 537         const uint8_t command[10] = {
 538                 0x0, 0xc1, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x70,
 539         };
 540
 541         return tpm_sendrecv_command(command, NULL, NULL);
 542 }
 543
 544 uint32_t tpm_physical_set_deactivated(uint8_t state)
 545 {
 546         const uint8_t command[11] = {
 547                 0x0, 0xc1, 0x0, 0x0, 0x0, 0xb, 0x0, 0x0, 0x0, 0x72,
 548         };
 549         const size_t state_offset = 10;
 550         uint8_t buf[COMMAND_BUFFER_SIZE];
 551
 552         if (pack_byte_string(buf, sizeof(buf), "sb",
 553                                 0, command, sizeof(command),
 554                                 state_offset, state))
 555                 return TPM_LIB_ERROR;
 556
 557         return tpm_sendrecv_command(buf, NULL, NULL);
 558 }
 559
 560 uint32_t tpm_get_capability(uint32_t cap_area, uint32_t sub_cap,
 561                 void *cap, size_t count)
 562 {
 563         const uint8_t command[22] = {
 564                 0x0, 0xc1,              /* TPM_TAG */
 565                 0x0, 0x0, 0x0, 0x16,    /* parameter size */
 566                 0x0, 0x0, 0x0, 0x65,    /* TPM_COMMAND_CODE */
 567                 0x0, 0x0, 0x0, 0x0,     /* TPM_CAPABILITY_AREA */
 568                 0x0, 0x0, 0x0, 0x4,     /* subcap size */
 569                 0x0, 0x0, 0x0, 0x0,     /* subcap value */
 570         };
 571         const size_t cap_area_offset = 10;
 572         const size_t sub_cap_offset = 18;
 573         const size_t cap_offset = 14;
 574         const size_t cap_size_offset = 10;
 575         uint8_t buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
 576         size_t response_length = sizeof(response);
 577         uint32_t cap_size;
 578         uint32_t err;
 579
 580         if (pack_byte_string(buf, sizeof(buf), "sdd",
 581                                 0, command, sizeof(command),
 582                                 cap_area_offset, cap_area,
 583                                 sub_cap_offset, sub_cap))
 584                 return TPM_LIB_ERROR;
 585         err = tpm_sendrecv_command(buf, response, &response_length);
 586         if (err)
 587                 return err;
 588         if (unpack_byte_string(response, response_length, "d",
 589                                 cap_size_offset, &cap_size))
 590                 return TPM_LIB_ERROR;
 591         if (cap_size > response_length || cap_size > count)
 592                 return TPM_LIB_ERROR;
 593         if (unpack_byte_string(response, response_length, "s",
 594                                 cap_offset, cap, cap_size))
 595                 return TPM_LIB_ERROR;
 596
 597         return 0;
 598 }
 599
 600 uint32_t tpm_get_permanent_flags(struct tpm_permanent_flags *pflags)
 601 {
 602         const uint8_t command[22] = {
 603                 0x0, 0xc1,              /* TPM_TAG */
 604                 0x0, 0x0, 0x0, 0x16,    /* parameter size */
 605                 0x0, 0x0, 0x0, 0x65,    /* TPM_COMMAND_CODE */
 606                 0x0, 0x0, 0x0, 0x4,     /* TPM_CAP_FLAG_PERM */
 607                 0x0, 0x0, 0x0, 0x4,     /* subcap size */
 608                 0x0, 0x0, 0x1, 0x8,     /* subcap value */
 609         };
 610         uint8_t response[COMMAND_BUFFER_SIZE];
 611         size_t response_length = sizeof(response);
 612         uint32_t err;
 613
 614         err = tpm_sendrecv_command(command, response, &response_length);
 615         if (err)
 616                 return err;
 617         memcpy(pflags, response + TPM_HEADER_SIZE, sizeof(*pflags));
 618
 619         return 0;
 620 }
 621
 622 uint32_t tpm_get_permissions(uint32_t index, uint32_t *perm)
 623 {
 624         const uint8_t command[22] = {
 625                 0x0, 0xc1,              /* TPM_TAG */
 626                 0x0, 0x0, 0x0, 0x16,    /* parameter size */
 627                 0x0, 0x0, 0x0, 0x65,    /* TPM_COMMAND_CODE */
 628                 0x0, 0x0, 0x0, 0x11,
 629                 0x0, 0x0, 0x0, 0x4,
 630         };
 631         const size_t index_offset = 18;
 632         const size_t perm_offset = 60;
 633         uint8_t buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
 634         size_t response_length = sizeof(response);
 635         uint32_t err;
 636
 637         if (pack_byte_string(buf, sizeof(buf), "d", 0, command, sizeof(command),
 638                              index_offset, index))
 639                 return TPM_LIB_ERROR;
 640         err = tpm_sendrecv_command(buf, response, &response_length);
 641         if (err)
 642                 return err;
 643         if (unpack_byte_string(response, response_length, "d",
 644                                perm_offset, perm))
 645                 return TPM_LIB_ERROR;
 646
 647         return 0;
 648 }
 649
 650 #ifdef CONFIG_TPM_FLUSH_RESOURCES
 651 uint32_t tpm_flush_specific(uint32_t key_handle, uint32_t resource_type)
 652 {
 653         const uint8_t command[18] = {
 654                 0x00, 0xc1,             /* TPM_TAG */
 655                 0x00, 0x00, 0x00, 0x12, /* parameter size */
 656                 0x00, 0x00, 0x00, 0xba, /* TPM_COMMAND_CODE */
 657                 0x00, 0x00, 0x00, 0x00, /* key handle */
 658                 0x00, 0x00, 0x00, 0x00, /* resource type */
 659         };
 660         const size_t key_handle_offset = 10;
 661         const size_t resource_type_offset = 14;
 662         uint8_t buf[COMMAND_BUFFER_SIZE], response[COMMAND_BUFFER_SIZE];
 663         size_t response_length = sizeof(response);
 664         uint32_t err;
 665
 666         if (pack_byte_string(buf, sizeof(buf), "sdd",
 667                              0, command, sizeof(command),
 668                              key_handle_offset, key_handle,
 669                              resource_type_offset, resource_type))
 670                 return TPM_LIB_ERROR;
 671
 672         err = tpm_sendrecv_command(buf, response, &response_length);
 673         if (err)
 674                 return err;
 675         return 0;
 676 }
 677 #endif /* CONFIG_TPM_FLUSH_RESOURCES */
 678
 679 #ifdef CONFIG_TPM_AUTH_SESSIONS
 680
 681 /**
 682  * Fill an authentication block in a request.
 683  * This func can create the first as well as the second auth block (for
 684  * double authorized commands).
 685  *
 686  * @param request       pointer to the request (w/ uninitialised auth data)
 687  * @param request_len0  length of the request without auth data
 688  * @param handles_len   length of the handles area in request
 689  * @param auth_session  pointer to the (valid) auth session to be used
 690  * @param request_auth  pointer to the auth block of the request to be filled
 691  * @param auth          authentication data (HMAC key)
 692  */
 693 static uint32_t create_request_auth(const void *request, size_t request_len0,
 694         size_t handles_len,
 695         struct session_data *auth_session,
 696         void *request_auth, const void *auth)
 697 {
 698         uint8_t hmac_data[DIGEST_LENGTH * 3 + 1];
 699         sha1_context hash_ctx;
 700         const size_t command_code_offset = 6;
 701         const size_t auth_nonce_odd_offset = 4;
 702         const size_t auth_continue_offset = 24;
 703         const size_t auth_auth_offset = 25;
 704
 705         if (!auth_session || !auth_session->valid)
 706                 return TPM_LIB_ERROR;
 707
 708         sha1_starts(&hash_ctx);
 709         sha1_update(&hash_ctx, request + command_code_offset, 4);
 710         if (request_len0 > TPM_REQUEST_HEADER_LENGTH + handles_len)
 711                 sha1_update(&hash_ctx,
 712                             request + TPM_REQUEST_HEADER_LENGTH + handles_len,
 713                             request_len0 - TPM_REQUEST_HEADER_LENGTH
 714                             - handles_len);
 715         sha1_finish(&hash_ctx, hmac_data);
 716
 717         sha1_starts(&hash_ctx);
 718         sha1_update(&hash_ctx, auth_session->nonce_odd, DIGEST_LENGTH);
 719         sha1_update(&hash_ctx, hmac_data, sizeof(hmac_data));
 720         sha1_finish(&hash_ctx, auth_session->nonce_odd);
 721
 722         if (pack_byte_string(request_auth, TPM_REQUEST_AUTH_LENGTH, "dsb",
 723                              0, auth_session->handle,
 724                              auth_nonce_odd_offset, auth_session->nonce_odd,
 725                              DIGEST_LENGTH,
 726                              auth_continue_offset, 1))
 727                 return TPM_LIB_ERROR;
 728         if (pack_byte_string(hmac_data, sizeof(hmac_data), "ss",
 729                              DIGEST_LENGTH,
 730                              auth_session->nonce_even,
 731                              DIGEST_LENGTH,
 732                              2 * DIGEST_LENGTH,
 733                              request_auth + auth_nonce_odd_offset,
 734                              DIGEST_LENGTH + 1))
 735                 return TPM_LIB_ERROR;
 736         sha1_hmac(auth, DIGEST_LENGTH, hmac_data, sizeof(hmac_data),
 737                   request_auth + auth_auth_offset);
 738
 739         return TPM_SUCCESS;
 740 }
 741
 742 /**
 743  * Verify an authentication block in a response.
 744  * Since this func updates the nonce_even in the session data it has to be
 745  * called when receiving a succesfull AUTH response.
 746  * This func can verify the first as well as the second auth block (for
 747  * double authorized commands).
 748  *
 749  * @param command_code  command code of the request
 750  * @param response      pointer to the request (w/ uninitialised auth data)
 751  * @param handles_len   length of the handles area in response
 752  * @param auth_session  pointer to the (valid) auth session to be used
 753  * @param response_auth pointer to the auth block of the response to be verified
 754  * @param auth          authentication data (HMAC key)
 755  */
 756 static uint32_t verify_response_auth(uint32_t command_code,
 757         const void *response, size_t response_len0,
 758         size_t handles_len,
 759         struct session_data *auth_session,
 760         const void *response_auth, const void *auth)
 761 {
 762         uint8_t hmac_data[DIGEST_LENGTH * 3 + 1];
 763         uint8_t computed_auth[DIGEST_LENGTH];
 764         sha1_context hash_ctx;
 765         const size_t return_code_offset = 6;
 766         const size_t auth_continue_offset = 20;
 767         const size_t auth_auth_offset = 21;
 768         uint8_t auth_continue;
 769
 770         if (!auth_session || !auth_session->valid)
 771                 return TPM_AUTHFAIL;
 772         if (pack_byte_string(hmac_data, sizeof(hmac_data), "d",
 773                              0, command_code))
 774                 return TPM_LIB_ERROR;
 775         if (response_len0 < TPM_RESPONSE_HEADER_LENGTH)
 776                 return TPM_LIB_ERROR;
 777
 778         sha1_starts(&hash_ctx);
 779         sha1_update(&hash_ctx, response + return_code_offset, 4);
 780         sha1_update(&hash_ctx, hmac_data, 4);
 781         if (response_len0 > TPM_RESPONSE_HEADER_LENGTH + handles_len)
 782                 sha1_update(&hash_ctx,
 783                             response + TPM_RESPONSE_HEADER_LENGTH + handles_len,
 784                             response_len0 - TPM_RESPONSE_HEADER_LENGTH
 785                             - handles_len);
 786         sha1_finish(&hash_ctx, hmac_data);
 787
 788         memcpy(auth_session->nonce_even, response_auth, DIGEST_LENGTH);
 789         auth_continue = ((uint8_t *)response_auth)[auth_continue_offset];
 790         if (pack_byte_string(hmac_data, sizeof(hmac_data), "ssb",
 791                              DIGEST_LENGTH,
 792                              response_auth,
 793                              DIGEST_LENGTH,
 794                              2 * DIGEST_LENGTH,
 795                              auth_session->nonce_odd,
 796                              DIGEST_LENGTH,
 797                              3 * DIGEST_LENGTH,
 798                              auth_continue))
 799                 return TPM_LIB_ERROR;
 800
 801         sha1_hmac(auth, DIGEST_LENGTH, hmac_data, sizeof(hmac_data),
 802                   computed_auth);
 803
 804         if (memcmp(computed_auth, response_auth + auth_auth_offset,
 805                    DIGEST_LENGTH))
 806                 return TPM_AUTHFAIL;
 807
 808         return TPM_SUCCESS;
 809 }
 810
 811
 812 uint32_t tpm_terminate_auth_session(uint32_t auth_handle)
 813 {
 814         const uint8_t command[18] = {
 815                 0x00, 0xc1,             /* TPM_TAG */
 816                 0x00, 0x00, 0x00, 0x00, /* parameter size */
 817                 0x00, 0x00, 0x00, 0xba, /* TPM_COMMAND_CODE */
 818                 0x00, 0x00, 0x00, 0x00, /* TPM_HANDLE */
 819                 0x00, 0x00, 0x00, 0x02, /* TPM_RESSOURCE_TYPE */
 820         };
 821         const size_t req_handle_offset = TPM_REQUEST_HEADER_LENGTH;
 822         uint8_t request[COMMAND_BUFFER_SIZE];
 823
 824         if (pack_byte_string(request, sizeof(request), "sd",
 825                              0, command, sizeof(command),
 826                              req_handle_offset, auth_handle))
 827                 return TPM_LIB_ERROR;
 828         if (oiap_session.valid && oiap_session.handle == auth_handle)
 829                 oiap_session.valid = 0;
 830
 831         return tpm_sendrecv_command(request, NULL, NULL);
 832 }
 833
 834 uint32_t tpm_end_oiap(void)
 835 {
 836         uint32_t err = TPM_SUCCESS;
 837         if (oiap_session.valid)
 838                 err = tpm_terminate_auth_session(oiap_session.handle);
 839         return err;
 840 }
 841
 842 uint32_t tpm_oiap(uint32_t *auth_handle)
 843 {
 844         const uint8_t command[10] = {
 845                 0x00, 0xc1,             /* TPM_TAG */
 846                 0x00, 0x00, 0x00, 0x0a, /* parameter size */
 847                 0x00, 0x00, 0x00, 0x0a, /* TPM_COMMAND_CODE */
 848         };
 849         const size_t res_auth_handle_offset = TPM_RESPONSE_HEADER_LENGTH;
 850         const size_t res_nonce_even_offset = TPM_RESPONSE_HEADER_LENGTH + 4;
 851         uint8_t response[COMMAND_BUFFER_SIZE];
 852         size_t response_length = sizeof(response);
 853         uint32_t err;
 854
 855         if (oiap_session.valid)
 856                 tpm_terminate_auth_session(oiap_session.handle);
 857
 858         err = tpm_sendrecv_command(command, response, &response_length);
 859         if (err)
 860                 return err;
 861         if (unpack_byte_string(response, response_length, "ds",
 862                                res_auth_handle_offset, &oiap_session.handle,
 863                                res_nonce_even_offset, &oiap_session.nonce_even,
 864                                (uint32_t)DIGEST_LENGTH))
 865                 return TPM_LIB_ERROR;
 866         oiap_session.valid = 1;
 867         if (auth_handle)
 868                 *auth_handle = oiap_session.handle;
 869         return 0;
 870 }
 871
 872 uint32_t tpm_load_key2_oiap(uint32_t parent_handle,
 873                 const void *key, size_t key_length,
 874                 const void *parent_key_usage_auth,
 875                 uint32_t *key_handle)
 876 {
 877         const uint8_t command[14] = {
 878                 0x00, 0xc2,             /* TPM_TAG */
 879                 0x00, 0x00, 0x00, 0x00, /* parameter size */
 880                 0x00, 0x00, 0x00, 0x41, /* TPM_COMMAND_CODE */
 881                 0x00, 0x00, 0x00, 0x00, /* parent handle */
 882         };
 883         const size_t req_size_offset = 2;
 884         const size_t req_parent_handle_offset = TPM_REQUEST_HEADER_LENGTH;
 885         const size_t req_key_offset = TPM_REQUEST_HEADER_LENGTH + 4;
 886         const size_t res_handle_offset = TPM_RESPONSE_HEADER_LENGTH;
 887         uint8_t request[sizeof(command) + TPM_KEY12_MAX_LENGTH
 888                         + TPM_REQUEST_AUTH_LENGTH];
 889         uint8_t response[COMMAND_BUFFER_SIZE];
 890         size_t response_length = sizeof(response);
 891         uint32_t err;
 892
 893         if (!oiap_session.valid) {
 894                 err = tpm_oiap(NULL);
 895                 if (err)
 896                         return err;
 897         }
 898         if (pack_byte_string(request, sizeof(request), "sdds",
 899                              0, command, sizeof(command),
 900                              req_size_offset,
 901                              sizeof(command) + key_length
 902                              + TPM_REQUEST_AUTH_LENGTH,
 903                              req_parent_handle_offset, parent_handle,
 904                              req_key_offset, key, key_length
 905                 ))
 906                 return TPM_LIB_ERROR;
 907
 908         err = create_request_auth(request, sizeof(command) + key_length, 4,
 909                                 &oiap_session,
 910                                 request + sizeof(command) + key_length,
 911                                 parent_key_usage_auth);
 912         if (err)
 913                 return err;
 914         err = tpm_sendrecv_command(request, response, &response_length);
 915         if (err) {
 916                 if (err == TPM_AUTHFAIL)
 917                         oiap_session.valid = 0;
 918                 return err;
 919         }
 920
 921         err = verify_response_auth(0x00000041, response,
 922                         response_length - TPM_RESPONSE_AUTH_LENGTH,
 923                         4, &oiap_session,
 924                         response + response_length - TPM_RESPONSE_AUTH_LENGTH,
 925                         parent_key_usage_auth);
 926         if (err)
 927                 return err;
 928
 929         if (key_handle) {
 930                 if (unpack_byte_string(response, response_length, "d",
 931                                        res_handle_offset, key_handle))
 932                         return TPM_LIB_ERROR;
 933         }
 934
 935         return 0;
 936 }
 937
 938 uint32_t tpm_get_pub_key_oiap(uint32_t key_handle, const void *usage_auth,
 939                         void *pubkey, size_t *pubkey_len)
 940 {
 941         const uint8_t command[14] = {
 942                 0x00, 0xc2,             /* TPM_TAG */
 943                 0x00, 0x00, 0x00, 0x00, /* parameter size */
 944                 0x00, 0x00, 0x00, 0x21, /* TPM_COMMAND_CODE */
 945                 0x00, 0x00, 0x00, 0x00, /* key handle */
 946         };
 947         const size_t req_size_offset = 2;
 948         const size_t req_key_handle_offset = TPM_REQUEST_HEADER_LENGTH;
 949         const size_t res_pubkey_offset = TPM_RESPONSE_HEADER_LENGTH;
 950         uint8_t request[sizeof(command) + TPM_REQUEST_AUTH_LENGTH];
 951         uint8_t response[TPM_RESPONSE_HEADER_LENGTH + TPM_PUBKEY_MAX_LENGTH
 952                         + TPM_RESPONSE_AUTH_LENGTH];
 953         size_t response_length = sizeof(response);
 954         uint32_t err;
 955
 956         if (!oiap_session.valid) {
 957                 err = tpm_oiap(NULL);
 958                 if (err)
 959                         return err;
 960         }
 961         if (pack_byte_string(request, sizeof(request), "sdd",
 962                              0, command, sizeof(command),
 963                              req_size_offset,
 964                              (uint32_t)(sizeof(command)
 965                              + TPM_REQUEST_AUTH_LENGTH),
 966                              req_key_handle_offset, key_handle
 967                 ))
 968                 return TPM_LIB_ERROR;
 969         err = create_request_auth(request, sizeof(command), 4, &oiap_session,
 970                         request + sizeof(command), usage_auth);
 971         if (err)
 972                 return err;
 973         err = tpm_sendrecv_command(request, response, &response_length);
 974         if (err) {
 975                 if (err == TPM_AUTHFAIL)
 976                         oiap_session.valid = 0;
 977                 return err;
 978         }
 979         err = verify_response_auth(0x00000021, response,
 980                         response_length - TPM_RESPONSE_AUTH_LENGTH,
 981                         0, &oiap_session,
 982                         response + response_length - TPM_RESPONSE_AUTH_LENGTH,
 983                         usage_auth);
 984         if (err)
 985                 return err;
 986
 987         if (pubkey) {
 988                 if ((response_length - TPM_RESPONSE_HEADER_LENGTH
 989                         - TPM_RESPONSE_AUTH_LENGTH) > *pubkey_len)
 990                         return TPM_LIB_ERROR;
 991                 *pubkey_len = response_length - TPM_RESPONSE_HEADER_LENGTH
 992                         - TPM_RESPONSE_AUTH_LENGTH;
 993                 memcpy(pubkey, response + res_pubkey_offset,
 994                        response_length - TPM_RESPONSE_HEADER_LENGTH
 995                        - TPM_RESPONSE_AUTH_LENGTH);
 996         }
 997
 998         return 0;
 999 }
1000
1001 #ifdef CONFIG_TPM_LOAD_KEY_BY_SHA1
1002 uint32_t tpm_find_key_sha1(const uint8_t auth[20], const uint8_t
1003                            pubkey_digest[20], uint32_t *handle)
1004 {
1005         uint16_t key_count;
1006         uint32_t key_handles[10];
1007         uint8_t buf[288];
1008         uint8_t *ptr;
1009         uint32_t err;
1010         uint8_t digest[20];
1011         size_t buf_len;
1012         unsigned int i;
1013
1014         /* fetch list of already loaded keys in the TPM */
1015         err = tpm_get_capability(TPM_CAP_HANDLE, TPM_RT_KEY, buf, sizeof(buf));
1016         if (err)
1017                 return -1;
1018         key_count = get_unaligned_be16(buf);
1019         ptr = buf + 2;
1020         for (i = 0; i < key_count; ++i, ptr += 4)
1021                 key_handles[i] = get_unaligned_be32(ptr);
1022
1023         /* now search a(/ the) key which we can access with the given auth */
1024         for (i = 0; i < key_count; ++i) {
1025                 buf_len = sizeof(buf);
1026                 err = tpm_get_pub_key_oiap(key_handles[i], auth, buf, &buf_len);
1027                 if (err && err != TPM_AUTHFAIL)
1028                         return -1;
1029                 if (err)
1030                         continue;
1031                 sha1_csum(buf, buf_len, digest);
1032                 if (!memcmp(digest, pubkey_digest, 20)) {
1033                         *handle = key_handles[i];
1034                         return 0;
1035                 }
1036         }
1037         return 1;
1038 }
1039 #endif /* CONFIG_TPM_LOAD_KEY_BY_SHA1 */
1040
1041 #endif /* CONFIG_TPM_AUTH_SESSIONS */