scottk/OpenCellular
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/OpenCellular.git synced 2025-12-02 14:14:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Improve coverage of rollback_index.c

Browse Source 
BUG=chromium-os:38139
BRANCH=none
TEST=make runtests

Change-Id: I21b62b5dd3fc6037f54f7c3bac768c2b67a4c12d
Signed-off-by: Randall Spangler <rspangler@chromium.org>
Reviewed-on: https://gerrit.chromium.org/gerrit/41859
Reviewed-by: Bill Richardson <wfrichar@chromium.org>
This commit is contained in:
Randall Spangler
2013-01-23 13:04:05 -08:00
committed by ChromeBot
parent 6dbf9d9160
commit a3eac79f50
4 changed files with 1281 additions and 1091 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@@ -405,6 +405,7 @@ ALL_OBJS += ${TESTLIB_OBJS}
TEST_NAMES = \ TEST_NAMES = \
cgptlib_test \ cgptlib_test \
rollback_index2_tests \ rollback_index2_tests \
rollback_index3_tests \
rsa_padding_test \ rsa_padding_test \
rsa_utility_tests \ rsa_utility_tests \
rsa_verify_benchmark \ rsa_verify_benchmark \
@@ -932,6 +933,7 @@ runtestscripts: test_setup genfuzztestcases
.PHONY: runmisctests .PHONY: runmisctests
runmisctests: test_setup runmisctests: test_setup
${RUNTEST} ${BUILD_RUN}/tests/rollback_index2_tests ${RUNTEST} ${BUILD_RUN}/tests/rollback_index2_tests
${RUNTEST} ${BUILD_RUN}/tests/rollback_index3_tests
${RUNTEST} ${BUILD_RUN}/tests/rsa_utility_tests ${RUNTEST} ${BUILD_RUN}/tests/rsa_utility_tests
${RUNTEST} ${BUILD_RUN}/tests/sha_tests ${RUNTEST} ${BUILD_RUN}/tests/sha_tests
${RUNTEST} ${BUILD_RUN}/tests/stateful_util_tests ${RUNTEST} ${BUILD_RUN}/tests/stateful_util_tests

821
firmware/lib/rollback_index.c
View File

