/* Copyright 2014 The ChromiumOS Authors
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 *
 * Tests for api.c
 */

#include <stdio.h>

#include "2api.h"
#include "2common.h"
#include "2misc.h"
#include "2nvstorage.h"
#include "2rsa.h"
#include "2secdata.h"
#include "2sysincludes.h"
#include "common/tests.h"

/* Common context for tests */

static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
	__attribute__((aligned(VB2_WORKBUF_ALIGN)));
static struct vb2_context *ctx;
static struct vb2_shared_data *sd;
static struct vb2_gbb_header gbb;

const char mock_body[320] = "Mock body";
const int mock_body_size = sizeof(mock_body);
const int mock_algorithm = VB2_ALG_RSA2048_SHA256;
const int mock_hash_alg = VB2_HASH_SHA256;
static const uint8_t mock_hwid_digest[VB2_GBB_HWID_DIGEST_SIZE] = {
	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
	0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
	0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
};
const int mock_sig_size = 64;
static uint8_t digest_result[VB2_SHA256_DIGEST_SIZE];
static const uint32_t digest_result_size = sizeof(digest_result);

static const struct vb2_hash mock_mhash = {
	.algo = VB2_HASH_SHA256,
	.sha256 = {
		0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
		0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
		0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
		0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
	},
};

/* Mocked function data */

static int force_dev_mode;
static vb2_error_t retval_vb2_fw_init_gbb;
static vb2_error_t retval_vb2_check_dev_switch;
static vb2_error_t retval_vb2_check_tpm_clear;
static vb2_error_t retval_vb2_select_fw_slot;
static vb2_error_t retval_vb2_load_fw_keyblock;
static vb2_error_t retval_vb2_load_fw_preamble;
static vb2_error_t retval_vb2_digest_finalize;
static vb2_error_t retval_vb2_verify_digest;

/* Type of test to reset for */

enum reset_type {
	FOR_MISC,
	FOR_EXTEND_HASH,
	FOR_CHECK_HASH,
	FOR_METADATA_HASH,
};

static void reset_common_data(enum reset_type t)
{
	struct vb2_fw_preamble *pre;
	struct vb2_packed_key *k;

	memset(workbuf, 0xaa, sizeof(workbuf));

	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
		  "vb2api_init failed");
	sd = vb2_get_sd(ctx);

	vb2_nv_init(ctx);

	vb2api_secdata_firmware_create(ctx);

	vb2api_secdata_kernel_create(ctx);
	vb2_secdata_kernel_init(ctx);

	force_dev_mode = 0;
	retval_vb2_fw_init_gbb = VB2_SUCCESS;
	retval_vb2_check_dev_switch = VB2_SUCCESS;
	retval_vb2_check_tpm_clear = VB2_SUCCESS;
	retval_vb2_select_fw_slot = VB2_SUCCESS;
	retval_vb2_load_fw_keyblock = VB2_SUCCESS;
	retval_vb2_load_fw_preamble = VB2_SUCCESS;
	retval_vb2_digest_finalize = VB2_SUCCESS;
	retval_vb2_verify_digest = VB2_SUCCESS;

	memcpy(&gbb.hwid_digest, mock_hwid_digest,
	       sizeof(gbb.hwid_digest));

	sd->preamble_offset = sd->workbuf_used;
	sd->preamble_size = sizeof(*pre);
	vb2_set_workbuf_used(ctx, sd->preamble_offset + sd->preamble_size);
	pre = vb2_member_of(sd, sd->preamble_offset);
	sd->fw_version = 0x00030004U;
	sd->kernel_version = 0x00010002U;

	if (t == FOR_METADATA_HASH) {
		struct vb2_hash *mhash;
		pre->body_signature.data_size = 0;
		pre->body_signature.sig_size = offsetof(struct vb2_hash, raw) +
					       vb2_digest_size(mock_mhash.algo);
		pre->body_signature.sig_offset =
			vb2_offset_of(&pre->body_signature,
				      vb2_member_of(sd, sd->workbuf_used));
		pre->flags = 0;
		mhash = vb2_member_of(sd, sd->workbuf_used);
		vb2_set_workbuf_used(ctx, pre->body_signature.sig_size);
		memcpy(mhash, &mock_mhash, pre->body_signature.sig_size);
	} else {
		pre->body_signature.data_size = mock_body_size;
		pre->body_signature.sig_size = mock_sig_size;
		pre->flags = 0;

		sd->data_key_offset = sd->workbuf_used;
		sd->data_key_size = sizeof(*k) + 8;
		vb2_set_workbuf_used(ctx,
				     sd->data_key_offset + sd->data_key_size);
		k = vb2_member_of(sd, sd->data_key_offset);
		k->algorithm = mock_algorithm;
	}

	if (t == FOR_EXTEND_HASH || t == FOR_CHECK_HASH)
		vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY);

	if (t == FOR_CHECK_HASH)
		vb2api_extend_hash(ctx, mock_body, mock_body_size);

	/* Always clear out the digest result. */
	memset(digest_result, 0, digest_result_size);
};

