firmware/lib/secdata_tpm.c

/* 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.
 *
 * Functions for querying, manipulating and locking secure data spaces
 * stored in the TPM NVRAM.
 */

#include "2common.h"
#include "2crc8.h"
#include "2nvstorage.h"
#include "2secdata.h"
#include "2sysincludes.h"
#include "secdata_tpm.h"
#include "tlcl.h"
#include "tss_constants.h"
#include "vboot_api.h"

#define RETURN_ON_FAILURE(tpm_command) do { \
		uint32_t result_; \
		if ((result_ = (tpm_command)) != TPM_SUCCESS) { \
			VB2_DEBUG("TPM: 0x%x returned by " #tpm_command \
				  "\n", (int)result_); \
			return result_; \
		} \
	} while (0)

#define PRINT_BYTES(title, value) do { \
		int i; \
		VB2_DEBUG(title); \
		VB2_DEBUG_RAW(":"); \
		for (i = 0; i < sizeof(*(value)); i++) \
			VB2_DEBUG_RAW(" %02x", *((uint8_t *)(value) + i)); \
		VB2_DEBUG_RAW("\n"); \
	} while (0)

uint32_t TPMClearAndReenable(void)
{
	VB2_DEBUG("TPM: clear and re-enable\n");
	RETURN_ON_FAILURE(TlclForceClear());
	RETURN_ON_FAILURE(TlclSetEnable());
	RETURN_ON_FAILURE(TlclSetDeactivated(0));

	return TPM_SUCCESS;
}

uint32_t SafeWrite(uint32_t index, const void *data, uint32_t length)
{
	uint32_t result = TlclWrite(index, data, length);
	if (result == TPM_E_MAXNVWRITES) {
		RETURN_ON_FAILURE(TPMClearAndReenable());
		return TlclWrite(index, data, length);
	} else {
		return result;
	}
}

/* Functions to read and write firmware and kernel spaces. */
uint32_t ReadSpaceFirmware(RollbackSpaceFirmware *rsf)
{
	uint32_t r;

	r = TlclRead(FIRMWARE_NV_INDEX, rsf, sizeof(RollbackSpaceFirmware));
	if (TPM_SUCCESS != r) {
		VB2_DEBUG("TPM: read secdata_firmware returned 0x%x\n", r);
		return r;
	}
	PRINT_BYTES("TPM: read secdata_firmware", rsf);

	if (rsf->struct_version < ROLLBACK_SPACE_FIRMWARE_VERSION)
		return TPM_E_STRUCT_VERSION;

	if (rsf->crc8 != vb2_crc8(rsf, offsetof(RollbackSpaceFirmware, crc8))) {
		VB2_DEBUG("TPM: bad secdata_firmware CRC\n");
		return TPM_E_CORRUPTED_STATE;
	}

	return TPM_SUCCESS;
}

uint32_t WriteSpaceFirmware(RollbackSpaceFirmware *rsf)
{
	uint32_t r;

	rsf->crc8 = vb2_crc8(rsf, offsetof(RollbackSpaceFirmware, crc8));

	PRINT_BYTES("TPM: write secdata", rsf);
	r = SafeWrite(FIRMWARE_NV_INDEX, rsf, sizeof(RollbackSpaceFirmware));
	if (TPM_SUCCESS != r) {
		VB2_DEBUG("TPM: write secdata_firmware failure\n");
		return r;
	}

	return TPM_SUCCESS;
}

vb2_error_t SetVirtualDevMode(int val)
{
	RollbackSpaceFirmware rsf;

	VB2_DEBUG("Enabling developer mode...\n");

	if (TPM_SUCCESS != ReadSpaceFirmware(&rsf))
		return VBERROR_TPM_FIRMWARE_SETUP;

	VB2_DEBUG("TPM: flags were 0x%02x\n", rsf.flags);
	if (val)
		rsf.flags |= FLAG_VIRTUAL_DEV_MODE_ON;
	else
		rsf.flags &= ~FLAG_VIRTUAL_DEV_MODE_ON;
	/*
	 * NOTE: This doesn't update the FLAG_LAST_BOOT_DEVELOPER bit.  That
	 * will be done on the next boot.
	 */
	VB2_DEBUG("TPM: flags are now 0x%02x\n", rsf.flags);

	if (TPM_SUCCESS != WriteSpaceFirmware(&rsf))
		return VBERROR_TPM_SET_BOOT_MODE_STATE;

	VB2_DEBUG("Mode change will take effect on next reboot\n");

	return VB2_SUCCESS;
}

uint32_t ReadSpaceKernel(RollbackSpaceKernel *rsk)
{
#ifndef TPM2_MODE
	/*
	 * Before reading the kernel space, verify its permissions.  If the
	 * kernel space has the wrong permission, we give up.  This will need
	 * to be fixed by the recovery kernel.  We will 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).
	 */
	uint32_t perms;

	RETURN_ON_FAILURE(TlclGetPermissions(KERNEL_NV_INDEX, &perms));

	if (perms != TPM_NV_PER_PPWRITE)
		return TPM_E_CORRUPTED_STATE;
#endif

	uint32_t r;

	r = TlclRead(KERNEL_NV_INDEX, rsk, sizeof(RollbackSpaceKernel));
	if (TPM_SUCCESS != r) {
		VB2_DEBUG("TPM: read secdata_kernel returned 0x%x\n", r);
		return r;
	}
	PRINT_BYTES("TPM: read secdata_kernel", rsk);

	if (rsk->struct_version < ROLLBACK_SPACE_FIRMWARE_VERSION)
		return TPM_E_STRUCT_VERSION;

	if (rsk->uid != ROLLBACK_SPACE_KERNEL_UID)
		return TPM_E_CORRUPTED_STATE;

	if (rsk->crc8 != vb2_crc8(rsk, offsetof(RollbackSpaceKernel, crc8))) {
		VB2_DEBUG("TPM: bad secdata_kernel CRC\n");
		return TPM_E_CORRUPTED_STATE;
	}

	return TPM_SUCCESS;
}