@@ -1,4 +1,4 @@
/* Copyright (c) 2012 The Chromium OS Authors. All rights reserved. /* Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be * Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file. * found in the LICENSE file.
* *
@@ -39,246 +39,281 @@ __pragma(warning (disable: 4127))
} while (0) } while (0)
uint32_t TPMClearAndReenable(void) { uint32_t TPMClearAndReenable(void)
VBDEBUG(("TPM: Clear and re-enable\n")); {
RETURN_ON_FAILURE(TlclForceClear()); VBDEBUG(("TPM: Clear and re-enable\n"));
RETURN_ON_FAILURE(TlclSetEnable()); RETURN_ON_FAILURE(TlclForceClear());
RETURN_ON_FAILURE(TlclSetDeactivated(0)); RETURN_ON_FAILURE(TlclSetEnable());
RETURN_ON_FAILURE(TlclSetDeactivated(0));
return TPM_SUCCESS; return TPM_SUCCESS;
} }
uint32_t SafeWrite(uint32_t index, const void *data, uint32_t length)
uint32_t SafeWrite(uint32_t index, const void* data, uint32_t length) { {
uint32_t result = TlclWrite(index, data, length); uint32_t result = TlclWrite(index, data, length);
if (result == TPM_E_MAXNVWRITES) { if (result == TPM_E_MAXNVWRITES) {
RETURN_ON_FAILURE(TPMClearAndReenable()); RETURN_ON_FAILURE(TPMClearAndReenable());
return TlclWrite(index, data, length); return TlclWrite(index, data, length);
} else { } else {
return result; return result;
} }
} }
uint32_t SafeDefineSpace(uint32_t index, uint32_t perm, uint32_t size)
uint32_t SafeDefineSpace(uint32_t index, uint32_t perm, uint32_t size) { {
uint32_t result = TlclDefineSpace(index, perm, size); uint32_t result = TlclDefineSpace(index, perm, size);
if (result == TPM_E_MAXNVWRITES) { if (result == TPM_E_MAXNVWRITES) {
RETURN_ON_FAILURE(TPMClearAndReenable()); RETURN_ON_FAILURE(TPMClearAndReenable());
return TlclDefineSpace(index, perm, size); return TlclDefineSpace(index, perm, size);
} else { } else {
return result; return result;
} }
} }
/* Functions to read and write firmware and kernel spaces. */ /* Functions to read and write firmware and kernel spaces. */
uint32_t ReadSpaceFirmware(RollbackSpaceFirmware* rsf) { uint32_t ReadSpaceFirmware(RollbackSpaceFirmware *rsf)
uint32_t r; {
int attempts = 3; uint32_t r;
int attempts = 3;
while (attempts--) { while (attempts--) {
r = TlclRead(FIRMWARE_NV_INDEX, rsf, sizeof(RollbackSpaceFirmware)); r = TlclRead(FIRMWARE_NV_INDEX, rsf,
if (r != TPM_SUCCESS) sizeof(RollbackSpaceFirmware));
return r; if (r != TPM_SUCCESS)
return r;
/* No CRC in this version, so we'll create one when we write it. Note that /*
* we're marking this as version 2, not ROLLBACK_SPACE_FIRMWARE_VERSION, * No CRC in this version, so we'll create one when we write
* because version 2 just added the CRC. Later versions will need to * it. Note that we're marking this as version 2, not
* set default values for any extra fields explicitly (probably here). */ * ROLLBACK_SPACE_FIRMWARE_VERSION, because version 2 just
if (rsf->struct_version < 2) { * added the CRC. Later versions will need to set default
rsf->struct_version = 2; /* Danger Will Robinson! Danger! */ * values for any extra fields explicitly (probably here).
return TPM_SUCCESS; */
} if (rsf->struct_version < 2) {
/* Danger Will Robinson! Danger! */
rsf->struct_version = 2;
return TPM_SUCCESS;
}
/* If the CRC is good, we're done. If it's bad, try a couple more times to /*
* see if it gets better before we give up. It could just be noise. */ * If the CRC is good, we're done. If it's bad, try a couple
if (rsf->crc8 == Crc8(rsf, offsetof(RollbackSpaceFirmware, crc8))) * more times to see if it gets better before we give up. It
return TPM_SUCCESS; * could just be noise.
*/
if (rsf->crc8 == Crc8(rsf,
offsetof(RollbackSpaceFirmware, crc8)))
return TPM_SUCCESS;
VBDEBUG(("TPM: %s() - bad CRC\n", __func__)); VBDEBUG(("TPM: %s() - bad CRC\n", __func__));
} }
VBDEBUG(("TPM: %s() - too many bad CRCs, giving up\n", __func__)); VBDEBUG(("TPM: %s() - too many bad CRCs, giving up\n", __func__));
return TPM_E_CORRUPTED_STATE; return TPM_E_CORRUPTED_STATE;
} }
uint32_t WriteSpaceFirmware(RollbackSpaceFirmware* rsf) { uint32_t WriteSpaceFirmware(RollbackSpaceFirmware *rsf)
RollbackSpaceFirmware rsf2; {
uint32_t r; RollbackSpaceFirmware rsf2;
int attempts = 3; uint32_t r;
int attempts = 3;
/* All writes should use struct_version 2 or greater. */ /* All writes should use struct_version 2 or greater. */
if (rsf->struct_version < 2) if (rsf->struct_version < 2)
rsf->struct_version = 2; rsf->struct_version = 2;
rsf->crc8 = Crc8(rsf, offsetof(RollbackSpaceFirmware, crc8)); rsf->crc8 = Crc8(rsf, offsetof(RollbackSpaceFirmware, crc8));
while (attempts--) { while (attempts--) {
r = SafeWrite(FIRMWARE_NV_INDEX, rsf, sizeof(RollbackSpaceFirmware)); r = SafeWrite(FIRMWARE_NV_INDEX, rsf,
/* Can't write, not gonna try again */ sizeof(RollbackSpaceFirmware));
if (r != TPM_SUCCESS) /* Can't write, not gonna try again */
return r; if (r != TPM_SUCCESS)
return r;
/* Read it back to be sure it got the right values. */ /* Read it back to be sure it got the right values. */
r = ReadSpaceFirmware(&rsf2); /* This checks the CRC */ r = ReadSpaceFirmware(&rsf2); /* This checks the CRC */
if (r == TPM_SUCCESS) if (r == TPM_SUCCESS)
return r; return r;
VBDEBUG(("TPM: %s() - bad CRC\n", __func__)); VBDEBUG(("TPM: %s() - bad CRC\n", __func__));
/* Try writing it again. Maybe it was garbled on the way out. */ /* Try writing it again. Maybe it was garbled on the way out. */
} }
VBDEBUG(("TPM: %s() - too many bad CRCs, giving up\n", __func__)); VBDEBUG(("TPM: %s() - too many bad CRCs, giving up\n", __func__));
return TPM_E_CORRUPTED_STATE; return TPM_E_CORRUPTED_STATE;
} }
uint32_t SetVirtualDevMode(int val) { uint32_t SetVirtualDevMode(int val)
RollbackSpaceFirmware rsf; {
RollbackSpaceFirmware rsf;
VBDEBUG(("TPM: Entering %s()\n", __func__)); VBDEBUG(("TPM: Entering %s()\n", __func__));
if (TPM_SUCCESS != ReadSpaceFirmware(&rsf)) if (TPM_SUCCESS != ReadSpaceFirmware(&rsf))
return VBERROR_TPM_FIRMWARE_SETUP; return VBERROR_TPM_FIRMWARE_SETUP;
VBDEBUG(("TPM: flags were 0x%02x\n", rsf.flags)); VBDEBUG(("TPM: flags were 0x%02x\n", rsf.flags));
if (val) if (val)
rsf.flags |= FLAG_VIRTUAL_DEV_MODE_ON; rsf.flags |= FLAG_VIRTUAL_DEV_MODE_ON;
else else
rsf.flags &= ~FLAG_VIRTUAL_DEV_MODE_ON; rsf.flags &= ~FLAG_VIRTUAL_DEV_MODE_ON;
/* NOTE: This doesn't update the FLAG_LAST_BOOT_DEVELOPER bit */ /*
VBDEBUG(("TPM: flags are now 0x%02x\n", rsf.flags)); * NOTE: This doesn't update the FLAG_LAST_BOOT_DEVELOPER bit. That
* will be done by SetupTPM() on the next boot.
*/
VBDEBUG(("TPM: flags are now 0x%02x\n", rsf.flags));
if (TPM_SUCCESS != WriteSpaceFirmware(&rsf)) if (TPM_SUCCESS != WriteSpaceFirmware(&rsf))
return VBERROR_TPM_SET_BOOT_MODE_STATE; return VBERROR_TPM_SET_BOOT_MODE_STATE;
VBDEBUG(("TPM: Leaving %s()\n", __func__)); VBDEBUG(("TPM: Leaving %s()\n", __func__));
return VBERROR_SUCCESS; return VBERROR_SUCCESS;
} }
uint32_t ReadSpaceKernel(RollbackSpaceKernel* rsk) { uint32_t ReadSpaceKernel(RollbackSpaceKernel *rsk)
uint32_t r; {
int attempts = 3; uint32_t r;
int attempts = 3;
while (attempts--) { while (attempts--) {
r = TlclRead(KERNEL_NV_INDEX, rsk, sizeof(RollbackSpaceKernel)); r = TlclRead(KERNEL_NV_INDEX, rsk, sizeof(RollbackSpaceKernel));
if (r != TPM_SUCCESS) if (r != TPM_SUCCESS)
return r; return r;
/* No CRC in this version, so we'll create one when we write it. Note that /*
* we're marking this as version 2, not ROLLBACK_SPACE_KERNEL_VERSION, * No CRC in this version, so we'll create one when we write
* because version 2 just added the CRC. Later versions will need to * it. Note that we're marking this as version 2, not
* set default values for any extra fields explicitly (probably here). */ * ROLLBACK_SPACE_KERNEL_VERSION, because version 2 just added
if (rsk->struct_version < 2) { * the CRC. Later versions will need to set default values for
rsk->struct_version = 2; /* Danger Will Robinson! Danger! */ * any extra fields explicitly (probably here).
return TPM_SUCCESS; */
} if (rsk->struct_version < 2) {
/* Danger Will Robinson! Danger! */
rsk->struct_version = 2;
return TPM_SUCCESS;
}
/* If the CRC is good, we're done. If it's bad, try a couple more times to /*
* see if it gets better before we give up. It could just be noise. */ * If the CRC is good, we're done. If it's bad, try a couple
if (rsk->crc8 == Crc8(rsk, offsetof(RollbackSpaceKernel, crc8))) * more times to see if it gets better before we give up. It
return TPM_SUCCESS; * could just be noise.
*/
if (rsk->crc8 == Crc8(rsk, offsetof(RollbackSpaceKernel, crc8)))
return TPM_SUCCESS;
VBDEBUG(("TPM: %s() - bad CRC\n", __func__)); VBDEBUG(("TPM: %s() - bad CRC\n", __func__));
} }
VBDEBUG(("TPM: %s() - too many bad CRCs, giving up\n", __func__)); VBDEBUG(("TPM: %s() - too many bad CRCs, giving up\n", __func__));
return TPM_E_CORRUPTED_STATE; return TPM_E_CORRUPTED_STATE;
} }
uint32_t WriteSpaceKernel(RollbackSpaceKernel* rsk) { uint32_t WriteSpaceKernel(RollbackSpaceKernel *rsk)
RollbackSpaceKernel rsk2; {
uint32_t r; RollbackSpaceKernel rsk2;
int attempts = 3; uint32_t r;
int attempts = 3;
/* All writes should use struct_version 2 or greater. */ /* All writes should use struct_version 2 or greater. */
if (rsk->struct_version < 2) if (rsk->struct_version < 2)
rsk->struct_version = 2; rsk->struct_version = 2;
rsk->crc8 = Crc8(rsk, offsetof(RollbackSpaceKernel, crc8)); rsk->crc8 = Crc8(rsk, offsetof(RollbackSpaceKernel, crc8));
while (attempts--) { while (attempts--) {
r = SafeWrite(KERNEL_NV_INDEX, rsk, sizeof(RollbackSpaceKernel)); r = SafeWrite(KERNEL_NV_INDEX, rsk,
/* Can't write, not gonna try again */ sizeof(RollbackSpaceKernel));
if (r != TPM_SUCCESS) /* Can't write, not gonna try again */
return r; if (r != TPM_SUCCESS)
return r;
/* Read it back to be sure it got the right values. */ /* Read it back to be sure it got the right values. */
r = ReadSpaceKernel(&rsk2); /* This checks the CRC */ r = ReadSpaceKernel(&rsk2); /* This checks the CRC */
if (r == TPM_SUCCESS) if (r == TPM_SUCCESS)
return r; return r;
VBDEBUG(("TPM: %s() - bad CRC\n", __func__)); VBDEBUG(("TPM: %s() - bad CRC\n", __func__));
/* Try writing it again. Maybe it was garbled on the way out. */ /* Try writing it again. Maybe it was garbled on the way out. */
} }
VBDEBUG(("TPM: %s() - too many bad CRCs, giving up\n", __func__)); VBDEBUG(("TPM: %s() - too many bad CRCs, giving up\n", __func__));
return TPM_E_CORRUPTED_STATE; return TPM_E_CORRUPTED_STATE;
}
uint32_t OneTimeInitializeTPM(RollbackSpaceFirmware *rsf,
RollbackSpaceKernel *rsk)
{
static const RollbackSpaceFirmware rsf_init = {
.struct_version = ROLLBACK_SPACE_FIRMWARE_VERSION,
};
static const RollbackSpaceKernel rsk_init = {
.struct_version = ROLLBACK_SPACE_KERNEL_VERSION,
.uid = ROLLBACK_SPACE_KERNEL_UID,
};
TPM_PERMANENT_FLAGS pflags;
uint32_t result;
VBDEBUG(("TPM: One-time initialization\n"));
/*
* Do a full test. This only happens the first time the device is
* turned on in the factory, so performance is not an issue. This is
* almost certainly not necessary, but it gives us more confidence
* about some code paths below that are difficult to
* test---specifically the ones that set lifetime flags, and are only
* executed once per physical TPM.
*/
result = TlclSelfTestFull();
if (result != TPM_SUCCESS)
return result;
result = TlclGetPermanentFlags(&pflags);
if (result != TPM_SUCCESS)
return result;
/*
* TPM may come from the factory without physical presence finalized.
* Fix if necessary.
*/
VBDEBUG(("TPM: physicalPresenceLifetimeLock=%d\n",
pflags.physicalPresenceLifetimeLock));
if (!pflags.physicalPresenceLifetimeLock) {
VBDEBUG(("TPM: Finalizing physical presence\n"));
RETURN_ON_FAILURE(TlclFinalizePhysicalPresence());
}
/*
* 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. Here we create that space if it doesn't already
* exist. */
VBDEBUG(("TPM: nvLocked=%d\n", pflags.nvLocked));
if (!pflags.nvLocked) {
VBDEBUG(("TPM: Enabling NV locking\n"));
RETURN_ON_FAILURE(TlclSetNvLocked());
}
/* Clear TPM owner, in case the TPM is already owned for some reason. */
VBDEBUG(("TPM: Clearing owner\n"));
RETURN_ON_FAILURE(TPMClearAndReenable());
/* Initializes the firmware and kernel spaces */
Memcpy(rsf, &rsf_init, sizeof(RollbackSpaceFirmware));
Memcpy(rsk, &rsk_init, sizeof(RollbackSpaceKernel));
/* Defines and sets firmware and kernel spaces */
RETURN_ON_FAILURE(SafeDefineSpace(KERNEL_NV_INDEX, TPM_NV_PER_PPWRITE,
sizeof(RollbackSpaceKernel)));
RETURN_ON_FAILURE(WriteSpaceKernel(rsk));
RETURN_ON_FAILURE(SafeDefineSpace(
FIRMWARE_NV_INDEX,
TPM_NV_PER_GLOBALLOCK | TPM_NV_PER_PPWRITE,
sizeof(RollbackSpaceFirmware)));
RETURN_ON_FAILURE(WriteSpaceFirmware(rsf));
return TPM_SUCCESS;
} }
uint32_t OneTimeInitializeTPM(RollbackSpaceFirmware* rsf, /*
RollbackSpaceKernel* rsk) { * SetupTPM starts the TPM and establishes the root of trust for the
static const RollbackSpaceFirmware rsf_init = {
.struct_version = ROLLBACK_SPACE_FIRMWARE_VERSION,
};
static const RollbackSpaceKernel rsk_init = {
.struct_version = ROLLBACK_SPACE_KERNEL_VERSION,
.uid = ROLLBACK_SPACE_KERNEL_UID,
};
TPM_PERMANENT_FLAGS pflags;
uint32_t result;
VBDEBUG(("TPM: One-time initialization\n"));
/* Do a full test. This only happens the first time the device is turned on
* in the factory, so performance is not an issue. This is almost certainly
* not necessary, but it gives us more confidence about some code paths below
* that are difficult to test---specifically the ones that set lifetime
* flags, and are only executed once per physical TPM. */
result = TlclSelfTestFull();
if (result != TPM_SUCCESS)
return result;
result = TlclGetPermanentFlags(&pflags);
if (result != TPM_SUCCESS)
return result;
/* TPM may come from the factory without physical presence finalized. Fix
* if necessary. */
VBDEBUG(("TPM: physicalPresenceLifetimeLock=%d\n",
pflags.physicalPresenceLifetimeLock));
if (!pflags.physicalPresenceLifetimeLock) {
VBDEBUG(("TPM: Finalizing physical presence\n"));
RETURN_ON_FAILURE(TlclFinalizePhysicalPresence());
}
/* 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.
* Here we create that space if it doesn't already exist. */
VBDEBUG(("TPM: nvLocked=%d\n", pflags.nvLocked));
if (!pflags.nvLocked) {
VBDEBUG(("TPM: Enabling NV locking\n"));
RETURN_ON_FAILURE(TlclSetNvLocked());
}
/* Clear TPM owner, in case the TPM is already owned for some reason. */
VBDEBUG(("TPM: Clearing owner\n"));
RETURN_ON_FAILURE(TPMClearAndReenable());
/* Initializes the firmware and kernel spaces */
Memcpy(rsf, &rsf_init, sizeof(RollbackSpaceFirmware));
Memcpy(rsk, &rsk_init, sizeof(RollbackSpaceKernel));
/* Defines and sets firmware and kernel spaces */
RETURN_ON_FAILURE(SafeDefineSpace(KERNEL_NV_INDEX, TPM_NV_PER_PPWRITE,
sizeof(RollbackSpaceKernel)));
RETURN_ON_FAILURE(WriteSpaceKernel(rsk));
RETURN_ON_FAILURE(SafeDefineSpace(FIRMWARE_NV_INDEX,
TPM_NV_PER_GLOBALLOCK | TPM_NV_PER_PPWRITE,
sizeof(RollbackSpaceFirmware)));
RETURN_ON_FAILURE(WriteSpaceFirmware(rsf));
return TPM_SUCCESS;
}
/* SetupTPM starts the TPM and establishes the root of trust for the
* anti-rollback mechanism. SetupTPM can fail for three reasons. 1 A bug. 2 a * anti-rollback mechanism. SetupTPM can fail for three reasons. 1 A bug. 2 a
* TPM hardware failure. 3 An unexpected TPM state due to some attack. In * TPM hardware failure. 3 An unexpected TPM state due to some attack. In
* general we cannot easily distinguish the kind of failure, so our strategy is * general we cannot easily distinguish the kind of failure, so our strategy is
@@ -299,38 +334,40 @@ uint32_t OneTimeInitializeTPM(RollbackSpaceFirmware* rsf,
*/ */
uint32_t SetupTPM(int recovery_mode, int developer_mode, uint32_t SetupTPM(int recovery_mode, int developer_mode,
int disable_dev_request, int clear_tpm_owner_request, int disable_dev_request, int clear_tpm_owner_request,
RollbackSpaceFirmware* rsf) { RollbackSpaceFirmware* rsf)
{
uint8_t in_flags;
uint8_t disable;
uint8_t deactivated;
uint32_t result;
uint8_t in_flags; VBDEBUG(("TPM: SetupTPM(r%d, d%d)\n", recovery_mode, developer_mode));
uint8_t disable;
uint8_t deactivated;
uint32_t result;
VBDEBUG(("TPM: SetupTPM(r%d, d%d)\n", recovery_mode, developer_mode)); /* Global variables are usable in recovery mode */
if (recovery_mode)
g_rollback_recovery_mode = 1;
if (recovery_mode) RETURN_ON_FAILURE(TlclLibInit());
g_rollback_recovery_mode = 1; /* Global variables are usable in
* recovery mode */
RETURN_ON_FAILURE(TlclLibInit());
#ifdef TEGRA_SOFT_REBOOT_WORKAROUND #ifdef TEGRA_SOFT_REBOOT_WORKAROUND
result = TlclStartup(); result = TlclStartup();
if (result == TPM_E_INVALID_POSTINIT) { if (result == TPM_E_INVALID_POSTINIT) {
/* Some prototype hardware doesn't reset the TPM on a CPU reset. We do a /*
* hard reset to get around this. * Some prototype hardware doesn't reset the TPM on a CPU
*/ * reset. We do a hard reset to get around this.
VBDEBUG(("TPM: soft reset detected\n", result)); */
return TPM_E_MUST_REBOOT; VBDEBUG(("TPM: soft reset detected\n", result));
} else if (result != TPM_SUCCESS) { return TPM_E_MUST_REBOOT;
VBDEBUG(("TPM: TlclStartup returned %08x\n", result)); } else if (result != TPM_SUCCESS) {
return result; VBDEBUG(("TPM: TlclStartup returned %08x\n", result));
} return result;
}
#else #else
RETURN_ON_FAILURE(TlclStartup()); RETURN_ON_FAILURE(TlclStartup());
#endif #endif
/* Some TPMs start the self test automatically at power on. In that case we /*
* Some TPMs start the self test automatically at power on. In that case we
* don't need to call ContinueSelfTest. On some (other) TPMs, * don't need to call ContinueSelfTest. On some (other) TPMs,
* ContinueSelfTest may block. In that case, we definitely don't want to * ContinueSelfTest may block. In that case, we definitely don't want to
* call it here. For TPMs in the intersection of these two sets, we're * call it here. For TPMs in the intersection of these two sets, we're
@@ -346,225 +383,249 @@ uint32_t SetupTPM(int recovery_mode, int developer_mode,
#ifdef TPM_BLOCKING_CONTINUESELFTEST #ifdef TPM_BLOCKING_CONTINUESELFTEST
#warning "lousy TPM!" #warning "lousy TPM!"
#endif #endif
RETURN_ON_FAILURE(TlclContinueSelfTest()); RETURN_ON_FAILURE(TlclContinueSelfTest());
#endif #endif
result = TlclAssertPhysicalPresence(); result = TlclAssertPhysicalPresence();
if (result != TPM_SUCCESS) { if (result != TPM_SUCCESS) {
/* It is possible that the TPM was delivered with the physical presence /*
* command disabled. This tries enabling it, then tries asserting PP * It is possible that the TPM was delivered with the physical
* again. * presence command disabled. This tries enabling it, then
*/ * tries asserting PP again.
RETURN_ON_FAILURE(TlclPhysicalPresenceCMDEnable()); */
RETURN_ON_FAILURE(TlclAssertPhysicalPresence()); RETURN_ON_FAILURE(TlclPhysicalPresenceCMDEnable());
} RETURN_ON_FAILURE(TlclAssertPhysicalPresence());
}
/* Checks that the TPM is enabled and activated. */ /* Check that the TPM is enabled and activated. */
RETURN_ON_FAILURE(TlclGetFlags(&disable, &deactivated, NULL)); RETURN_ON_FAILURE(TlclGetFlags(&disable, &deactivated, NULL));
if (disable || deactivated) { if (disable || deactivated) {
VBDEBUG(("TPM: disabled (%d) or deactivated (%d). Fixing...\n", VBDEBUG(("TPM: disabled (%d) or deactivated (%d). Fixing...\n",
disable, deactivated)); disable, deactivated));
RETURN_ON_FAILURE(TlclSetEnable()); RETURN_ON_FAILURE(TlclSetEnable());
RETURN_ON_FAILURE(TlclSetDeactivated(0)); RETURN_ON_FAILURE(TlclSetDeactivated(0));
VBDEBUG(("TPM: Must reboot to re-enable\n")); VBDEBUG(("TPM: Must reboot to re-enable\n"));
return TPM_E_MUST_REBOOT; return TPM_E_MUST_REBOOT;
} }
/* Reads the firmware space. */ /* Read the firmware space. */
result = ReadSpaceFirmware(rsf); result = ReadSpaceFirmware(rsf);
if (TPM_E_BADINDEX == result) { if (TPM_E_BADINDEX == result) {
RollbackSpaceKernel rsk; RollbackSpaceKernel rsk;
/* This is the first time we've run, and the TPM has not been /*
* initialized. This initializes it. */ * This is the first time we've run, and the TPM has not been
VBDEBUG(("TPM: Not initialized yet.\n")); * initialized. Initialize it.
RETURN_ON_FAILURE(OneTimeInitializeTPM(rsf, &rsk)); */
} else if (TPM_SUCCESS != result) { VBDEBUG(("TPM: Not initialized yet.\n"));
VBDEBUG(("TPM: Firmware space in a bad state; giving up.\n")); RETURN_ON_FAILURE(OneTimeInitializeTPM(rsf, &rsk));
return TPM_E_CORRUPTED_STATE; } else if (TPM_SUCCESS != result) {
} VBDEBUG(("TPM: Firmware space in a bad state; giving up.\n"));
VBDEBUG(("TPM: Firmware space sv%d f%x v%x\n", return TPM_E_CORRUPTED_STATE;
rsf->struct_version, rsf->flags, rsf->fw_versions)); }
in_flags = rsf->flags; VBDEBUG(("TPM: Firmware space sv%d f%x v%x\n",
rsf->struct_version, rsf->flags, rsf->fw_versions));
in_flags = rsf->flags;
/* If we've been asked to clear the virtual dev-mode flag, do so now */ /* If we've been asked to clear the virtual dev-mode flag, do so now */
if (disable_dev_request) { if (disable_dev_request) {
rsf->flags &= ~FLAG_VIRTUAL_DEV_MODE_ON; rsf->flags &= ~FLAG_VIRTUAL_DEV_MODE_ON;
VBDEBUG(("TPM: Clearing virt dev-switch: f%x\n", rsf->flags)); VBDEBUG(("TPM: Clearing virt dev-switch: f%x\n", rsf->flags));
} }
/* The developer_mode value that's passed in is only set by a hardware /*
* dev-switch. We should OR it with the virtual switch, whether or not the * The developer_mode value that's passed in is only set by a hardware
* virtual switch is used. If it's not used, it shouldn't change, so it * dev-switch. We should OR it with the virtual switch, whether or not
* doesn't matter. */ * the virtual switch is used. If it's not used, it shouldn't change,
if (rsf->flags & FLAG_VIRTUAL_DEV_MODE_ON) * so it doesn't matter.
developer_mode = 1; */
if (rsf->flags & FLAG_VIRTUAL_DEV_MODE_ON)
developer_mode = 1;
/* Clears ownership if developer flag has toggled, or if an owner-clear has /*
* been requested. */ * Clear ownership if developer flag has toggled, or if an owner-clear
if ((developer_mode ? FLAG_LAST_BOOT_DEVELOPER : 0) != * has been requested.
(in_flags & FLAG_LAST_BOOT_DEVELOPER)) { */
VBDEBUG(("TPM: Developer flag changed; clearing owner.\n")); if ((developer_mode ? FLAG_LAST_BOOT_DEVELOPER : 0) !=
RETURN_ON_FAILURE(TPMClearAndReenable()); (in_flags & FLAG_LAST_BOOT_DEVELOPER)) {
} else if (clear_tpm_owner_request) { VBDEBUG(("TPM: Developer flag changed; clearing owner.\n"));
VBDEBUG(("TPM: Clearing owner as specifically requested.\n")); RETURN_ON_FAILURE(TPMClearAndReenable());
RETURN_ON_FAILURE(TPMClearAndReenable()); } else if (clear_tpm_owner_request) {
} VBDEBUG(("TPM: Clearing owner as specifically requested.\n"));
RETURN_ON_FAILURE(TPMClearAndReenable());
}
if (developer_mode) if (developer_mode)
rsf->flags |= FLAG_LAST_BOOT_DEVELOPER; rsf->flags |= FLAG_LAST_BOOT_DEVELOPER;
else else
rsf->flags &= ~FLAG_LAST_BOOT_DEVELOPER; rsf->flags &= ~FLAG_LAST_BOOT_DEVELOPER;
/* If firmware space is dirty, this flushes it back to the TPM */ /* If firmware space is dirty, flush it back to the TPM */
if (rsf->flags != in_flags) { if (rsf->flags != in_flags) {
VBDEBUG(("TPM: Updating firmware space.\n")); VBDEBUG(("TPM: Updating firmware space.\n"));
RETURN_ON_FAILURE(WriteSpaceFirmware(rsf)); RETURN_ON_FAILURE(WriteSpaceFirmware(rsf));
} }
VBDEBUG(("TPM: SetupTPM() succeeded\n")); VBDEBUG(("TPM: SetupTPM() succeeded\n"));
return TPM_SUCCESS; return TPM_SUCCESS;
} }
/* disable MSVC warnings on unused arguments */ /* Disable MSVC warnings on unused arguments */
__pragma(warning (disable: 4100)) __pragma(warning (disable: 4100))
#ifdef DISABLE_ROLLBACK_TPM #ifdef DISABLE_ROLLBACK_TPM
/* Dummy implementations which don't support TPM rollback protection */ /* Dummy implementations which don't support TPM rollback protection */
uint32_t RollbackS3Resume(void) { uint32_t RollbackS3Resume(void)
{
#ifndef CHROMEOS_ENVIRONMENT #ifndef CHROMEOS_ENVIRONMENT
/* Initialize the TPM, but ignore return codes. In ChromeOS /*
* environment, don't even talk to the TPM. */ * Initialize the TPM, but ignore return codes. In ChromeOS
TlclLibInit(); * environment, don't even talk to the TPM.
TlclResume(); */
TlclLibInit();
TlclResume();
#endif #endif
return TPM_SUCCESS; return TPM_SUCCESS;
} }
uint32_t RollbackFirmwareSetup(int recovery_mode, int is_hw_dev, uint32_t RollbackFirmwareSetup(int recovery_mode, int is_hw_dev,
int disable_dev_request, int disable_dev_request,
int clear_tpm_owner_request, int clear_tpm_owner_request,
int *is_virt_dev, uint32_t *version) { int *is_virt_dev, uint32_t *version)
{
#ifndef CHROMEOS_ENVIRONMENT #ifndef CHROMEOS_ENVIRONMENT
/* Initialize the TPM, but ignores return codes. In ChromeOS /*
* environment, don't even talk to the TPM. */ * Initialize the TPM, but ignores return codes. In ChromeOS
TlclLibInit(); * environment, don't even talk to the TPM.
TlclStartup(); */
TlclContinueSelfTest(); TlclLibInit();
TlclStartup();
TlclContinueSelfTest();
#endif #endif
*version = 0; *is_virt_dev = 0;
return TPM_SUCCESS; *version = 0;
return TPM_SUCCESS;
} }
uint32_t RollbackFirmwareRead(uint32_t* version) { uint32_t RollbackFirmwareWrite(uint32_t version)
*version = 0; {
return TPM_SUCCESS; return TPM_SUCCESS;
} }
uint32_t RollbackFirmwareWrite(uint32_t version) { uint32_t RollbackFirmwareLock(void)
return TPM_SUCCESS; {
return TPM_SUCCESS;
} }
uint32_t RollbackFirmwareLock(void) { uint32_t RollbackKernelRead(uint32_t* version)
return TPM_SUCCESS; {
*version = 0;
return TPM_SUCCESS;
} }
uint32_t RollbackKernelRead(uint32_t* version) { uint32_t RollbackKernelWrite(uint32_t version)
*version = 0; {
return TPM_SUCCESS; return TPM_SUCCESS;
} }
uint32_t RollbackKernelWrite(uint32_t version) { uint32_t RollbackKernelLock(void)
return TPM_SUCCESS; {
} return TPM_SUCCESS;
uint32_t RollbackKernelLock(void) {
return TPM_SUCCESS;
} }
#else #else
uint32_t RollbackS3Resume(void) { uint32_t RollbackS3Resume(void)
uint32_t result; {
RETURN_ON_FAILURE(TlclLibInit()); uint32_t result;
result = TlclResume(); RETURN_ON_FAILURE(TlclLibInit());
if (result == TPM_E_INVALID_POSTINIT) { result = TlclResume();
/* We're on a platform where the TPM maintains power in S3, so if (result == TPM_E_INVALID_POSTINIT) {
it's already initialized. */ /*
return TPM_SUCCESS; * We're on a platform where the TPM maintains power in S3, so
} * it's already initialized.
return result; */
return TPM_SUCCESS;
}
return result;
} }
uint32_t RollbackFirmwareSetup(int recovery_mode, int is_hw_dev, uint32_t RollbackFirmwareSetup(int recovery_mode, int is_hw_dev,
int disable_dev_request, int disable_dev_request,
int clear_tpm_owner_request, int clear_tpm_owner_request,
int *is_virt_dev, uint32_t *version) { int *is_virt_dev, uint32_t *version)
RollbackSpaceFirmware rsf; {
RollbackSpaceFirmware rsf;
/* Set version to 0 in case we fail */ /* Set version to 0 in case we fail */
*version = 0; *version = 0;
RETURN_ON_FAILURE(SetupTPM(recovery_mode, is_hw_dev, disable_dev_request, RETURN_ON_FAILURE(SetupTPM(recovery_mode, is_hw_dev,
clear_tpm_owner_request, &rsf)); disable_dev_request,
*version = rsf.fw_versions; clear_tpm_owner_request, &rsf));
*is_virt_dev = (rsf.flags & FLAG_VIRTUAL_DEV_MODE_ON) ? 1 : 0; *version = rsf.fw_versions;
VBDEBUG(("TPM: RollbackFirmwareSetup %x\n", (int)rsf.fw_versions)); *is_virt_dev = (rsf.flags & FLAG_VIRTUAL_DEV_MODE_ON) ? 1 : 0;
return TPM_SUCCESS; VBDEBUG(("TPM: RollbackFirmwareSetup %x\n", (int)rsf.fw_versions));
return TPM_SUCCESS;
} }
uint32_t RollbackFirmwareWrite(uint32_t version) { uint32_t RollbackFirmwareWrite(uint32_t version)
RollbackSpaceFirmware rsf; {
RollbackSpaceFirmware rsf;
RETURN_ON_FAILURE(ReadSpaceFirmware(&rsf)); RETURN_ON_FAILURE(ReadSpaceFirmware(&rsf));
VBDEBUG(("TPM: RollbackFirmwareWrite %x --> %x\n", (int)rsf.fw_versions, VBDEBUG(("TPM: RollbackFirmwareWrite %x --> %x\n", (int)rsf.fw_versions,
(int)version)); (int)version));
rsf.fw_versions = version; rsf.fw_versions = version;
return WriteSpaceFirmware(&rsf); return WriteSpaceFirmware(&rsf);
} }
uint32_t RollbackFirmwareLock(void) { uint32_t RollbackFirmwareLock(void)
return TlclSetGlobalLock(); {
return TlclSetGlobalLock();
} }
uint32_t RollbackKernelRead(uint32_t* version) { uint32_t RollbackKernelRead(uint32_t* version)
RollbackSpaceKernel rsk; {
uint32_t perms; RollbackSpaceKernel rsk;
uint32_t perms;
/* Read the kernel space and verify its permissions. If the kernel /*
* space has the wrong permission, or it doesn't contain the right * Read the kernel space and verify its permissions. If the kernel
* identifier, we give up. This will need to be fixed by the * space has the wrong permission, or it doesn't contain the right
* recovery kernel. We have to worry about this because at any time * identifier, we give up. This will need to be fixed by the
* (even with PP turned off) the TPM owner can remove and redefine a * recovery kernel. We have to worry about this because at any time
* PP-protected space (but not write to it). */ * (even with PP turned off) the TPM owner can remove and redefine a
RETURN_ON_FAILURE(ReadSpaceKernel(&rsk)); * PP-protected space (but not write to it).
RETURN_ON_FAILURE(TlclGetPermissions(KERNEL_NV_INDEX, &perms)); */
if (TPM_NV_PER_PPWRITE != perms || ROLLBACK_SPACE_KERNEL_UID != rsk.uid) RETURN_ON_FAILURE(ReadSpaceKernel(&rsk));
return TPM_E_CORRUPTED_STATE; RETURN_ON_FAILURE(TlclGetPermissions(KERNEL_NV_INDEX, &perms));
if (TPM_NV_PER_PPWRITE != perms || ROLLBACK_SPACE_KERNEL_UID != rsk.uid)
return TPM_E_CORRUPTED_STATE;
*version = rsk.kernel_versions; *version = rsk.kernel_versions;
VBDEBUG(("TPM: RollbackKernelRead %x\n", (int)rsk.kernel_versions)); VBDEBUG(("TPM: RollbackKernelRead %x\n", (int)rsk.kernel_versions));
return TPM_SUCCESS; return TPM_SUCCESS;
} }
uint32_t RollbackKernelWrite(uint32_t version) { uint32_t RollbackKernelWrite(uint32_t version)
RollbackSpaceKernel rsk; {
RETURN_ON_FAILURE(ReadSpaceKernel(&rsk)); RollbackSpaceKernel rsk;
VBDEBUG(("TPM: RollbackKernelWrite %x --> %x\n", (int)rsk.kernel_versions, RETURN_ON_FAILURE(ReadSpaceKernel(&rsk));
(int)version)); VBDEBUG(("TPM: RollbackKernelWrite %x --> %x\n",
rsk.kernel_versions = version; (int)rsk.kernel_versions, (int)version));
return WriteSpaceKernel(&rsk); rsk.kernel_versions = version;
return WriteSpaceKernel(&rsk);
} }
uint32_t RollbackKernelLock(void) { uint32_t RollbackKernelLock(void)
if (g_rollback_recovery_mode) { {
return TPM_SUCCESS; if (g_rollback_recovery_mode)
} else { return TPM_SUCCESS;
return TlclLockPhysicalPresence(); else
} return TlclLockPhysicalPresence();
} }
#endif // DISABLE_ROLLBACK_TPM #endif /* DISABLE_ROLLBACK_TPM */