/* Mocked functions */
struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
{
	return &gbb;
}

vb2_error_t vb2_fw_init_gbb(struct vb2_context *c)
{
	return retval_vb2_fw_init_gbb;
}

vb2_error_t vb2_check_dev_switch(struct vb2_context *c)
{
	if (force_dev_mode) {
		c->flags |= VB2_CONTEXT_DEVELOPER_MODE;
		sd->flags |= VB2_SD_FLAG_DEV_MODE_ENABLED;
	}
	return retval_vb2_check_dev_switch;
}

vb2_error_t vb2_check_tpm_clear(struct vb2_context *c)
{
	return retval_vb2_check_tpm_clear;
}

vb2_error_t vb2_select_fw_slot(struct vb2_context *c)
{
	return retval_vb2_select_fw_slot;
}

vb2_error_t vb2_load_fw_keyblock(struct vb2_context *c)
{
	return retval_vb2_load_fw_keyblock;
}

vb2_error_t vb2_load_fw_preamble(struct vb2_context *c)
{
	return retval_vb2_load_fw_preamble;
}

vb2_error_t vb2_unpack_key_buffer(struct vb2_public_key *key,
				  const uint8_t *buf, uint32_t size)
{
	struct vb2_packed_key *k = (struct vb2_packed_key *)buf;

	if (size != sizeof(*k) + 8)
		return VB2_ERROR_UNPACK_KEY_SIZE;

	key->sig_alg = vb2_crypto_to_signature(k->algorithm);
	key->hash_alg = vb2_crypto_to_hash(k->algorithm);

	return VB2_SUCCESS;
}

static void fill_digest(uint8_t *digest, uint32_t digest_size)
{
	/* Set the result to a known value. */
	memset(digest, 0x0a, digest_size);
}

vb2_error_t vb2_digest_init(struct vb2_digest_context *dc, bool allow_hwcrypto,
			    enum vb2_hash_algorithm algo, uint32_t data_size)
{
	if (algo != mock_hash_alg)
		return VB2_ERROR_SHA_INIT_ALGORITHM;

	dc->hash_alg = algo;
	dc->using_hwcrypto = 0;

	return VB2_SUCCESS;
}

vb2_error_t vb2_digest_extend(struct vb2_digest_context *dc, const uint8_t *buf,
			      uint32_t size)
{
	if (dc->hash_alg != mock_hash_alg)
		return VB2_ERROR_SHA_EXTEND_ALGORITHM;

	return VB2_SUCCESS;
}

vb2_error_t vb2_digest_finalize(struct vb2_digest_context *dc, uint8_t *digest,
				uint32_t digest_size)
{
	if (retval_vb2_digest_finalize == VB2_SUCCESS)
		fill_digest(digest, digest_size);

	return retval_vb2_digest_finalize;
}

uint32_t vb2_rsa_sig_size(enum vb2_signature_algorithm sig_alg)
{
	return mock_sig_size;
}

static struct vb2_public_key last_used_key;

vb2_error_t vb2_rsa_verify_digest(const struct vb2_public_key *key,
				  uint8_t *sig, const uint8_t *digest,
				  const struct vb2_workbuf *wb)
{
	memcpy(&last_used_key, key, sizeof(struct vb2_public_key));
	return retval_vb2_verify_digest;
}

/* Tests */
static int vb2_try_returned;

static vb2_error_t call_vb2_try(vb2_error_t expr, uint8_t recovery_reason,
				int one_arg)
{
	vb2_try_returned = 1;
	if (one_arg)
		VB2_TRY(expr);
	else
		VB2_TRY(expr, ctx, recovery_reason);
	vb2_try_returned = 0;
	return VB2_SUCCESS;
}

