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