Exhaustive test for rollback code

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) {      \
       return result;                                    \
     }                                                   \
   } while (0)
 
-static uint32_t TPMClearAndReenable() {
+uint32_t TPMClearAndReenable(void) {
   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.
@@ skipping 13 matching lines @@
                                     TPM_NV_PER_PPWRITE, KERNEL_SPACE_SIZE));
   RETURN_ON_FAILURE(SafeWrite(KERNEL_VERSIONS_NV_INDEX, KERNEL_SPACE_INIT_DATA,
                               KERNEL_SPACE_SIZE));
   return TPM_SUCCESS;
 }
 
 /* When the return value is TPM_SUCCESS, this function sets *|initialized| to 1
  * if the spaces have been fully initialized, to 0 if not.  Otherwise
  * *|initialized| is not changed.
  */
-static uint32_t GetSpacesInitialized(int* initialized) {
+uint32_t GetSpacesInitialized(int* initialized) {
   uint32_t space_holder;
   uint32_t result;
   result = TlclRead(TPM_IS_INITIALIZED_NV_INDEX,
                     (uint8_t*) &space_holder, sizeof(space_holder));
   switch (result) {
   case TPM_SUCCESS:
     *initialized = 1;
     break;
   case TPM_E_BADINDEX:
     *initialized = 0;
@@ skipping 75 matching lines @@
   /* 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 ||
-      !Memcmp(buffer + sizeof(uint32_t), KERNEL_SPACE_UID,
-              KERNEL_SPACE_UID_SIZE)) {
+      Memcmp(buffer + sizeof(uint32_t), KERNEL_SPACE_UID,
+              KERNEL_SPACE_UID_SIZE) != 0) {
     return TPM_E_CORRUPTED_STATE;
   }
 
   if (must_use_backup) {
     /* We must use the backup space because in the preceding boot cycle the
      * primary space was left unlocked and cannot be trusted.
      */
     RETURN_ON_FAILURE(TlclRead(KERNEL_VERSIONS_BACKUP_NV_INDEX,
                                (uint8_t*) &backup_combined_versions,
                                sizeof(uint32_t)));
@@ skipping 57 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.
  */
 static uint32_t SetupTPM(int recovery_mode,
                          int developer_mode) {
   uint8_t disable;
   uint8_t deactivated;
+  uint32_t result;
 
   TlclLibInit();
   RETURN_ON_FAILURE(TlclStartup());
   RETURN_ON_FAILURE(TlclContinueSelfTest());
   RETURN_ON_FAILURE(TlclAssertPhysicalPresence());
   /* Checks that the TPM is enabled and activated. */
   RETURN_ON_FAILURE(TlclGetFlags(&disable, &deactivated));
   if (disable || deactivated) {
     RETURN_ON_FAILURE(TlclSetEnable());
     RETURN_ON_FAILURE(TlclSetDeactivated(0));
     return TPM_E_MUST_REBOOT;
   }
-  /* We expect this to fail the first time we run on a device, because the TPM
-   * has not been initialized yet.
-   */
-  if (RecoverKernelSpace() != TPM_SUCCESS) {
+  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;
     RETURN_ON_FAILURE(GetSpacesInitialized(&initialized));
     if (initialized) {
-      return TPM_E_ALREADY_INITIALIZED;
+      return result;
     } else {
       RETURN_ON_FAILURE(InitializeSpaces());
       RETURN_ON_FAILURE(RecoverKernelSpace());
     }
   }
   RETURN_ON_FAILURE(BackupKernelSpace());
   RETURN_ON_FAILURE(SetDistrustKernelSpaceAtNextBoot(recovery_mode));
   RETURN_ON_FAILURE(CheckDeveloperModeTransition(developer_mode));
 
   if (recovery_mode) {
@@ skipping 26 matching lines @@
   return SafeWrite(FIRMWARE_VERSIONS_NV_INDEX,
                    (uint8_t*) &combined_version,
                    sizeof(uint32_t));
 }
 
 uint32_t RollbackFirmwareLock(void) {
   return TlclSetGlobalLock();
 }
 
 uint32_t RollbackKernelRecovery(int developer_mode) {
-  (void) SetupTPM(1, developer_mode);
+  uint32_t result = SetupTPM(1, developer_mode);
   /* In recovery mode we ignore TPM malfunctions or corruptions, and leave the
    * TPM completely unlocked if and only if the dev mode switch is ON.  The
    * recovery kernel will fix the TPM (if needed) and lock it ASAP.  We leave
    * Physical Presence on in either case.
    */
   if (!developer_mode) {
     RETURN_ON_FAILURE(TlclSetGlobalLock());
   }
-  return TPM_SUCCESS;
+  /* We still return the result of SetupTPM even though we expect the caller to
+   * ignore it.  It's useful in unit testing.
+   */
+  return result;
 }
 
 uint32_t RollbackKernelRead(uint16_t* key_version, uint16_t* version) {
   uint32_t kernel_versions;
   if (g_rollback_recovery_mode) {
     *key_version = 0;
     *version = 0;
   } else {
     /* Reads kernel versions from TPM. */
     RETURN_ON_FAILURE(TlclRead(KERNEL_VERSIONS_NV_INDEX,
@@ skipping 15 matching lines @@
   return TPM_SUCCESS;
 }
 
 uint32_t RollbackKernelLock(void) {
   if (!g_rollback_recovery_mode) {
     return TlclLockPhysicalPresence();
   } else {
     return TPM_SUCCESS;
   }
 }