static void misc_tests(void)
{
	/* Test secdata_firmware passthru functions */
	reset_common_data(FOR_MISC);
	/* Corrupt secdata_firmware so initial check will fail */
	ctx->secdata_firmware[0] ^= 0x42;
	TEST_EQ(vb2api_secdata_firmware_check(ctx),
		VB2_ERROR_SECDATA_FIRMWARE_CRC,
		"secdata_firmware check");
	TEST_EQ(vb2api_secdata_firmware_create(ctx), VB2_SECDATA_FIRMWARE_SIZE,
		  "secdata_firmware create");
	TEST_SUCC(vb2api_secdata_firmware_check(ctx),
		  "secdata_firmware check 2");

	/* Test get_firmware_size() */
	reset_common_data(FOR_MISC);
	TEST_EQ(vb2api_get_firmware_size(ctx), mock_body_size, "firmware_size");

	reset_common_data(FOR_MISC);
	sd->preamble_size = 0;
	TEST_ABORT(vb2api_get_firmware_size(ctx), "firmware_size too early");

	/* Test VB2_TRY() */
	reset_common_data(FOR_MISC);
	call_vb2_try(VB2_SUCCESS, VB2_RECOVERY_NOT_REQUESTED, 1);
	TEST_EQ(vb2_try_returned, 0, "VB2_TRY(expr) success");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		VB2_RECOVERY_NOT_REQUESTED, "  vb2api_fail no request");

	reset_common_data(FOR_MISC);
	call_vb2_try(VB2_REQUEST, VB2_RECOVERY_NOT_REQUESTED, 1);
	TEST_EQ(vb2_try_returned, 1, "VB2_TRY(expr) request");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		VB2_RECOVERY_NOT_REQUESTED, "  vb2api_fail no request");

	reset_common_data(FOR_MISC);
	call_vb2_try(VB2_ERROR_MOCK, VB2_RECOVERY_NOT_REQUESTED, 1);
	TEST_EQ(vb2_try_returned, 1, "VB2_TRY(expr) error");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		VB2_RECOVERY_NOT_REQUESTED, "  vb2api_fail no request");

	reset_common_data(FOR_MISC);
	call_vb2_try(VB2_SUCCESS, 123, 0);
	TEST_EQ(vb2_try_returned, 0, "VB2_TRY(expr, ...) success");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		VB2_RECOVERY_NOT_REQUESTED, "  vb2api_fail no request");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_SUBCODE),
		0, "  vb2api_fail no subcode");

	reset_common_data(FOR_MISC);
	call_vb2_try(VB2_REQUEST, 123, 0);
	TEST_EQ(vb2_try_returned, 1, "VB2_TRY(expr, ...) request");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		VB2_RECOVERY_NOT_REQUESTED, "  vb2api_fail no request");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_SUBCODE),
		0, "  vb2api_fail no subcode");

	reset_common_data(FOR_MISC);
	call_vb2_try(VB2_ERROR_MOCK, 123, 0);
	TEST_EQ(vb2_try_returned, 1, "VB2_TRY(expr, ...) error");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		123, "  vb2api_fail request");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_SUBCODE),
		VB2_ERROR_MOCK & 0xff, "  vb2api_fail subcode");
}

