_vboot_reference/firmware/lib/vboot_firmware.c - chromiumos/platform/vboot - Git at Google

 /* 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.
  *
  * High-level firmware API for loading and verifying rewritable firmware.
  * (Firmware portion)
  */

 #include "sysincludes.h"

 #include "region.h"
 #include "gbb_access.h"
 #include "gbb_header.h"
 #include "load_firmware_fw.h"
 #include "utility.h"
 #include "vboot_api.h"
 #include "vboot_common.h"
 #include "vboot_nvstorage.h"

 /*
  * Static variables for UpdateFirmwareBodyHash().  It's less than optimal to
  * have static variables in a library, but in UEFI the caller is deep inside a
  * different firmware stack and doesn't have a good way to pass the params
  * struct back to us.
  */
 typedef struct VbLoadFirmwareInternal {
 	DigestContext body_digest_context;
 	uint32_t body_size_accum;
 } VbLoadFirmwareInternal;

 void VbUpdateFirmwareBodyHash(VbCommonParams *cparams, uint8_t *data,
 			      uint32_t size)
 {
 	VbLoadFirmwareInternal *lfi =
 		(VbLoadFirmwareInternal*)cparams->vboot_context;

 	DigestUpdate(&lfi->body_digest_context, data, size);
 	lfi->body_size_accum += size;
 }

 int LoadFirmware(VbCommonParams *cparams, VbSelectFirmwareParams *fparams,
                  VbNvContext *vnc)
 {
 	VbSharedDataHeader *shared =
 		(VbSharedDataHeader *)cparams->shared_data_blob;
 	GoogleBinaryBlockHeader *gbb = cparams->gbb;
 	VbPublicKey *root_key = NULL;
 	VbLoadFirmwareInternal *lfi;

 	uint32_t try_b_count;
 	uint32_t lowest_version = 0xFFFFFFFF;
 	int good_index = -1;
 	int is_dev;
 	int index;
 	int i;

 	int retval = VBERROR_UNKNOWN;
 	int recovery = VBNV_RECOVERY_RO_UNSPECIFIED;

 	/* Clear output params in case we fail */
 	shared->firmware_index = 0xFF;

 	VBDEBUG(("LoadFirmware started...\n"));

 	/* Must have a root key from the GBB */
 	retval = VbGbbReadRootKey(cparams, &root_key);
 	if (retval) {
 		VBDEBUG(("No GBB\n"));
 		retval = VBERROR_INVALID_GBB;
 		goto LoadFirmwareExit;
 	}

 	/* Parse flags */
 	is_dev = (shared->flags & VBSD_BOOT_DEV_SWITCH_ON ? 1 : 0);
 	if (is_dev)
 		shared->flags |= VBSD_LF_DEV_SWITCH_ON;

 	/* Read try-b count and decrement if necessary */
 	VbNvGet(vnc, VBNV_TRY_B_COUNT, &try_b_count);
 	if (0 != try_b_count) {
 		if (!(shared->flags & VBSD_NOFAIL_BOOT))
 			VbNvSet(vnc, VBNV_TRY_B_COUNT, try_b_count - 1);
 		shared->flags |= VBSD_FWB_TRIED;
 	}

 	/* Allocate our internal data */
 	lfi = (VbLoadFirmwareInternal *)
 		VbExMalloc(sizeof(VbLoadFirmwareInternal));
 	cparams->vboot_context = lfi;

 	/* Loop over indices */
 	for (i = 0; i < 2; i++) {
 		VbKeyBlockHeader *key_block;
 		uint32_t vblock_size;
 		VbFirmwarePreambleHeader *preamble;
 		RSAPublicKey *data_key;
 		uint64_t key_version;
 		uint32_t combined_version;
 		uint8_t *body_digest;
 		uint8_t *check_result;

 		/* If try B count is non-zero try firmware B first */
 		index = (try_b_count ? 1 - i : i);
 		if (0 == index) {
 			key_block = (VbKeyBlockHeader *)
 				fparams->verification_block_A;
 			vblock_size = fparams->verification_size_A;
 			check_result = &shared->check_fw_a_result;
 		} else {
 			key_block = (VbKeyBlockHeader *)
 				fparams->verification_block_B;
 			vblock_size = fparams->verification_size_B;
 			check_result = &shared->check_fw_b_result;
 		}

 		/*
 		 * Check the key block flags against the current boot mode.  Do
 		 * this before verifying the key block, since flags are faster
 		 * to check than the RSA signature.
 		 */
 		if (!(key_block->key_block_flags &
 		      (is_dev ? KEY_BLOCK_FLAG_DEVELOPER_1 :
 		       KEY_BLOCK_FLAG_DEVELOPER_0))) {
 			VBDEBUG(("Developer flag mismatch.\n"));
 			*check_result = VBSD_LF_CHECK_DEV_MISMATCH;
 			continue;
 		}

 		/* RW firmware never runs in recovery mode. */
 		if (!(key_block->key_block_flags & KEY_BLOCK_FLAG_RECOVERY_0)) {
 			VBDEBUG(("Recovery flag mismatch.\n"));
 			*check_result = VBSD_LF_CHECK_REC_MISMATCH;
 			continue;
 		}

 		/* Verify the key block */
 		if ((0 != KeyBlockVerify(key_block, vblock_size,
 					 root_key, 0))) {
 			VBDEBUG(("Key block verification failed.\n"));
 			*check_result = VBSD_LF_CHECK_VERIFY_KEYBLOCK;
 			continue;
 		}

 		/* Check for rollback of key version. */
 		key_version = key_block->data_key.key_version;
 		if (!(gbb->flags & GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK)) {
 			if (key_version < (shared->fw_version_tpm >> 16)) {
 				VBDEBUG(("Key rollback detected.\n"));
 				*check_result = VBSD_LF_CHECK_KEY_ROLLBACK;
 				continue;
 			}
 			if (key_version > 0xFFFF) {
 				/*
 				 * Key version is stored in 16 bits in the TPM,
 				 * so key versions greater than 0xFFFF can't be
 				 * stored properly.
 				 */
 				VBDEBUG(("Key version > 0xFFFF.\n"));
 				*check_result = VBSD_LF_CHECK_KEY_ROLLBACK;
 				continue;
 			}
 		}

 		/* Get key for preamble/data verification from the key block. */
 		data_key = PublicKeyToRSA(&key_block->data_key);
 		if (!data_key) {
 			VBDEBUG(("Unable to parse data key.\n"));
 			*check_result = VBSD_LF_CHECK_DATA_KEY_PARSE;
 			continue;
 		}

 		/* Verify the preamble, which follows the key block. */
 		preamble = (VbFirmwarePreambleHeader *)
 			((uint8_t *)key_block + key_block->key_block_size);
 		if ((0 != VerifyFirmwarePreamble(
 					preamble,
 					vblock_size - key_block->key_block_size,
 					data_key))) {
 			VBDEBUG(("Preamble verfication failed.\n"));
 			*check_result = VBSD_LF_CHECK_VERIFY_PREAMBLE;
 			RSAPublicKeyFree(data_key);
 			continue;
 		}

 		/* Check for rollback of firmware version. */
 		combined_version = (uint32_t)((key_version << 16) |
 				(preamble->firmware_version & 0xFFFF));
 		if (combined_version < shared->fw_version_tpm &&
 		    !(gbb->flags & GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK)) {
 			VBDEBUG(("Firmware version rollback detected.\n"));
 			*check_result = VBSD_LF_CHECK_FW_ROLLBACK;
 			RSAPublicKeyFree(data_key);
 			continue;
 		}

 		/* Header for this firmware is valid */
 		*check_result = VBSD_LF_CHECK_HEADER_VALID;

 		/* Check for lowest key version from a valid header. */
 		if (lowest_version > combined_version)
 			lowest_version = combined_version;

 		/*
 		 * If we already have good firmware, no need to read another
 		 * one; we only needed to look at the versions to check for
 		 * rollback.
 		 */
 		if (-1 != good_index) {
 			RSAPublicKeyFree(data_key);
 			continue;
 		}

 		/* Handle preamble flag for using the RO normal/dev code path */
 		VBDEBUG(("Preamble flags %#x\n", VbGetFirmwarePreambleFlags(preamble)));
 		if (VbGetFirmwarePreambleFlags(preamble) &
 		    VB_FIRMWARE_PREAMBLE_USE_RO_NORMAL) {

 			/* Fail if calling firmware doesn't support RO normal */
 			if (!(shared->flags & VBSD_BOOT_RO_NORMAL_SUPPORT)) {
 				VBDEBUG(("No RO normal support.\n"));
 				*check_result = VBSD_LF_CHECK_NO_RO_NORMAL;
 				RSAPublicKeyFree(data_key);
 				continue;
 			}

 			/* Use the RO normal code path */
 			shared->flags |= VBSD_LF_USE_RO_NORMAL;

 		} else {
 			VbError_t rv;

 			/* Read the firmware data */
 			DigestInit(&lfi->body_digest_context,
 				   data_key->algorithm);
 			lfi->body_size_accum = 0;
 			rv = VbExHashFirmwareBody(
 					cparams,
 					(index ? VB_SELECT_FIRMWARE_B :
 					 VB_SELECT_FIRMWARE_A));
 			if (VBERROR_SUCCESS != rv) {
 				VBDEBUG(("VbExHashFirmwareBody() failed for "
 					 "index %d\n", index));
 				*check_result = VBSD_LF_CHECK_GET_FW_BODY;
 				RSAPublicKeyFree(data_key);
 				continue;
 			}
 			if (lfi->body_size_accum !=
 			    preamble->body_signature.data_size) {
 				VBDEBUG(("Hashed %d bytes but expected %d\n",
 					 (int)lfi->body_size_accum,
 					 (int)preamble->body_signature.data_size));
 				*check_result = VBSD_LF_CHECK_HASH_WRONG_SIZE;
 				RSAPublicKeyFree(data_key);
 				continue;
 			}

 			/* Verify firmware data */
 			body_digest = DigestFinal(&lfi->body_digest_context);
 			if (0 != VerifyDigest(body_digest,
 					      &preamble->body_signature,
 					      data_key)) {
 				VBDEBUG(("FW body verification failed.\n"));
 				*check_result = VBSD_LF_CHECK_VERIFY_BODY;
 				RSAPublicKeyFree(data_key);
 				VbExFree(body_digest);
 				continue;
 			}
 			VbExFree(body_digest);
 		}

 		/* Done with the data key, so can free it now */
 		RSAPublicKeyFree(data_key);

 		/* If we're still here, the firmware is valid. */
 		VBDEBUG(("Firmware %d is valid.\n", index));
 		*check_result = VBSD_LF_CHECK_VALID;
 		if (-1 == good_index) {
 			/* Save the key we actually used */
 			if (0 != VbSharedDataSetKernelKey(
 					shared, &preamble->kernel_subkey)) {
 				/*
 				 * The firmware signature was good, but the
 				 * public key was bigger that the caller can
 				 * handle.
 				 */
 				VBDEBUG(("Unable to save kernel subkey.\n"));
 				continue;
 			}

 			/*
 			 * Save the good index, now that we're sure we can
 			 * actually use this firmware.  That's the one we'll
 			 * boot.
 			 */
 			good_index = index;
 			shared->firmware_index = (uint8_t)index;
 			shared->fw_keyblock_flags = key_block->key_block_flags;

 			/*
 			 * If the good firmware's key version is the same as
 			 * the tpm, then the TPM doesn't need updating; we can
 			 * stop now.  Otherwise, we'll check all the other
 			 * headers to see if they contain a newer key.
 			 */
 			if (combined_version == shared->fw_version_tpm)
 				break;
 		}
 	}

 	/* Free internal data */
 	VbExFree(lfi);
 	cparams->vboot_context = NULL;

 	/* Handle finding good firmware */
 	if (good_index >= 0) {

 		/* Save versions we found */
 		shared->fw_version_lowest = lowest_version;
 		if (lowest_version > shared->fw_version_tpm)
 			shared->fw_version_tpm = lowest_version;

 		/* Success */
 		VBDEBUG(("Will boot firmware index %d\n",
 			 (int)shared->firmware_index));
 		retval = VBERROR_SUCCESS;

 	} else {
 		uint8_t a = shared->check_fw_a_result;
 		uint8_t b = shared->check_fw_b_result;
 		uint8_t best_check;

 		/* No good firmware, so go to recovery mode. */
 		VBDEBUG(("Alas, no good firmware.\n"));
 		recovery = VBNV_RECOVERY_RO_INVALID_RW;
 		retval = VBERROR_LOAD_FIRMWARE;

 		/*
 		 * If the best check result fits in the range of recovery
 		 * reasons, provide more detail on how far we got in
 		 * validation.
 		 */
 		best_check = (a > b ? a : b) +
 			VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN;
 		if (best_check >= VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN &&
 		    best_check <= VBNV_RECOVERY_RO_INVALID_RW_CHECK_MAX)
 			recovery = best_check;
 	}

  LoadFirmwareExit:
 	VbExFree(root_key);

 	/* Store recovery request, if any */
 	VbNvSet(vnc, VBNV_RECOVERY_REQUEST, VBERROR_SUCCESS != retval ?
 		recovery : VBNV_RECOVERY_NOT_REQUESTED);
 	/* If the system does not support RO_NORMAL and LoadFirmware()
 	 * encountered an error, update the shared recovery reason if
 	 * recovery was not previously requested. */
 	if (!(shared->flags & VBSD_BOOT_RO_NORMAL_SUPPORT) &&
 	    VBNV_RECOVERY_NOT_REQUESTED == shared->recovery_reason &&
 	    VBERROR_SUCCESS != retval) {
 		VBDEBUG(("RO normal but we got an error.\n"));
 		shared->recovery_reason = recovery;
 	}

 	return retval;
 }
	/* 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.
	*
	* High-level firmware API for loading and verifying rewritable firmware.
	* (Firmware portion)
	*/

	#include "sysincludes.h"

	#include "region.h"
	#include "gbb_access.h"
	#include "gbb_header.h"
	#include "load_firmware_fw.h"
	#include "utility.h"
	#include "vboot_api.h"
	#include "vboot_common.h"
	#include "vboot_nvstorage.h"

	/*
	* Static variables for UpdateFirmwareBodyHash(). It's less than optimal to
	* have static variables in a library, but in UEFI the caller is deep inside a
	* different firmware stack and doesn't have a good way to pass the params
	* struct back to us.
	*/
	typedef struct VbLoadFirmwareInternal {
	DigestContext body_digest_context;
	uint32_t body_size_accum;
	} VbLoadFirmwareInternal;

	void VbUpdateFirmwareBodyHash(VbCommonParams cparams, uint8_t data,
	uint32_t size)
	{
	VbLoadFirmwareInternal *lfi =
	(VbLoadFirmwareInternal*)cparams->vboot_context;

	DigestUpdate(&lfi->body_digest_context, data, size);
	lfi->body_size_accum += size;
	}

	int LoadFirmware(VbCommonParams cparams, VbSelectFirmwareParams fparams,
	VbNvContext *vnc)
	{
	VbSharedDataHeader *shared =
	(VbSharedDataHeader *)cparams->shared_data_blob;
	GoogleBinaryBlockHeader *gbb = cparams->gbb;
	VbPublicKey *root_key = NULL;
	VbLoadFirmwareInternal *lfi;

	uint32_t try_b_count;
	uint32_t lowest_version = 0xFFFFFFFF;
	int good_index = -1;
	int is_dev;
	int index;
	int i;

	int retval = VBERROR_UNKNOWN;
	int recovery = VBNV_RECOVERY_RO_UNSPECIFIED;

	/* Clear output params in case we fail */
	shared->firmware_index = 0xFF;

	VBDEBUG(("LoadFirmware started...\n"));

	/* Must have a root key from the GBB */
	retval = VbGbbReadRootKey(cparams, &root_key);
	if (retval) {
	VBDEBUG(("No GBB\n"));
	retval = VBERROR_INVALID_GBB;
	goto LoadFirmwareExit;
	}

	/* Parse flags */
	is_dev = (shared->flags & VBSD_BOOT_DEV_SWITCH_ON ? 1 : 0);
	if (is_dev)
	shared->flags \|= VBSD_LF_DEV_SWITCH_ON;

	/* Read try-b count and decrement if necessary */
	VbNvGet(vnc, VBNV_TRY_B_COUNT, &try_b_count);
	if (0 != try_b_count) {
	if (!(shared->flags & VBSD_NOFAIL_BOOT))
	VbNvSet(vnc, VBNV_TRY_B_COUNT, try_b_count - 1);
	shared->flags \|= VBSD_FWB_TRIED;
	}

	/* Allocate our internal data */
	lfi = (VbLoadFirmwareInternal *)
	VbExMalloc(sizeof(VbLoadFirmwareInternal));
	cparams->vboot_context = lfi;

	/* Loop over indices */
	for (i = 0; i < 2; i++) {
	VbKeyBlockHeader *key_block;
	uint32_t vblock_size;
	VbFirmwarePreambleHeader *preamble;
	RSAPublicKey *data_key;
	uint64_t key_version;
	uint32_t combined_version;
	uint8_t *body_digest;
	uint8_t *check_result;

	/* If try B count is non-zero try firmware B first */
	index = (try_b_count ? 1 - i : i);
	if (0 == index) {
	key_block = (VbKeyBlockHeader *)
	fparams->verification_block_A;
	vblock_size = fparams->verification_size_A;
	check_result = &shared->check_fw_a_result;
	} else {
	key_block = (VbKeyBlockHeader *)
	fparams->verification_block_B;
	vblock_size = fparams->verification_size_B;
	check_result = &shared->check_fw_b_result;
	}

	/*
	* Check the key block flags against the current boot mode. Do
	* this before verifying the key block, since flags are faster
	* to check than the RSA signature.
	*/
	if (!(key_block->key_block_flags &
	(is_dev ? KEY_BLOCK_FLAG_DEVELOPER_1 :
	KEY_BLOCK_FLAG_DEVELOPER_0))) {
	VBDEBUG(("Developer flag mismatch.\n"));
	*check_result = VBSD_LF_CHECK_DEV_MISMATCH;
	continue;
	}

	/* RW firmware never runs in recovery mode. */
	if (!(key_block->key_block_flags & KEY_BLOCK_FLAG_RECOVERY_0)) {
	VBDEBUG(("Recovery flag mismatch.\n"));
	*check_result = VBSD_LF_CHECK_REC_MISMATCH;
	continue;
	}

	/* Verify the key block */
	if ((0 != KeyBlockVerify(key_block, vblock_size,
	root_key, 0))) {
	VBDEBUG(("Key block verification failed.\n"));
	*check_result = VBSD_LF_CHECK_VERIFY_KEYBLOCK;
	continue;
	}

	/* Check for rollback of key version. */
	key_version = key_block->data_key.key_version;
	if (!(gbb->flags & GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK)) {
	if (key_version < (shared->fw_version_tpm >> 16)) {
	VBDEBUG(("Key rollback detected.\n"));
	*check_result = VBSD_LF_CHECK_KEY_ROLLBACK;
	continue;
	}
	if (key_version > 0xFFFF) {
	/*
	* Key version is stored in 16 bits in the TPM,
	* so key versions greater than 0xFFFF can't be
	* stored properly.
	*/
	VBDEBUG(("Key version > 0xFFFF.\n"));
	*check_result = VBSD_LF_CHECK_KEY_ROLLBACK;
	continue;
	}
	}

	/* Get key for preamble/data verification from the key block. */
	data_key = PublicKeyToRSA(&key_block->data_key);
	if (!data_key) {
	VBDEBUG(("Unable to parse data key.\n"));
	*check_result = VBSD_LF_CHECK_DATA_KEY_PARSE;
	continue;
	}

	/* Verify the preamble, which follows the key block. */
	preamble = (VbFirmwarePreambleHeader *)
	((uint8_t *)key_block + key_block->key_block_size);
	if ((0 != VerifyFirmwarePreamble(
	preamble,
	vblock_size - key_block->key_block_size,
	data_key))) {
	VBDEBUG(("Preamble verfication failed.\n"));
	*check_result = VBSD_LF_CHECK_VERIFY_PREAMBLE;
	RSAPublicKeyFree(data_key);
	continue;
	}

	/* Check for rollback of firmware version. */
	combined_version = (uint32_t)((key_version << 16) \|
	(preamble->firmware_version & 0xFFFF));
	if (combined_version < shared->fw_version_tpm &&
	!(gbb->flags & GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK)) {
	VBDEBUG(("Firmware version rollback detected.\n"));
	*check_result = VBSD_LF_CHECK_FW_ROLLBACK;
	RSAPublicKeyFree(data_key);
	continue;
	}

	/* Header for this firmware is valid */
	*check_result = VBSD_LF_CHECK_HEADER_VALID;

	/* Check for lowest key version from a valid header. */
	if (lowest_version > combined_version)
	lowest_version = combined_version;

	/*
	* If we already have good firmware, no need to read another
	* one; we only needed to look at the versions to check for
	* rollback.
	*/
	if (-1 != good_index) {
	RSAPublicKeyFree(data_key);
	continue;
	}

	/* Handle preamble flag for using the RO normal/dev code path */
	VBDEBUG(("Preamble flags %#x\n", VbGetFirmwarePreambleFlags(preamble)));
	if (VbGetFirmwarePreambleFlags(preamble) &
	VB_FIRMWARE_PREAMBLE_USE_RO_NORMAL) {

	/* Fail if calling firmware doesn't support RO normal */
	if (!(shared->flags & VBSD_BOOT_RO_NORMAL_SUPPORT)) {
	VBDEBUG(("No RO normal support.\n"));
	*check_result = VBSD_LF_CHECK_NO_RO_NORMAL;
	RSAPublicKeyFree(data_key);
	continue;
	}

	/* Use the RO normal code path */
	shared->flags \|= VBSD_LF_USE_RO_NORMAL;

	} else {
	VbError_t rv;

	/* Read the firmware data */
	DigestInit(&lfi->body_digest_context,
	data_key->algorithm);
	lfi->body_size_accum = 0;
	rv = VbExHashFirmwareBody(
	cparams,
	(index ? VB_SELECT_FIRMWARE_B :
	VB_SELECT_FIRMWARE_A));
	if (VBERROR_SUCCESS != rv) {
	VBDEBUG(("VbExHashFirmwareBody() failed for "
	"index %d\n", index));
	*check_result = VBSD_LF_CHECK_GET_FW_BODY;
	RSAPublicKeyFree(data_key);
	continue;
	}
	if (lfi->body_size_accum !=
	preamble->body_signature.data_size) {
	VBDEBUG(("Hashed %d bytes but expected %d\n",
	(int)lfi->body_size_accum,
	(int)preamble->body_signature.data_size));
	*check_result = VBSD_LF_CHECK_HASH_WRONG_SIZE;
	RSAPublicKeyFree(data_key);
	continue;
	}

	/* Verify firmware data */
	body_digest = DigestFinal(&lfi->body_digest_context);
	if (0 != VerifyDigest(body_digest,
	&preamble->body_signature,
	data_key)) {
	VBDEBUG(("FW body verification failed.\n"));
	*check_result = VBSD_LF_CHECK_VERIFY_BODY;
	RSAPublicKeyFree(data_key);
	VbExFree(body_digest);
	continue;
	}
	VbExFree(body_digest);
	}

	/* Done with the data key, so can free it now */
	RSAPublicKeyFree(data_key);

	/* If we're still here, the firmware is valid. */
	VBDEBUG(("Firmware %d is valid.\n", index));
	*check_result = VBSD_LF_CHECK_VALID;
	if (-1 == good_index) {
	/* Save the key we actually used */
	if (0 != VbSharedDataSetKernelKey(
	shared, &preamble->kernel_subkey)) {
	/*
	* The firmware signature was good, but the
	* public key was bigger that the caller can
	* handle.
	*/
	VBDEBUG(("Unable to save kernel subkey.\n"));
	continue;
	}

	/*
	* Save the good index, now that we're sure we can
	* actually use this firmware. That's the one we'll
	* boot.
	*/
	good_index = index;
	shared->firmware_index = (uint8_t)index;
	shared->fw_keyblock_flags = key_block->key_block_flags;

	/*
	* If the good firmware's key version is the same as
	* the tpm, then the TPM doesn't need updating; we can
	* stop now. Otherwise, we'll check all the other
	* headers to see if they contain a newer key.
	*/
	if (combined_version == shared->fw_version_tpm)
	break;
	}
	}

	/* Free internal data */
	VbExFree(lfi);
	cparams->vboot_context = NULL;

	/* Handle finding good firmware */
	if (good_index >= 0) {

	/* Save versions we found */
	shared->fw_version_lowest = lowest_version;
	if (lowest_version > shared->fw_version_tpm)
	shared->fw_version_tpm = lowest_version;

	/* Success */
	VBDEBUG(("Will boot firmware index %d\n",
	(int)shared->firmware_index));
	retval = VBERROR_SUCCESS;

	} else {
	uint8_t a = shared->check_fw_a_result;
	uint8_t b = shared->check_fw_b_result;
	uint8_t best_check;

	/* No good firmware, so go to recovery mode. */
	VBDEBUG(("Alas, no good firmware.\n"));
	recovery = VBNV_RECOVERY_RO_INVALID_RW;
	retval = VBERROR_LOAD_FIRMWARE;

	/*
	* If the best check result fits in the range of recovery
	* reasons, provide more detail on how far we got in
	* validation.
	*/
	best_check = (a > b ? a : b) +
	VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN;
	if (best_check >= VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN &&
	best_check <= VBNV_RECOVERY_RO_INVALID_RW_CHECK_MAX)
	recovery = best_check;
	}

	LoadFirmwareExit:
	VbExFree(root_key);

	/* Store recovery request, if any */
	VbNvSet(vnc, VBNV_RECOVERY_REQUEST, VBERROR_SUCCESS != retval ?
	recovery : VBNV_RECOVERY_NOT_REQUESTED);
	/* If the system does not support RO_NORMAL and LoadFirmware()
	* encountered an error, update the shared recovery reason if
	* recovery was not previously requested. */
	if (!(shared->flags & VBSD_BOOT_RO_NORMAL_SUPPORT) &&
	VBNV_RECOVERY_NOT_REQUESTED == shared->recovery_reason &&
	VBERROR_SUCCESS != retval) {
	VBDEBUG(("RO normal but we got an error.\n"));
	shared->recovery_reason = recovery;
	}

	return retval;
	}