Various bug fixes to tpm_lite. Some changes to the test suite.

firmware/lib/tpm_lite/tlcl.c

 /* Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /* A lightweight TPM command library.
  *
  * The general idea is that TPM commands are array of bytes whose
  * fields are mostly compile-time constant.  The goal is to build much
  * of the commands at compile time (or build time) and change some of
  * the fields at run time as needed.  The code in
  * utility/tlcl_generator.c builds structures containing the commands,
  * as well as the offsets of the fields that need to be set at run
  * time.
  */
 
 #include "sysincludes.h"
 #include "tlcl.h"
 #include "tlcl_internal.h"
 #include "tlcl_structures.h"
 #include "tss_constants.h"
 #include "utility.h"
 
+#define EXTRA_LOGGING 0
+
+#if EXTRA_LOGGING
+#include <stdio.h>
+#endif
 
 /* Sets the size field of a TPM command. */
 static INLINE void SetTpmCommandSize(uint8_t* buffer, uint32_t size) {
   ToTpmUint32(buffer + sizeof(uint16_t), size);
 }
 
 /* Gets the size field of a TPM command. */
 POSSIBLY_UNUSED static INLINE int TpmCommandSize(const uint8_t* buffer) {
   uint32_t size;
   FromTpmUint32(buffer + sizeof(uint16_t), &size);
@@ skipping 21 matching lines @@
       VBDEBUG(("TPM: command 0x%x failed: 0x%x\n", command, result));
     else
       error("TPM: command 0x%x failed: 0x%x\n", command, result);
   }
 }
 
 /* Sends a TPM command and gets a response. */
 static void TlclSendReceive(uint8_t* request, uint8_t* response,
                             int max_length) {
 
+#if EXTRA_LOGGING
+  printf("command: %x%x %x%x%x%x %x%x%x%x\n",

[Randall Spangler, 2010/08/04 16:27:26]

Better to use VBDEBUG here, so that we can turn on EXTRA_LOGGING inside the
firmware (which doesn't have printf())

+         request[0], request[1],
+         request[2], request[3], request[4], request[5],
+         request[6], request[7], request[8], request[9]);
+#endif
   TlclStubSendReceive(request, TpmCommandSize(request),
                       response, max_length);
+#if EXTRA_LOGGING
+  printf("response: %x%x %x%x%x%x %x%x%x%x\n",
+         response[0], response[1],
+         response[2], response[3], response[4], response[5],
+         response[6], response[7], response[8], response[9]);
+#endif
 
 #ifdef VBOOT_DEBUG
   {
     int command = TpmCommandCode(request);
     int result = TpmReturnCode(response);
     VBDEBUG(("TPM: command 0x%x returned 0x%x\n", command, result));
   }
 #endif
 }
 
@@ skipping 38 matching lines @@
 
 uint32_t TlclWrite(uint32_t index, uint8_t* data, uint32_t length) {
   struct s_tpm_nv_write_cmd cmd;
   uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
   const int total_length =
     kTpmRequestHeaderLength + kWriteInfoLength + length;
 
   VBDEBUG(("TPM: TlclWrite(0x%x, %d)\n", index, length));
   Memcpy(&cmd, &tpm_nv_write_cmd, sizeof(cmd));
   assert(total_length <= TPM_LARGE_ENOUGH_COMMAND_SIZE);
-  SetTpmCommandSize(tpm_nv_write_cmd.buffer, total_length);
+  SetTpmCommandSize(cmd.buffer, total_length);
 
   ToTpmUint32(cmd.buffer + tpm_nv_write_cmd.index, index);
   ToTpmUint32(cmd.buffer + tpm_nv_write_cmd.length, length);
   Memcpy(cmd.buffer + tpm_nv_write_cmd.data, data, length);
 
   TlclSendReceive(cmd.buffer, response, sizeof(response));
   CheckResult(cmd.buffer, response, 1);
 
   return TpmReturnCode(response);
 }
@@ skipping 71 matching lines @@
 }
 
 uint32_t TlclClearEnable(void) {
   VBDEBUG(("TPM: Disabling TPM\n"));
   return Send(tpm_physicaldisable_cmd.buffer);
 }
 
 uint32_t TlclSetDeactivated(uint8_t flag) {
   struct s_tpm_physicalsetdeactivated_cmd cmd;
   VBDEBUG(("TPM: SetDeactivated(%d)\n", flag));
-  Memcpy(&cmd, &tpm_physicaldisable_cmd, sizeof(cmd));
+  Memcpy(&cmd, &tpm_physicalsetdeactivated_cmd, sizeof(cmd));
   *(cmd.buffer + cmd.deactivated) = flag;
   return Send(cmd.buffer);
 }
 
 uint32_t TlclGetFlags(uint8_t* disable, uint8_t* deactivated, uint8_t *nvlocked) {
   uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
   TPM_PERMANENT_FLAGS* pflags;
   uint32_t result;
   uint32_t size;
   VBDEBUG(("TPM: Get flags\n"));
@@ skipping 47 matching lines @@
   ToTpmUint32(cmd.buffer + tpm_getpermissions_cmd.index, index);
   TlclSendReceive(tpm_getpermissions_cmd.buffer, response, sizeof(response));
   result = TpmReturnCode(response);
   if (result != TPM_SUCCESS) {
     return result;
   }
   nvdata = response + kTpmResponseHeaderLength + sizeof(size);
   FromTpmUint32(nvdata + kNvDataPublicPermissionsOffset, permissions);
   return result;
 }