static void phase1_tests(void)
{
	reset_common_data(FOR_MISC);
	TEST_SUCC(vb2api_fw_phase1(ctx), "phase1 good");
	TEST_EQ(sd->recovery_reason, 0, "  not recovery");
	TEST_EQ(ctx->flags & VB2_CONTEXT_RECOVERY_MODE, 0, "  recovery flag");
	TEST_EQ(ctx->flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
	TEST_EQ(ctx->flags & VB2_CONTEXT_DISPLAY_INIT,
		0, "  display init context flag");
	TEST_EQ(sd->flags & VB2_SD_FLAG_DISPLAY_AVAILABLE,
		0, "  display available SD flag");
	TEST_NEQ(sd->status & VB2_SD_STATUS_SECDATA_FIRMWARE_INIT,
		 0, "  secdata firmware initialized");
	TEST_NEQ(sd->status & VB2_SD_STATUS_SECDATA_KERNEL_INIT,
		 0, "  secdata kernel initialized");
	TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
		 0, "  recovery decided");

	reset_common_data(FOR_MISC);
	retval_vb2_fw_init_gbb = VB2_ERROR_GBB_MAGIC;
	TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_RECOVERY,
		"phase1 gbb");
	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_GBB_HEADER,
		"  recovery reason");
	TEST_NEQ(ctx->flags & VB2_CONTEXT_RECOVERY_MODE, 0, "  recovery flag");
	TEST_NEQ(ctx->flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
	TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
		 0, "  recovery decided");

	/* Dev switch error proceeds to a recovery boot */
	reset_common_data(FOR_MISC);
	retval_vb2_check_dev_switch = VB2_ERROR_MOCK;
	TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_RECOVERY,
		"phase1 dev switch error proceeds to recovery");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		VB2_RECOVERY_DEV_SWITCH, "  recovery request");
	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_DEV_SWITCH,
		"  recovery reason");
	/* Check that DISPLAY_AVAILABLE gets set on recovery mode. */
	TEST_NEQ(ctx->flags & VB2_CONTEXT_DISPLAY_INIT,
		 0, "  display init context flag");
	TEST_NEQ(sd->flags & VB2_SD_FLAG_DISPLAY_AVAILABLE,
		 0, "  display available SD flag");
	TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
		 0, "  recovery decided");

	reset_common_data(FOR_MISC);
	ctx->secdata_firmware[0] ^= 0x42;
	TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_RECOVERY,
		"phase1 secdata_firmware");
	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_SECDATA_FIRMWARE_INIT,
		"  recovery reason");
	TEST_NEQ(ctx->flags & VB2_CONTEXT_RECOVERY_MODE, 0, "  recovery flag");
	TEST_NEQ(ctx->flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
	TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
		 0, "  recovery decided");

	/* Bad secdata_kernel causes recovery mode */
	reset_common_data(FOR_MISC);
	ctx->secdata_kernel[2] ^= 0x42;  /* 3rd byte is CRC */
	TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_RECOVERY,
		"phase1 bad secdata_kernel");
	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_SECDATA_KERNEL_INIT,
		"  recovery reason");
	TEST_NEQ(ctx->flags & VB2_CONTEXT_RECOVERY_MODE, 0, "  recovery flag");
	TEST_NEQ(ctx->flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
	TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
		 0, "  recovery decided");

	/* Test secdata_firmware-requested reboot */
	reset_common_data(FOR_MISC);
	ctx->flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
	TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_SECDATA_REBOOT,
		"phase1 secdata_firmware reboot normal");
	TEST_EQ(sd->recovery_reason, 0,	"  recovery reason");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_TPM_REQUESTED_REBOOT),
		1, "  tpm reboot request");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		0, "  recovery request");
	TEST_EQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
		0, "  recovery decided");

	reset_common_data(FOR_MISC);
	vb2_nv_set(ctx, VB2_NV_TPM_REQUESTED_REBOOT, 1);
	TEST_SUCC(vb2api_fw_phase1(ctx),
		  "phase1 secdata_firmware reboot back normal");
	TEST_EQ(sd->recovery_reason, 0,	"  recovery reason");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_TPM_REQUESTED_REBOOT),
		0, "  tpm reboot request");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		0, "  recovery request");
	TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
		 0, "  recovery decided");

	reset_common_data(FOR_MISC);
	ctx->flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
	memset(ctx->secdata_firmware, 0, sizeof(ctx->secdata_firmware));
	TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_SECDATA_REBOOT,
		"phase1 secdata_firmware reboot normal, "
		"secdata_firmware blank");
	TEST_EQ(sd->recovery_reason, 0,	"  recovery reason");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_TPM_REQUESTED_REBOOT),
		1, "  tpm reboot request");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		0, "  recovery request");
	TEST_EQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
		0, "  recovery decided");

	reset_common_data(FOR_MISC);
	ctx->flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
	vb2_nv_set(ctx, VB2_NV_TPM_REQUESTED_REBOOT, 1);
	TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_RECOVERY,
		"phase1 secdata_firmware reboot normal again");
	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_TPM_REBOOT,
		"  recovery reason");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_TPM_REQUESTED_REBOOT),
		1, "  tpm reboot request");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		VB2_RECOVERY_RO_TPM_REBOOT, "  recovery request");
	TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
		 0, "  recovery decided");

	reset_common_data(FOR_MISC);
	ctx->flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
	vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED);
	TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_SECDATA_REBOOT,
		"phase1 secdata_firmware reboot recovery");
	/* Recovery reason isn't set this boot because we're rebooting first */
	TEST_EQ(sd->recovery_reason, 0, "  recovery reason not set THIS boot");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_TPM_REQUESTED_REBOOT),
		1, "  tpm reboot request");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		VB2_RECOVERY_RO_UNSPECIFIED, "  recovery request");
	TEST_EQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
		0, "  recovery decided");

	reset_common_data(FOR_MISC);
	vb2_nv_set(ctx, VB2_NV_TPM_REQUESTED_REBOOT, 1);
	vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED);
	TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_RECOVERY,
		"phase1 secdata_firmware reboot back recovery");
	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_UNSPECIFIED,
		"  recovery reason");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_TPM_REQUESTED_REBOOT),
		0, "  tpm reboot request");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		VB2_RECOVERY_RO_UNSPECIFIED, "  recovery request");
	TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
		 0, "  recovery decided");

	reset_common_data(FOR_MISC);
	ctx->flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
	vb2_nv_set(ctx, VB2_NV_TPM_REQUESTED_REBOOT, 1);
	vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED);
	TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_RECOVERY,
		"phase1 secdata_firmware reboot recovery again");
	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_UNSPECIFIED,
		"  recovery reason");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_TPM_REQUESTED_REBOOT),
		1, "  tpm reboot request");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		VB2_RECOVERY_RO_UNSPECIFIED, "  recovery request");
	TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
		 0, "  recovery decided");

	/* Cases for checking DISPLAY_INIT and DISPLAY_AVAILABLE. */
	reset_common_data(FOR_MISC);
	ctx->flags |= VB2_CONTEXT_DISPLAY_INIT;
	TEST_SUCC(vb2api_fw_phase1(ctx), "phase1 with DISPLAY_INIT");
	TEST_NEQ(ctx->flags & VB2_CONTEXT_DISPLAY_INIT,
		 0, "  display init context flag");
	TEST_NEQ(sd->flags & VB2_SD_FLAG_DISPLAY_AVAILABLE,
		 0, "  display available SD flag");
	TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
		 0, "  recovery decided");

	reset_common_data(FOR_MISC);
	vb2_nv_set(ctx, VB2_NV_DISPLAY_REQUEST, 1);
	TEST_SUCC(vb2api_fw_phase1(ctx), "phase1 with DISPLAY_REQUEST");
	TEST_NEQ(ctx->flags & VB2_CONTEXT_DISPLAY_INIT,
		 0, "  display init context flag");
	TEST_NEQ(sd->flags & VB2_SD_FLAG_DISPLAY_AVAILABLE,
		 0, "  display available SD flag");
	TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
		 0, "  recovery decided");

	reset_common_data(FOR_MISC);
	force_dev_mode = 1;
	TEST_SUCC(vb2api_fw_phase1(ctx), "phase1 in dev mode");
	TEST_NEQ(ctx->flags & VB2_CONTEXT_DISPLAY_INIT,
		 0, "  display init context flag");
	TEST_NEQ(sd->flags & VB2_SD_FLAG_DISPLAY_AVAILABLE,
		 0, "  display available SD flag");
	TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
		 0, "  recovery decided");
}

