lib/tpm-v1.c

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