1504
tests/rollback_index2_tests.c
View File

File diff suppressed because it is too large Load Diff

45
tests/rollback_index3_tests.c Normal file
View File

@@ -0,0 +1,45 @@
/* Copyright (c) 2013 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.
*
* Tests for do-nothing rollback_index functions with disabled TPM
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define _STUB_IMPLEMENTATION_ /* So we can use memset() ourselves */
#include "rollback_index.h"
#include "test_common.h"
/* disable MSVC warnings on unused arguments */
__pragma(warning (disable: 4100))
int main(int argc, char* argv[])
{
int is_virt_dev;
uint32_t version;
TEST_EQ(RollbackS3Resume(), 0, "RollbackS3Resume()");
is_virt_dev = 1;
version = 1;
TEST_EQ(RollbackFirmwareSetup(0, 0, 0, 0, &is_virt_dev, &version),
0, "RollbackFirmwareSetup()");
TEST_EQ(is_virt_dev, 0, "rfs is_virt_dev");
TEST_EQ(version, 0, "rfs version");
TEST_EQ(RollbackFirmwareWrite(0), 0, "RollbackFirmwareWrite()");
TEST_EQ(RollbackFirmwareLock(), 0, "RollbackFirmwareLock()");
version = 1;
TEST_EQ(RollbackKernelRead(&version), 0, "RollbackKernelRead()");
TEST_EQ(version, 0, "rkr version");
TEST_EQ(RollbackKernelWrite(0), 0, "RollbackKernelWrite()");
TEST_EQ(RollbackKernelLock(), 0, "RollbackKernelLock()");
return gTestSuccess ? 0 : 255;
}