static void phase2_tests(void)
{
	reset_common_data(FOR_MISC);
	TEST_SUCC(vb2api_fw_phase2(ctx), "phase2 good");
	TEST_EQ(ctx->flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
	TEST_EQ(ctx->flags & VB2_CONTEXT_FW_SLOT_B, 0, "  slot b flag");

	reset_common_data(FOR_MISC);
	ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
	TEST_SUCC(vb2api_fw_phase2(ctx), "phase2 dev");
	TEST_NEQ(ctx->flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");

	reset_common_data(FOR_MISC);
	retval_vb2_check_tpm_clear = VB2_ERROR_MOCK;
	TEST_EQ(vb2api_fw_phase2(ctx), VB2_ERROR_MOCK, "phase2 tpm clear");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		VB2_RECOVERY_TPM_CLEAR_OWNER, "  recovery reason");

	reset_common_data(FOR_MISC);
	retval_vb2_select_fw_slot = VB2_ERROR_MOCK;
	TEST_EQ(vb2api_fw_phase2(ctx), VB2_ERROR_MOCK, "phase2 slot");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		VB2_RECOVERY_FW_SLOT, "  recovery reason");

	/* S3 resume exits before clearing RAM */
	reset_common_data(FOR_MISC);
	ctx->flags |= VB2_CONTEXT_S3_RESUME;
	ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
	TEST_SUCC(vb2api_fw_phase2(ctx), "phase2 s3 dev");
	TEST_EQ(ctx->flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
	TEST_EQ(ctx->flags & VB2_CONTEXT_FW_SLOT_B, 0, "  slot b flag");

	reset_common_data(FOR_MISC);
	ctx->flags |= VB2_CONTEXT_S3_RESUME;
	vb2_nv_set(ctx, VB2_NV_FW_TRIED, 1);
	TEST_SUCC(vb2api_fw_phase2(ctx), "phase2 s3");
	TEST_NEQ(ctx->flags & VB2_CONTEXT_FW_SLOT_B, 0, "  slot b flag");
}

static void get_pcr_digest_tests(void)
{
	uint8_t digest[VB2_PCR_DIGEST_RECOMMENDED_SIZE];
	uint8_t digest_org[VB2_PCR_DIGEST_RECOMMENDED_SIZE];
	uint8_t fw_ver_digest[VB2_PCR_DIGEST_RECOMMENDED_SIZE] = {0x04, 0x00,
								  0x03, 0x00};
	uint8_t ker_ver_digest[VB2_PCR_DIGEST_RECOMMENDED_SIZE] = {0x02, 0x00,
								   0x01, 0x00};
	uint32_t digest_size;

	reset_common_data(FOR_MISC);
	memset(digest_org, 0, sizeof(digest_org));

	digest_size = sizeof(digest);
	memset(digest, 0, sizeof(digest));
	TEST_SUCC(vb2api_get_pcr_digest(
			ctx, BOOT_MODE_PCR, digest, &digest_size),
		  "BOOT_MODE_PCR");
	TEST_EQ(digest_size, VB2_SHA1_DIGEST_SIZE, "BOOT_MODE_PCR digest size");
	TEST_TRUE(memcmp(digest, digest_org, digest_size),
		  "BOOT_MODE_PCR digest");

	digest_size = sizeof(digest);
	memset(digest, 0, sizeof(digest));
	TEST_SUCC(vb2api_get_pcr_digest(
			ctx, HWID_DIGEST_PCR, digest, &digest_size),
		  "HWID_DIGEST_PCR");
	TEST_EQ(digest_size, VB2_GBB_HWID_DIGEST_SIZE,
		"HWID_DIGEST_PCR digest size");
	TEST_FALSE(memcmp(digest, mock_hwid_digest, digest_size),
		   "HWID_DIGEST_PCR digest");

	digest_size = sizeof(digest);
	memset(digest, 0, sizeof(digest));
	TEST_SUCC(vb2api_get_pcr_digest(ctx, FIRMWARE_VERSION_PCR, digest,
					&digest_size),
		  "FIRMWARE_DIGEST_PCR");
	TEST_EQ(digest_size, sizeof(uint32_t),
		"FIRMWARE_DIGEST_PCR digest size");
	TEST_FALSE(memcmp(digest, fw_ver_digest, digest_size),
		   "FIRMWARE_DIGEST_PCR digest");

	digest_size = sizeof(digest);
	memset(digest, 0, sizeof(digest));
	TEST_SUCC(vb2api_get_pcr_digest(ctx, KERNEL_VERSION_PCR, digest,
					&digest_size),
		  "KERNEL_DIGEST_PCR");
	TEST_EQ(digest_size, sizeof(uint32_t), "KERNEL_DIGEST_PCR digest size");
	TEST_FALSE(memcmp(digest, ker_ver_digest, digest_size),
		   "KERNEL_DIGEST_PCR digest");

	digest_size = 1;
	TEST_EQ(vb2api_get_pcr_digest(ctx, BOOT_MODE_PCR, digest, &digest_size),
		VB2_ERROR_API_PCR_DIGEST_BUF,
		"BOOT_MODE_PCR buffer too small");

	TEST_EQ(vb2api_get_pcr_digest(ctx, 255, digest, &digest_size),
		VB2_ERROR_API_PCR_DIGEST, "invalid enum vb2_pcr_digest");
}

static void phase3_tests(void)
{
	reset_common_data(FOR_MISC);
	TEST_SUCC(vb2api_fw_phase3(ctx), "phase3 good");

	reset_common_data(FOR_MISC);
	retval_vb2_load_fw_keyblock = VB2_ERROR_MOCK;
	TEST_EQ(vb2api_fw_phase3(ctx), VB2_ERROR_MOCK, "phase3 keyblock");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		VB2_RECOVERY_RO_INVALID_RW, "  recovery reason");

	reset_common_data(FOR_MISC);
	retval_vb2_load_fw_preamble = VB2_ERROR_MOCK;
	TEST_EQ(vb2api_fw_phase3(ctx), VB2_ERROR_MOCK, "phase3 keyblock");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
		VB2_RECOVERY_RO_INVALID_RW, "  recovery reason");
}

