Add lots of debugging to TPM library.

firmware/lib/rollback_index.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.
  *
  * Functions for querying, manipulating and locking rollback indices
  * stored in the TPM NVRAM.
  */
 
 #include "rollback_index.h"
 
 #include "tlcl.h"
 #include "tss_constants.h"
 #include "utility.h"
 
 static int g_rollback_recovery_mode = 0;
 
 /* disable MSVC warning on const logical expression (as in } while(0);) */
 __pragma(warning (disable: 4127))
 
 #define RETURN_ON_FAILURE(tpm_command) do {             \
     uint32_t result;                                    \
     if ((result = (tpm_command)) != TPM_SUCCESS) {      \
       VBDEBUG(("Rollback: %08x returned by " #tpm_command "\n", (int)result)); \
       return result;                                    \
     }                                                   \
   } while (0)
 
 uint32_t TPMClearAndReenable(void) {
+  VBDEBUG(("TPM: Clear and re-enable\n"));
   RETURN_ON_FAILURE(TlclForceClear());
   RETURN_ON_FAILURE(TlclSetEnable());
   RETURN_ON_FAILURE(TlclSetDeactivated(0));
+  
   return TPM_SUCCESS;
 }
 
 /* Like TlclWrite(), but checks for write errors due to hitting the 64-write
  * limit and clears the TPM when that happens.  This can only happen when the
  * TPM is unowned, so it is OK to clear it (and we really have no choice).
  * This is not expected to happen frequently, but it could happen.
  */
 static uint32_t SafeWrite(uint32_t index, uint8_t* data, uint32_t length) {
   uint32_t result = TlclWrite(index, data, length);
@@ skipping 47 matching lines @@
     break;
   }
   return result;
 }
 
 /* Creates the NVRAM spaces, and sets their initial values as needed.
  */
 static uint32_t InitializeSpaces(void) {
   uint32_t zero = 0;
   uint32_t firmware_perm = TPM_NV_PER_GLOBALLOCK | TPM_NV_PER_PPWRITE;
+  uint8_t nvlocked = 0;
+  uint32_t i;
 
-  VBDEBUG(("Initializing spaces\n"));
+  VBDEBUG(("TPM: Initializing spaces\n"));
 
-  RETURN_ON_FAILURE(TlclSetNvLocked());
+#ifdef FORCE_CLEAR_ON_INIT
+  /* Force the TPM clear, in case it previously had an owner, so that we can
+   * redefine the NVRAM spaces. */
+  RETURN_ON_FAILURE(TPMClearAndReenable());
+#endif
+
+  /* The TPM will not enforce the NV authorization restrictions until the 
+   * execution of a TPM_NV_DefineSpace with the handle of TPM_NV_INDEX_LOCK.
+   * Create that space if it doesn't already exist. */
+  RETURN_ON_FAILURE(TlclGetFlags(NULL, NULL, &nvlocked));
+  VBDEBUG(("TPM: nvlocked=%d\n", nvlocked));
+  if (!nvlocked) {
+    VBDEBUG(("TPM: Enabling NV locking\n"));
+    RETURN_ON_FAILURE(TlclSetNvLocked());
+  }
+
+  /* If the spaces were previously defined, we need to undefine them before we
+   * can redefine them.  Undefine by setting size=0.  Ignore these return codes,
+   * since they fail if the spaces aren't actually defined? */
+  for (i = FIRST_ROLLBACK_NV_INDEX; i <= LAST_ROLLBACK_NV_INDEX; i++)
+    SafeDefineSpace(i, firmware_perm, 0);
 
   RETURN_ON_FAILURE(SafeDefineSpace(FIRMWARE_VERSIONS_NV_INDEX,
                                     firmware_perm, sizeof(uint32_t)));
   RETURN_ON_FAILURE(SafeWrite(FIRMWARE_VERSIONS_NV_INDEX,
                               (uint8_t*) &zero, sizeof(uint32_t)));
 
   RETURN_ON_FAILURE(InitializeKernelVersionsSpaces());
 
   /* The space KERNEL_VERSIONS_BACKUP_NV_INDEX is used to protect the kernel
    * versions.  The content of space KERNEL_MUST_USE_BACKUP determines whether
@@ skipping 36 matching lines @@
 /* Checks if the kernel version space has been mucked with.  If it has,
  * reconstructs it using the backup value.
  */
 uint32_t RecoverKernelSpace(void) {
   uint32_t perms = 0;
   uint8_t buffer[KERNEL_SPACE_SIZE];
   uint32_t backup_combined_versions;
   uint32_t must_use_backup;
   uint32_t zero = 0;
 
+  VBDEBUG(("TPM: RecoverKernelSpace()\n"));
+
   RETURN_ON_FAILURE(TlclRead(KERNEL_MUST_USE_BACKUP_NV_INDEX,
                              (uint8_t*) &must_use_backup, sizeof(uint32_t)));
   /* must_use_backup is true if the previous boot entered recovery mode. */
 
+  VBDEBUG(("TPM: must_use_backup = %d\n", must_use_backup));
+
   /* If we can't read the kernel space, or it has the wrong permission, or it
    * doesn't contain the right identifier, we give up.  This will need to be
    * fixed by the recovery kernel.  We have to worry about this because at any
    * time (even with PP turned off) the TPM owner can remove and redefine a
    * PP-protected space (but not write to it).
    */
   RETURN_ON_FAILURE(TlclRead(KERNEL_VERSIONS_NV_INDEX, (uint8_t*) &buffer,
                              KERNEL_SPACE_SIZE));
   RETURN_ON_FAILURE(TlclGetPermissions(KERNEL_VERSIONS_NV_INDEX, &perms));
   if (perms != TPM_NV_PER_PPWRITE ||
@@ skipping 14 matching lines @@
                                 sizeof(uint32_t)));
     RETURN_ON_FAILURE(SafeWrite(KERNEL_MUST_USE_BACKUP_NV_INDEX,
                                 (uint8_t*) &zero, 0));
   }
   return TPM_SUCCESS;
 }
 
 static uint32_t BackupKernelSpace(void) {
   uint32_t kernel_versions;
   uint32_t backup_versions;
+  VBDEBUG(("TPM: BackupKernelSpace()\n"));
   RETURN_ON_FAILURE(TlclRead(KERNEL_VERSIONS_NV_INDEX,
                              (uint8_t*) &kernel_versions, sizeof(uint32_t)));
   RETURN_ON_FAILURE(TlclRead(KERNEL_VERSIONS_BACKUP_NV_INDEX,
                              (uint8_t*) &backup_versions, sizeof(uint32_t)));
   if (kernel_versions == backup_versions) {
     return TPM_SUCCESS;
   } else if (kernel_versions < backup_versions) {
     /* This cannot happen.  We're screwed. */
     return TPM_E_INTERNAL_INCONSISTENCY;
   }
@@ skipping 36 matching lines @@
  * As a side note, observe that we go through considerable hoops to avoid using
  * the STCLEAR permissions for the index spaces.  We do this to avoid writing
  * to the TPM flashram at every reboot or wake-up, because of concerns about
  * the durability of the NVRAM.
  */
 uint32_t SetupTPM(int recovery_mode, int developer_mode) {
   uint8_t disable;
   uint8_t deactivated;
   uint32_t result;
 
+  VBDEBUG(("TPM: SetupTPM(r%d, d%d)\n", recovery_mode, developer_mode));
+
+  /* TODO: TlclLibInit() should be able to return failure */
   TlclLibInit();
+
   RETURN_ON_FAILURE(TlclStartup());
+#ifdef USE_CONTINUE_SELF_TEST
+  /* TODO: ContinueSelfTest() should be faster than SelfTestFull, but may also
+   * not work properly in older TPM firmware.  For now, do the full self test. */
   RETURN_ON_FAILURE(TlclContinueSelfTest());
+#else
+  RETURN_ON_FAILURE(TlclSelfTestFull());
+#endif
   RETURN_ON_FAILURE(TlclAssertPhysicalPresence());
   /* Checks that the TPM is enabled and activated. */
-  RETURN_ON_FAILURE(TlclGetFlags(&disable, &deactivated));
+  RETURN_ON_FAILURE(TlclGetFlags(&disable, &deactivated, NULL));
   if (disable || deactivated) {
+    VBDEBUG(("TPM: disabled (%d) or deactivated (%d).  Fixing...\n", disable, deactivated));
     RETURN_ON_FAILURE(TlclSetEnable());
     RETURN_ON_FAILURE(TlclSetDeactivated(0));
+    VBDEBUG(("TPM: Must reboot to re-enable\n"));
     return TPM_E_MUST_REBOOT;
   }
   result = RecoverKernelSpace();
   if (result != TPM_SUCCESS) {
      /* Check if this is the first time we run and the TPM has not been
       * initialized yet.
       */
     int initialized = 0;
+    VBDEBUG(("TPM: RecoverKernelSpace() failed\n"));
     RETURN_ON_FAILURE(GetSpacesInitialized(&initialized));
     if (initialized) {
+      VBDEBUG(("TPM: Already initialized, so give up\n"));
       return result;
     } else {
+      VBDEBUG(("TPM: Need to initialize spaces.\n"));
       RETURN_ON_FAILURE(InitializeSpaces());
+      VBDEBUG(("TPM: Retrying RecoverKernelSpace() now that spaces are initialized.\n"));
       RETURN_ON_FAILURE(RecoverKernelSpace());
     }
   }
   RETURN_ON_FAILURE(BackupKernelSpace());
   RETURN_ON_FAILURE(SetDistrustKernelSpaceAtNextBoot(recovery_mode));
   RETURN_ON_FAILURE(CheckDeveloperModeTransition(developer_mode));
 
   if (recovery_mode) {
     /* In recovery mode global variables are usable. */
     g_rollback_recovery_mode = 1;
   }
+  VBDEBUG(("TPM: SetupTPM() succeeded\n"));
   return TPM_SUCCESS;
 }
 
 /* disable MSVC warnings on unused arguments */
 __pragma(warning (disable: 4100))
 
 
 #ifdef DISABLE_ROLLBACK_TPM
 
 /* Dummy implementations which don't call into the tpm_lite library */
@@ skipping 104 matching lines @@
 
 uint32_t RollbackKernelLock(void) {
   if (!g_rollback_recovery_mode) {
     return TlclLockPhysicalPresence();
   } else {
     return TPM_SUCCESS;
   }
 }
 
 #endif // DISABLE_ROLLBACK_TPM