uint32_t WriteSpaceKernel(RollbackSpaceKernel *rsk)
{
	uint32_t r;

	rsk->crc8 = vb2_crc8(rsk, offsetof(RollbackSpaceKernel, crc8));

	PRINT_BYTES("TPM: write secdata_kernel", rsk);
	r = SafeWrite(KERNEL_NV_INDEX, rsk, sizeof(RollbackSpaceKernel));
	if (TPM_SUCCESS != r) {
		VB2_DEBUG("TPM: write secdata_kernel failure\n");
		return r;
	}

	return TPM_SUCCESS;
}

uint32_t RollbackKernelRead(uint32_t* version)
{
	RollbackSpaceKernel rsk;
	RETURN_ON_FAILURE(ReadSpaceKernel(&rsk));
	memcpy(version, &rsk.kernel_versions, sizeof(*version));
	VB2_DEBUG("TPM: RollbackKernelRead 0x%x\n", (int)*version);
	return TPM_SUCCESS;
}

uint32_t RollbackKernelWrite(uint32_t version)
{
	RollbackSpaceKernel rsk;
	uint32_t old_version;
	RETURN_ON_FAILURE(ReadSpaceKernel(&rsk));
	memcpy(&old_version, &rsk.kernel_versions, sizeof(old_version));
	VB2_DEBUG("TPM: RollbackKernelWrite 0x%x --> 0x%x\n",
		  (int)old_version, (int)version);
	memcpy(&rsk.kernel_versions, &version, sizeof(version));
	return WriteSpaceKernel(&rsk);
}

uint32_t RollbackKernelLock(int recovery_mode)
{
	static int kernel_locked = 0;
	uint32_t r;

	if (recovery_mode || kernel_locked)
		return TPM_SUCCESS;

	r = TlclLockPhysicalPresence();
	if (TPM_SUCCESS == r)
		kernel_locked = 1;

	VB2_DEBUG("TPM: lock secdata_kernel returned 0x%x\n", r);
	return r;
}

uint32_t RollbackFwmpRead(struct RollbackSpaceFwmp *fwmp)
{
	union {
		/*
		 * Use a union for buf and fwmp, rather than making fwmp a
		 * pointer to a bare uint8_t[] buffer.  This ensures fwmp will
		 * be aligned if necesssary for the target platform.
		 */
		uint8_t buf[FWMP_NV_MAX_SIZE];
		struct RollbackSpaceFwmp fwmp;
	} u;
	uint32_t r;

	/* Clear destination in case error or FWMP not present */
	memset(fwmp, 0, sizeof(*fwmp));

	/* Try to read entire 1.0 struct */
	r = TlclRead(FWMP_NV_INDEX, u.buf, sizeof(u.fwmp));
	if (TPM_E_BADINDEX == r) {
		/* Missing space is not an error; use defaults */
		VB2_DEBUG("TPM: no FWMP space\n");
		return TPM_SUCCESS;
	} else if (TPM_SUCCESS != r) {
		VB2_DEBUG("TPM: read FWMP returned 0x%x\n", r);
		return r;
	}

	/*
	 * Struct must be at least big enough for 1.0, but not bigger
	 * than our buffer size.
	 */
	if (u.fwmp.struct_size < sizeof(u.fwmp) ||
	    u.fwmp.struct_size > sizeof(u.buf)) {
		VB2_DEBUG("TPM: FWMP size invalid: 0x%x\n", u.fwmp.struct_size);
		return TPM_E_STRUCT_SIZE;
	}

	/*
	 * If space is bigger than we expect, re-read so we properly
	 * compute the CRC.
	 */
	if (u.fwmp.struct_size > sizeof(u.fwmp)) {
		r = TlclRead(FWMP_NV_INDEX, u.buf, u.fwmp.struct_size);
		if (TPM_SUCCESS != r) {
			VB2_DEBUG("TPM: re-read FWMP returned 0x%x\n", r);
			return r;
		}
	}

	/* Verify CRC */
	if (u.fwmp.crc != vb2_crc8(u.buf + 2, u.fwmp.struct_size - 2)) {
		VB2_DEBUG("TPM: bad FWMP CRC\n");
		return TPM_E_CORRUPTED_STATE;
	}

	/* Verify major version is compatible */
	if ((u.fwmp.struct_version >> 4) !=
	    (ROLLBACK_SPACE_FWMP_VERSION >> 4)) {
		VB2_DEBUG("TPM: FWMP major version incompatible\n");
		return TPM_E_STRUCT_VERSION;
	}

	/*
	 * Copy to destination.  Note that if the space is bigger than
	 * we expect (due to a minor version change), we only copy the
	 * part of the FWMP that we know what to do with.
	 *
	 * If this were a 1.1+ reader and the source was a 1.0 struct,
	 * we would need to take care of initializing the extra fields
	 * added in 1.1+.  But that's not an issue yet.
	 */
	memcpy(fwmp, &u.fwmp, sizeof(*fwmp));
	return TPM_SUCCESS;
}