static void init_hash_tests(void)
{
	struct vb2_packed_key *k;
	int wb_used_before;
	struct vb2_fw_preamble *pre;

	/* For now, all we support is body signature hash */
	reset_common_data(FOR_MISC);
	wb_used_before = sd->workbuf_used;
	TEST_SUCC(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY),
		  "init hash good");
	TEST_EQ(sd->hash_offset, wb_used_before, "hash context offset");
	TEST_EQ(sd->hash_size, sizeof(struct vb2_digest_context),
		"hash context size");
	TEST_EQ(sd->workbuf_used,
		vb2_wb_round_up(sd->hash_offset + sd->hash_size),
		"hash uses workbuf");
	TEST_EQ(sd->hash_tag, VB2_HASH_TAG_FW_BODY, "hash tag");
	TEST_EQ(sd->hash_remaining_size, mock_body_size, "hash remaining");

	wb_used_before = sd->workbuf_used;
	TEST_SUCC(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY),
		  "init hash again");
	TEST_EQ(sd->workbuf_used, wb_used_before, "init hash reuses context");

	reset_common_data(FOR_MISC);
	TEST_EQ(vb2api_init_hash(ctx, VB2_HASH_TAG_INVALID),
		VB2_ERROR_API_INIT_HASH_TAG, "init hash invalid tag");

	reset_common_data(FOR_MISC);
	sd->preamble_size = 0;
	TEST_EQ(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY),
		VB2_ERROR_API_INIT_HASH_PREAMBLE, "init hash preamble");

	reset_common_data(FOR_MISC);
	TEST_EQ(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY + 1),
		VB2_ERROR_API_INIT_HASH_TAG, "init hash unknown tag");

	reset_common_data(FOR_MISC);
	sd->workbuf_used = sd->workbuf_size + VB2_WORKBUF_ALIGN -
			vb2_wb_round_up(sizeof(struct vb2_digest_context));
	TEST_EQ(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY),
		VB2_ERROR_API_INIT_HASH_WORKBUF, "init hash workbuf");

	reset_common_data(FOR_MISC);
	sd->data_key_size = 0;
	TEST_EQ(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY),
		VB2_ERROR_API_INIT_HASH_DATA_KEY, "init hash data key");

	reset_common_data(FOR_MISC);
	pre = vb2_member_of(sd, sd->preamble_offset);
	pre->body_signature.data_size = 0;
	TEST_EQ(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY),
		VB2_ERROR_API_INIT_HASH_DATA_KEY, "init hash data size");

	reset_common_data(FOR_MISC);
	sd->data_key_size--;
	TEST_EQ(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY),
		VB2_ERROR_UNPACK_KEY_SIZE, "init hash data key size");

	reset_common_data(FOR_MISC);
	k = vb2_member_of(sd, sd->data_key_offset);
	k->algorithm--;
	TEST_EQ(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY),
		VB2_ERROR_SHA_INIT_ALGORITHM, "init hash algorithm");
}

static void extend_hash_tests(void)
{
	struct vb2_digest_context *dc;

	reset_common_data(FOR_EXTEND_HASH);
	TEST_SUCC(vb2api_extend_hash(ctx, mock_body, 32),
		"hash extend good");
	TEST_EQ(sd->hash_remaining_size, mock_body_size - 32,
		"hash extend remaining");
	TEST_SUCC(vb2api_extend_hash(ctx, mock_body, mock_body_size - 32),
		"hash extend again");
	TEST_EQ(sd->hash_remaining_size, 0, "hash extend remaining 2");

	reset_common_data(FOR_EXTEND_HASH);
	sd->hash_size = 0;
	TEST_EQ(vb2api_extend_hash(ctx, mock_body, mock_body_size),
		VB2_ERROR_API_EXTEND_HASH_WORKBUF, "hash extend no workbuf");

	reset_common_data(FOR_EXTEND_HASH);
	TEST_EQ(vb2api_extend_hash(ctx, mock_body, mock_body_size + 1),
		VB2_ERROR_API_EXTEND_HASH_SIZE, "hash extend too much");

	reset_common_data(FOR_EXTEND_HASH);
	TEST_EQ(vb2api_extend_hash(ctx, mock_body, 0),
		VB2_ERROR_API_EXTEND_HASH_SIZE, "hash extend empty");

	reset_common_data(FOR_EXTEND_HASH);
	dc = (struct vb2_digest_context *)vb2_member_of(sd, sd->hash_offset);
	dc->hash_alg = mock_hash_alg + 1;
	TEST_EQ(vb2api_extend_hash(ctx, mock_body, mock_body_size),
		VB2_ERROR_SHA_EXTEND_ALGORITHM, "hash extend fail");
}

static void check_hash_tests(void)
{
	struct vb2_fw_preamble *pre;
	const uint32_t digest_value = 0x0a0a0a0a;

	reset_common_data(FOR_CHECK_HASH);
	TEST_SUCC(vb2api_check_hash(ctx), "check hash good");

	reset_common_data(FOR_CHECK_HASH);
	TEST_SUCC(vb2api_check_hash_get_digest(ctx, digest_result,
			digest_result_size), "check hash good with result");
	/* Check the first 4 bytes to ensure it was copied over. */
	TEST_SUCC(memcmp(digest_result, &digest_value, sizeof(digest_value)),
		"check digest value");

	/* Test hwcrypto conditions */
	reset_common_data(FOR_CHECK_HASH);
	TEST_SUCC(vb2api_check_hash(ctx), "check hash good");
	TEST_EQ(last_used_key.allow_hwcrypto, 0,
		"hwcrypto is forbidden by TPM flag");

	reset_common_data(FOR_CHECK_HASH);
	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
	TEST_SUCC(vb2api_check_hash(ctx), "check hash good");
	TEST_EQ(last_used_key.allow_hwcrypto, 0,
		"hwcrypto is forbidden by TPM flag on recovery mode");

	reset_common_data(FOR_CHECK_HASH);
	vb2_secdata_kernel_set(ctx, VB2_SECDATA_KERNEL_FLAGS,
			       VB2_SECDATA_KERNEL_FLAG_HWCRYPTO_ALLOWED);
	TEST_SUCC(vb2api_check_hash(ctx), "check hash good");
	TEST_EQ(last_used_key.allow_hwcrypto, 1, "hwcrypto is allowed");

	reset_common_data(FOR_CHECK_HASH);
	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
	vb2_secdata_kernel_set(ctx, VB2_SECDATA_KERNEL_FLAGS,
			       VB2_SECDATA_KERNEL_FLAG_HWCRYPTO_ALLOWED);
	TEST_SUCC(vb2api_check_hash(ctx), "check hash good");
	TEST_EQ(last_used_key.allow_hwcrypto, 0,
		"hwcrypto is forbidden on recovery mode");

	reset_common_data(FOR_CHECK_HASH);
	TEST_EQ(vb2api_check_hash_get_digest(ctx, digest_result,
			digest_result_size - 1),
		VB2_ERROR_API_CHECK_DIGEST_SIZE, "check digest size");
	TEST_NEQ(memcmp(digest_result, &digest_value, sizeof(digest_value)), 0,
		"check digest wrong size");

	reset_common_data(FOR_CHECK_HASH);
	sd->preamble_size = 0;
	TEST_EQ(vb2api_check_hash(ctx),
		VB2_ERROR_API_CHECK_HASH_PREAMBLE, "check hash preamble");

	reset_common_data(FOR_CHECK_HASH);
	sd->hash_size = 0;
	TEST_EQ(vb2api_check_hash(ctx),
		VB2_ERROR_API_CHECK_HASH_WORKBUF, "check hash no workbuf");

	reset_common_data(FOR_CHECK_HASH);
	sd->hash_remaining_size = 1;
	TEST_EQ(vb2api_check_hash(ctx),
		VB2_ERROR_API_CHECK_HASH_SIZE, "check hash size");

	reset_common_data(FOR_CHECK_HASH);
	sd->workbuf_used = sd->workbuf_size;
	TEST_EQ(vb2api_check_hash(ctx),
		VB2_ERROR_API_CHECK_HASH_WORKBUF_DIGEST, "check hash workbuf");

	reset_common_data(FOR_CHECK_HASH);
	retval_vb2_digest_finalize = VB2_ERROR_MOCK;
	TEST_EQ(vb2api_check_hash(ctx), VB2_ERROR_MOCK, "check hash finalize");

	reset_common_data(FOR_CHECK_HASH);
	sd->hash_tag = VB2_HASH_TAG_INVALID;
	TEST_EQ(vb2api_check_hash(ctx),
		VB2_ERROR_API_CHECK_HASH_TAG, "check hash tag");

	reset_common_data(FOR_CHECK_HASH);
	sd->data_key_size = 0;
	TEST_EQ(vb2api_check_hash(ctx),
		VB2_ERROR_API_CHECK_HASH_DATA_KEY, "check hash data key");

	reset_common_data(FOR_CHECK_HASH);
	sd->data_key_size--;
	TEST_EQ(vb2api_check_hash(ctx),
		VB2_ERROR_UNPACK_KEY_SIZE, "check hash data key size");

	reset_common_data(FOR_CHECK_HASH);
	pre = vb2_member_of(sd, sd->preamble_offset);
	pre->body_signature.sig_size++;
	TEST_EQ(vb2api_check_hash(ctx),
		VB2_ERROR_VDATA_SIG_SIZE, "check hash sig size");

	reset_common_data(FOR_CHECK_HASH);
	retval_vb2_digest_finalize = VB2_ERROR_RSA_VERIFY_DIGEST;
	TEST_EQ(vb2api_check_hash(ctx),
		VB2_ERROR_RSA_VERIFY_DIGEST, "check hash finalize");
}

static void get_metadata_hash_test(void)
{
	struct vb2_hash *hash;
	struct vb2_fw_preamble *pre;

	reset_common_data(FOR_MISC);
	TEST_EQ(vb2api_get_metadata_hash(ctx, &hash),
		VB2_ERROR_API_INIT_HASH_DATA_KEY, "check body sig data size");

	reset_common_data(FOR_MISC);
	sd->preamble_size = 0;
	TEST_EQ(vb2api_get_metadata_hash(ctx, &hash),
		VB2_ERROR_API_CHECK_HASH_PREAMBLE, "check preamble size");

	reset_common_data(FOR_METADATA_HASH);
	pre = vb2_member_of(sd, sd->preamble_offset);
	pre->body_signature.sig_size = 8;
	TEST_EQ(vb2api_get_metadata_hash(ctx, &hash),
		VB2_ERROR_API_CHECK_HASH_SIG_SIZE, "check too small sig size");

	reset_common_data(FOR_METADATA_HASH);
	pre = vb2_member_of(sd, sd->preamble_offset);
	pre->body_signature.data_size = mock_body_size;
	TEST_EQ(vb2api_get_metadata_hash(ctx, &hash),
		VB2_ERROR_API_INIT_HASH_DATA_KEY, "check incorrect data size");

	reset_common_data(FOR_METADATA_HASH);
	pre = vb2_member_of(sd, sd->preamble_offset);
	hash = (struct vb2_hash *)vb2_signature_data_mutable(
		&pre->body_signature);
	hash->algo = VB2_HASH_INVALID;
	TEST_EQ(vb2api_get_metadata_hash(ctx, &hash),
		VB2_ERROR_API_CHECK_HASH_SIG_SIZE, "check unsupported algo");

	reset_common_data(FOR_METADATA_HASH);
	TEST_EQ(vb2api_get_metadata_hash(ctx, &hash), VB2_SUCCESS,
		"check metadata hash get");
	TEST_PTR_NEQ(hash, NULL, "check metadata hash not null");
	TEST_EQ(hash->algo, mock_mhash.algo, "check metadata hash algo");
	TEST_EQ(memcmp(hash->raw, mock_mhash.raw,
		       vb2_digest_size(mock_mhash.algo)),
		0, "check metadata hash digest");
}

int main(int argc, char* argv[])
{
	misc_tests();
	phase1_tests();
	phase2_tests();
	phase3_tests();

	init_hash_tests();
	extend_hash_tests();
	check_hash_tests();

	get_metadata_hash_test();

	get_pcr_digest_tests();

	return gTestSuccess ? 0 : 255;
}